Commit | Line | Data |
---|---|---|
9bbf86fe BG |
1 | /* |
2 | * Copyright (C) STMicroelectronics SA 2014 | |
3 | * Author: Benjamin Gaignard <benjamin.gaignard@st.com> for STMicroelectronics. | |
4 | * License terms: GNU General Public License (GPL), version 2 | |
5 | */ | |
6 | ||
7 | #include <drm/drmP.h> | |
8 | ||
9 | #include <linux/component.h> | |
10 | #include <linux/debugfs.h> | |
11 | #include <linux/kernel.h> | |
12 | #include <linux/module.h> | |
13 | #include <linux/of_platform.h> | |
14 | ||
de4b00b0 BG |
15 | #include <drm/drm_atomic.h> |
16 | #include <drm/drm_atomic_helper.h> | |
9bbf86fe BG |
17 | #include <drm/drm_crtc_helper.h> |
18 | #include <drm/drm_gem_cma_helper.h> | |
19 | #include <drm/drm_fb_cma_helper.h> | |
20 | ||
9e1f05b2 VA |
21 | #include "sti_crtc.h" |
22 | #include "sti_drv.h" | |
9bbf86fe BG |
23 | |
24 | #define DRIVER_NAME "sti" | |
25 | #define DRIVER_DESC "STMicroelectronics SoC DRM" | |
26 | #define DRIVER_DATE "20140601" | |
27 | #define DRIVER_MAJOR 1 | |
28 | #define DRIVER_MINOR 0 | |
29 | ||
30 | #define STI_MAX_FB_HEIGHT 4096 | |
31 | #define STI_MAX_FB_WIDTH 4096 | |
32 | ||
9e1f05b2 VA |
33 | static void sti_atomic_schedule(struct sti_private *private, |
34 | struct drm_atomic_state *state) | |
de4b00b0 BG |
35 | { |
36 | private->commit.state = state; | |
37 | schedule_work(&private->commit.work); | |
38 | } | |
39 | ||
9e1f05b2 VA |
40 | static void sti_atomic_complete(struct sti_private *private, |
41 | struct drm_atomic_state *state) | |
de4b00b0 BG |
42 | { |
43 | struct drm_device *drm = private->drm_dev; | |
44 | ||
45 | /* | |
46 | * Everything below can be run asynchronously without the need to grab | |
47 | * any modeset locks at all under one condition: It must be guaranteed | |
48 | * that the asynchronous work has either been cancelled (if the driver | |
49 | * supports it, which at least requires that the framebuffers get | |
50 | * cleaned up with drm_atomic_helper_cleanup_planes()) or completed | |
51 | * before the new state gets committed on the software side with | |
52 | * drm_atomic_helper_swap_state(). | |
53 | * | |
54 | * This scheme allows new atomic state updates to be prepared and | |
55 | * checked in parallel to the asynchronous completion of the previous | |
56 | * update. Which is important since compositors need to figure out the | |
57 | * composition of the next frame right after having submitted the | |
58 | * current layout. | |
59 | */ | |
60 | ||
61 | drm_atomic_helper_commit_modeset_disables(drm, state); | |
aef9dbb8 | 62 | drm_atomic_helper_commit_planes(drm, state, false); |
de4b00b0 BG |
63 | drm_atomic_helper_commit_modeset_enables(drm, state); |
64 | ||
65 | drm_atomic_helper_wait_for_vblanks(drm, state); | |
66 | ||
67 | drm_atomic_helper_cleanup_planes(drm, state); | |
68 | drm_atomic_state_free(state); | |
69 | } | |
70 | ||
9e1f05b2 | 71 | static void sti_atomic_work(struct work_struct *work) |
de4b00b0 | 72 | { |
9e1f05b2 VA |
73 | struct sti_private *private = container_of(work, |
74 | struct sti_private, commit.work); | |
de4b00b0 | 75 | |
9e1f05b2 | 76 | sti_atomic_complete(private, private->commit.state); |
de4b00b0 BG |
77 | } |
78 | ||
9e1f05b2 VA |
79 | static int sti_atomic_commit(struct drm_device *drm, |
80 | struct drm_atomic_state *state, bool async) | |
de4b00b0 | 81 | { |
9e1f05b2 | 82 | struct sti_private *private = drm->dev_private; |
de4b00b0 BG |
83 | int err; |
84 | ||
85 | err = drm_atomic_helper_prepare_planes(drm, state); | |
86 | if (err) | |
87 | return err; | |
88 | ||
89 | /* serialize outstanding asynchronous commits */ | |
90 | mutex_lock(&private->commit.lock); | |
91 | flush_work(&private->commit.work); | |
92 | ||
93 | /* | |
94 | * This is the point of no return - everything below never fails except | |
95 | * when the hw goes bonghits. Which means we can commit the new state on | |
96 | * the software side now. | |
97 | */ | |
98 | ||
99 | drm_atomic_helper_swap_state(drm, state); | |
100 | ||
101 | if (async) | |
9e1f05b2 | 102 | sti_atomic_schedule(private, state); |
de4b00b0 | 103 | else |
9e1f05b2 | 104 | sti_atomic_complete(private, state); |
de4b00b0 BG |
105 | |
106 | mutex_unlock(&private->commit.lock); | |
107 | return 0; | |
108 | } | |
109 | ||
c5de4853 | 110 | static const struct drm_mode_config_funcs sti_mode_config_funcs = { |
9bbf86fe | 111 | .fb_create = drm_fb_cma_create, |
de4b00b0 | 112 | .atomic_check = drm_atomic_helper_check, |
9e1f05b2 | 113 | .atomic_commit = sti_atomic_commit, |
9bbf86fe BG |
114 | }; |
115 | ||
9e1f05b2 | 116 | static void sti_mode_config_init(struct drm_device *dev) |
9bbf86fe BG |
117 | { |
118 | dev->mode_config.min_width = 0; | |
119 | dev->mode_config.min_height = 0; | |
120 | ||
121 | /* | |
122 | * set max width and height as default value. | |
123 | * this value would be used to check framebuffer size limitation | |
124 | * at drm_mode_addfb(). | |
125 | */ | |
738be9d6 VA |
126 | dev->mode_config.max_width = STI_MAX_FB_WIDTH; |
127 | dev->mode_config.max_height = STI_MAX_FB_HEIGHT; | |
9bbf86fe | 128 | |
9e1f05b2 | 129 | dev->mode_config.funcs = &sti_mode_config_funcs; |
9bbf86fe BG |
130 | } |
131 | ||
9e1f05b2 | 132 | static int sti_load(struct drm_device *dev, unsigned long flags) |
9bbf86fe | 133 | { |
9e1f05b2 | 134 | struct sti_private *private; |
9bbf86fe BG |
135 | int ret; |
136 | ||
9e1f05b2 | 137 | private = kzalloc(sizeof(*private), GFP_KERNEL); |
9bbf86fe BG |
138 | if (!private) { |
139 | DRM_ERROR("Failed to allocate private\n"); | |
140 | return -ENOMEM; | |
141 | } | |
142 | dev->dev_private = (void *)private; | |
143 | private->drm_dev = dev; | |
144 | ||
de4b00b0 | 145 | mutex_init(&private->commit.lock); |
9e1f05b2 | 146 | INIT_WORK(&private->commit.work, sti_atomic_work); |
de4b00b0 | 147 | |
9bbf86fe BG |
148 | drm_mode_config_init(dev); |
149 | drm_kms_helper_poll_init(dev); | |
150 | ||
9e1f05b2 | 151 | sti_mode_config_init(dev); |
9bbf86fe BG |
152 | |
153 | ret = component_bind_all(dev->dev, dev); | |
f78e772a BG |
154 | if (ret) { |
155 | drm_kms_helper_poll_fini(dev); | |
156 | drm_mode_config_cleanup(dev); | |
157 | kfree(private); | |
9bbf86fe | 158 | return ret; |
f78e772a | 159 | } |
9bbf86fe | 160 | |
de4b00b0 | 161 | drm_mode_config_reset(dev); |
9bbf86fe | 162 | |
4314e19e | 163 | drm_helper_disable_unused_functions(dev); |
9bbf86fe | 164 | drm_fbdev_cma_init(dev, 32, |
9e1f05b2 VA |
165 | dev->mode_config.num_crtc, |
166 | dev->mode_config.num_connector); | |
b5d34a27 | 167 | |
9bbf86fe BG |
168 | return 0; |
169 | } | |
170 | ||
9e1f05b2 | 171 | static const struct file_operations sti_driver_fops = { |
9bbf86fe BG |
172 | .owner = THIS_MODULE, |
173 | .open = drm_open, | |
174 | .mmap = drm_gem_cma_mmap, | |
175 | .poll = drm_poll, | |
176 | .read = drm_read, | |
177 | .unlocked_ioctl = drm_ioctl, | |
178 | #ifdef CONFIG_COMPAT | |
179 | .compat_ioctl = drm_compat_ioctl, | |
180 | #endif | |
181 | .release = drm_release, | |
182 | }; | |
183 | ||
9e1f05b2 VA |
184 | static struct dma_buf *sti_gem_prime_export(struct drm_device *dev, |
185 | struct drm_gem_object *obj, | |
186 | int flags) | |
9bbf86fe BG |
187 | { |
188 | /* we want to be able to write in mmapped buffer */ | |
189 | flags |= O_RDWR; | |
190 | return drm_gem_prime_export(dev, obj, flags); | |
191 | } | |
192 | ||
9e1f05b2 | 193 | static struct drm_driver sti_driver = { |
9bbf86fe BG |
194 | .driver_features = DRIVER_HAVE_IRQ | DRIVER_MODESET | |
195 | DRIVER_GEM | DRIVER_PRIME, | |
9e1f05b2 | 196 | .load = sti_load, |
9bbf86fe BG |
197 | .gem_free_object = drm_gem_cma_free_object, |
198 | .gem_vm_ops = &drm_gem_cma_vm_ops, | |
199 | .dumb_create = drm_gem_cma_dumb_create, | |
200 | .dumb_map_offset = drm_gem_cma_dumb_map_offset, | |
201 | .dumb_destroy = drm_gem_dumb_destroy, | |
9e1f05b2 | 202 | .fops = &sti_driver_fops, |
9bbf86fe | 203 | |
b44f8408 | 204 | .get_vblank_counter = drm_vblank_no_hw_counter, |
9e1f05b2 VA |
205 | .enable_vblank = sti_crtc_enable_vblank, |
206 | .disable_vblank = sti_crtc_disable_vblank, | |
9bbf86fe BG |
207 | |
208 | .prime_handle_to_fd = drm_gem_prime_handle_to_fd, | |
209 | .prime_fd_to_handle = drm_gem_prime_fd_to_handle, | |
9e1f05b2 | 210 | .gem_prime_export = sti_gem_prime_export, |
9bbf86fe BG |
211 | .gem_prime_import = drm_gem_prime_import, |
212 | .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, | |
213 | .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, | |
214 | .gem_prime_vmap = drm_gem_cma_prime_vmap, | |
215 | .gem_prime_vunmap = drm_gem_cma_prime_vunmap, | |
216 | .gem_prime_mmap = drm_gem_cma_prime_mmap, | |
217 | ||
218 | .name = DRIVER_NAME, | |
219 | .desc = DRIVER_DESC, | |
220 | .date = DRIVER_DATE, | |
221 | .major = DRIVER_MAJOR, | |
222 | .minor = DRIVER_MINOR, | |
223 | }; | |
224 | ||
225 | static int compare_of(struct device *dev, void *data) | |
226 | { | |
227 | return dev->of_node == data; | |
228 | } | |
229 | ||
9e1f05b2 | 230 | static int sti_bind(struct device *dev) |
9bbf86fe | 231 | { |
9e1f05b2 | 232 | return drm_platform_init(&sti_driver, to_platform_device(dev)); |
9bbf86fe BG |
233 | } |
234 | ||
9e1f05b2 | 235 | static void sti_unbind(struct device *dev) |
9bbf86fe BG |
236 | { |
237 | drm_put_dev(dev_get_drvdata(dev)); | |
238 | } | |
239 | ||
9e1f05b2 VA |
240 | static const struct component_master_ops sti_ops = { |
241 | .bind = sti_bind, | |
242 | .unbind = sti_unbind, | |
9bbf86fe BG |
243 | }; |
244 | ||
9e1f05b2 | 245 | static int sti_platform_probe(struct platform_device *pdev) |
9bbf86fe BG |
246 | { |
247 | struct device *dev = &pdev->dev; | |
53bdcf5f | 248 | struct device_node *node = dev->of_node; |
9bbf86fe BG |
249 | struct device_node *child_np; |
250 | struct component_match *match = NULL; | |
251 | ||
252 | dma_set_coherent_mask(dev, DMA_BIT_MASK(32)); | |
253 | ||
53bdcf5f BG |
254 | of_platform_populate(node, NULL, NULL, dev); |
255 | ||
9bbf86fe BG |
256 | child_np = of_get_next_available_child(node, NULL); |
257 | ||
258 | while (child_np) { | |
259 | component_match_add(dev, &match, compare_of, child_np); | |
260 | of_node_put(child_np); | |
261 | child_np = of_get_next_available_child(node, child_np); | |
262 | } | |
263 | ||
9e1f05b2 | 264 | return component_master_add_with_match(dev, &sti_ops, match); |
9bbf86fe BG |
265 | } |
266 | ||
9e1f05b2 | 267 | static int sti_platform_remove(struct platform_device *pdev) |
9bbf86fe | 268 | { |
9e1f05b2 | 269 | component_master_del(&pdev->dev, &sti_ops); |
9bbf86fe | 270 | of_platform_depopulate(&pdev->dev); |
53bdcf5f | 271 | |
9bbf86fe BG |
272 | return 0; |
273 | } | |
274 | ||
9e1f05b2 | 275 | static const struct of_device_id sti_dt_ids[] = { |
9bbf86fe BG |
276 | { .compatible = "st,sti-display-subsystem", }, |
277 | { /* end node */ }, | |
278 | }; | |
9e1f05b2 | 279 | MODULE_DEVICE_TABLE(of, sti_dt_ids); |
9bbf86fe | 280 | |
9e1f05b2 VA |
281 | static struct platform_driver sti_platform_driver = { |
282 | .probe = sti_platform_probe, | |
283 | .remove = sti_platform_remove, | |
9bbf86fe | 284 | .driver = { |
9bbf86fe | 285 | .name = DRIVER_NAME, |
9e1f05b2 | 286 | .of_match_table = sti_dt_ids, |
9bbf86fe BG |
287 | }, |
288 | }; | |
289 | ||
dcec16ef TR |
290 | static struct platform_driver * const drivers[] = { |
291 | &sti_tvout_driver, | |
292 | &sti_vtac_driver, | |
293 | &sti_hqvdp_driver, | |
294 | &sti_hdmi_driver, | |
295 | &sti_hda_driver, | |
296 | &sti_dvo_driver, | |
297 | &sti_vtg_driver, | |
298 | &sti_compositor_driver, | |
299 | &sti_platform_driver, | |
300 | }; | |
301 | ||
302 | static int sti_drm_init(void) | |
303 | { | |
304 | return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); | |
305 | } | |
306 | module_init(sti_drm_init); | |
307 | ||
308 | static void sti_drm_exit(void) | |
309 | { | |
310 | platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); | |
311 | } | |
312 | module_exit(sti_drm_exit); | |
9bbf86fe BG |
313 | |
314 | MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>"); | |
315 | MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver"); | |
316 | MODULE_LICENSE("GPL"); |