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" | |
bf8f9e4a | 23 | #include "sti_plane.h" |
9bbf86fe BG |
24 | |
25 | #define DRIVER_NAME "sti" | |
26 | #define DRIVER_DESC "STMicroelectronics SoC DRM" | |
27 | #define DRIVER_DATE "20140601" | |
28 | #define DRIVER_MAJOR 1 | |
29 | #define DRIVER_MINOR 0 | |
30 | ||
31 | #define STI_MAX_FB_HEIGHT 4096 | |
32 | #define STI_MAX_FB_WIDTH 4096 | |
33 | ||
bf8f9e4a VA |
34 | static int sti_drm_fps_get(void *data, u64 *val) |
35 | { | |
36 | struct drm_device *drm_dev = data; | |
37 | struct drm_plane *p; | |
38 | unsigned int i = 0; | |
39 | ||
40 | *val = 0; | |
41 | list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) { | |
42 | struct sti_plane *plane = to_sti_plane(p); | |
43 | ||
44 | *val |= plane->fps_info.output << i; | |
45 | i++; | |
46 | } | |
47 | ||
48 | return 0; | |
49 | } | |
50 | ||
51 | static int sti_drm_fps_set(void *data, u64 val) | |
52 | { | |
53 | struct drm_device *drm_dev = data; | |
54 | struct drm_plane *p; | |
55 | unsigned int i = 0; | |
56 | ||
57 | list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) { | |
58 | struct sti_plane *plane = to_sti_plane(p); | |
59 | ||
60 | plane->fps_info.output = (val >> i) & 1; | |
61 | i++; | |
62 | } | |
63 | ||
64 | return 0; | |
65 | } | |
66 | ||
67 | DEFINE_SIMPLE_ATTRIBUTE(sti_drm_fps_fops, | |
68 | sti_drm_fps_get, sti_drm_fps_set, "%llu\n"); | |
69 | ||
70 | static int sti_drm_fps_dbg_show(struct seq_file *s, void *data) | |
71 | { | |
72 | struct drm_info_node *node = s->private; | |
73 | struct drm_device *dev = node->minor->dev; | |
74 | struct drm_plane *p; | |
75 | int ret; | |
76 | ||
77 | ret = mutex_lock_interruptible(&dev->struct_mutex); | |
78 | if (ret) | |
79 | return ret; | |
80 | ||
81 | list_for_each_entry(p, &dev->mode_config.plane_list, head) { | |
82 | struct sti_plane *plane = to_sti_plane(p); | |
83 | ||
84 | seq_printf(s, "%s%s\n", | |
85 | plane->fps_info.fps_str, | |
86 | plane->fps_info.fips_str); | |
87 | } | |
88 | ||
89 | mutex_unlock(&dev->struct_mutex); | |
90 | return 0; | |
91 | } | |
92 | ||
93 | static struct drm_info_list sti_drm_dbg_list[] = { | |
94 | {"fps_get", sti_drm_fps_dbg_show, 0}, | |
95 | }; | |
96 | ||
97 | static int sti_drm_debugfs_create(struct dentry *root, | |
98 | struct drm_minor *minor, | |
99 | const char *name, | |
100 | const struct file_operations *fops) | |
101 | { | |
102 | struct drm_device *dev = minor->dev; | |
103 | struct drm_info_node *node; | |
104 | struct dentry *ent; | |
105 | ||
106 | ent = debugfs_create_file(name, S_IRUGO | S_IWUSR, root, dev, fops); | |
107 | if (IS_ERR(ent)) | |
108 | return PTR_ERR(ent); | |
109 | ||
110 | node = kmalloc(sizeof(*node), GFP_KERNEL); | |
111 | if (!node) { | |
112 | debugfs_remove(ent); | |
113 | return -ENOMEM; | |
114 | } | |
115 | ||
116 | node->minor = minor; | |
117 | node->dent = ent; | |
118 | node->info_ent = (void *)fops; | |
119 | ||
120 | mutex_lock(&minor->debugfs_lock); | |
121 | list_add(&node->list, &minor->debugfs_list); | |
122 | mutex_unlock(&minor->debugfs_lock); | |
123 | ||
124 | return 0; | |
125 | } | |
126 | ||
127 | static int sti_drm_dbg_init(struct drm_minor *minor) | |
128 | { | |
129 | int ret; | |
130 | ||
131 | ret = drm_debugfs_create_files(sti_drm_dbg_list, | |
132 | ARRAY_SIZE(sti_drm_dbg_list), | |
133 | minor->debugfs_root, minor); | |
134 | if (ret) | |
135 | goto err; | |
136 | ||
137 | ret = sti_drm_debugfs_create(minor->debugfs_root, minor, "fps_show", | |
138 | &sti_drm_fps_fops); | |
139 | if (ret) | |
140 | goto err; | |
141 | ||
142 | DRM_INFO("%s: debugfs installed\n", DRIVER_NAME); | |
143 | return 0; | |
144 | err: | |
145 | DRM_ERROR("%s: cannot install debugfs\n", DRIVER_NAME); | |
146 | return ret; | |
147 | } | |
148 | ||
149 | void sti_drm_dbg_cleanup(struct drm_minor *minor) | |
150 | { | |
151 | drm_debugfs_remove_files(sti_drm_dbg_list, | |
152 | ARRAY_SIZE(sti_drm_dbg_list), minor); | |
153 | ||
154 | drm_debugfs_remove_files((struct drm_info_list *)&sti_drm_fps_fops, | |
155 | 1, minor); | |
156 | } | |
157 | ||
9e1f05b2 VA |
158 | static void sti_atomic_schedule(struct sti_private *private, |
159 | struct drm_atomic_state *state) | |
de4b00b0 BG |
160 | { |
161 | private->commit.state = state; | |
162 | schedule_work(&private->commit.work); | |
163 | } | |
164 | ||
9e1f05b2 VA |
165 | static void sti_atomic_complete(struct sti_private *private, |
166 | struct drm_atomic_state *state) | |
de4b00b0 BG |
167 | { |
168 | struct drm_device *drm = private->drm_dev; | |
169 | ||
170 | /* | |
171 | * Everything below can be run asynchronously without the need to grab | |
172 | * any modeset locks at all under one condition: It must be guaranteed | |
173 | * that the asynchronous work has either been cancelled (if the driver | |
174 | * supports it, which at least requires that the framebuffers get | |
175 | * cleaned up with drm_atomic_helper_cleanup_planes()) or completed | |
176 | * before the new state gets committed on the software side with | |
177 | * drm_atomic_helper_swap_state(). | |
178 | * | |
179 | * This scheme allows new atomic state updates to be prepared and | |
180 | * checked in parallel to the asynchronous completion of the previous | |
181 | * update. Which is important since compositors need to figure out the | |
182 | * composition of the next frame right after having submitted the | |
183 | * current layout. | |
184 | */ | |
185 | ||
186 | drm_atomic_helper_commit_modeset_disables(drm, state); | |
aef9dbb8 | 187 | drm_atomic_helper_commit_planes(drm, state, false); |
de4b00b0 BG |
188 | drm_atomic_helper_commit_modeset_enables(drm, state); |
189 | ||
190 | drm_atomic_helper_wait_for_vblanks(drm, state); | |
191 | ||
192 | drm_atomic_helper_cleanup_planes(drm, state); | |
193 | drm_atomic_state_free(state); | |
194 | } | |
195 | ||
9e1f05b2 | 196 | static void sti_atomic_work(struct work_struct *work) |
de4b00b0 | 197 | { |
9e1f05b2 VA |
198 | struct sti_private *private = container_of(work, |
199 | struct sti_private, commit.work); | |
de4b00b0 | 200 | |
9e1f05b2 | 201 | sti_atomic_complete(private, private->commit.state); |
de4b00b0 BG |
202 | } |
203 | ||
9e1f05b2 | 204 | static int sti_atomic_commit(struct drm_device *drm, |
ab575184 | 205 | struct drm_atomic_state *state, bool nonblock) |
de4b00b0 | 206 | { |
9e1f05b2 | 207 | struct sti_private *private = drm->dev_private; |
de4b00b0 BG |
208 | int err; |
209 | ||
210 | err = drm_atomic_helper_prepare_planes(drm, state); | |
211 | if (err) | |
212 | return err; | |
213 | ||
ab575184 | 214 | /* serialize outstanding nonblocking commits */ |
de4b00b0 BG |
215 | mutex_lock(&private->commit.lock); |
216 | flush_work(&private->commit.work); | |
217 | ||
218 | /* | |
219 | * This is the point of no return - everything below never fails except | |
220 | * when the hw goes bonghits. Which means we can commit the new state on | |
221 | * the software side now. | |
222 | */ | |
223 | ||
224 | drm_atomic_helper_swap_state(drm, state); | |
225 | ||
ab575184 | 226 | if (nonblock) |
9e1f05b2 | 227 | sti_atomic_schedule(private, state); |
de4b00b0 | 228 | else |
9e1f05b2 | 229 | sti_atomic_complete(private, state); |
de4b00b0 BG |
230 | |
231 | mutex_unlock(&private->commit.lock); | |
232 | return 0; | |
233 | } | |
234 | ||
c5de4853 | 235 | static const struct drm_mode_config_funcs sti_mode_config_funcs = { |
9bbf86fe | 236 | .fb_create = drm_fb_cma_create, |
de4b00b0 | 237 | .atomic_check = drm_atomic_helper_check, |
9e1f05b2 | 238 | .atomic_commit = sti_atomic_commit, |
9bbf86fe BG |
239 | }; |
240 | ||
9e1f05b2 | 241 | static void sti_mode_config_init(struct drm_device *dev) |
9bbf86fe BG |
242 | { |
243 | dev->mode_config.min_width = 0; | |
244 | dev->mode_config.min_height = 0; | |
245 | ||
246 | /* | |
247 | * set max width and height as default value. | |
248 | * this value would be used to check framebuffer size limitation | |
249 | * at drm_mode_addfb(). | |
250 | */ | |
738be9d6 VA |
251 | dev->mode_config.max_width = STI_MAX_FB_WIDTH; |
252 | dev->mode_config.max_height = STI_MAX_FB_HEIGHT; | |
9bbf86fe | 253 | |
9e1f05b2 | 254 | dev->mode_config.funcs = &sti_mode_config_funcs; |
9bbf86fe BG |
255 | } |
256 | ||
9e1f05b2 | 257 | static int sti_load(struct drm_device *dev, unsigned long flags) |
9bbf86fe | 258 | { |
9e1f05b2 | 259 | struct sti_private *private; |
9bbf86fe BG |
260 | int ret; |
261 | ||
9e1f05b2 | 262 | private = kzalloc(sizeof(*private), GFP_KERNEL); |
9bbf86fe BG |
263 | if (!private) { |
264 | DRM_ERROR("Failed to allocate private\n"); | |
265 | return -ENOMEM; | |
266 | } | |
267 | dev->dev_private = (void *)private; | |
268 | private->drm_dev = dev; | |
269 | ||
de4b00b0 | 270 | mutex_init(&private->commit.lock); |
9e1f05b2 | 271 | INIT_WORK(&private->commit.work, sti_atomic_work); |
de4b00b0 | 272 | |
9bbf86fe BG |
273 | drm_mode_config_init(dev); |
274 | drm_kms_helper_poll_init(dev); | |
275 | ||
9e1f05b2 | 276 | sti_mode_config_init(dev); |
9bbf86fe BG |
277 | |
278 | ret = component_bind_all(dev->dev, dev); | |
f78e772a BG |
279 | if (ret) { |
280 | drm_kms_helper_poll_fini(dev); | |
281 | drm_mode_config_cleanup(dev); | |
282 | kfree(private); | |
9bbf86fe | 283 | return ret; |
f78e772a | 284 | } |
9bbf86fe | 285 | |
de4b00b0 | 286 | drm_mode_config_reset(dev); |
9bbf86fe | 287 | |
4314e19e | 288 | drm_helper_disable_unused_functions(dev); |
9bbf86fe | 289 | drm_fbdev_cma_init(dev, 32, |
9e1f05b2 VA |
290 | dev->mode_config.num_crtc, |
291 | dev->mode_config.num_connector); | |
b5d34a27 | 292 | |
9bbf86fe BG |
293 | return 0; |
294 | } | |
295 | ||
9e1f05b2 | 296 | static const struct file_operations sti_driver_fops = { |
9bbf86fe BG |
297 | .owner = THIS_MODULE, |
298 | .open = drm_open, | |
299 | .mmap = drm_gem_cma_mmap, | |
300 | .poll = drm_poll, | |
301 | .read = drm_read, | |
302 | .unlocked_ioctl = drm_ioctl, | |
303 | #ifdef CONFIG_COMPAT | |
304 | .compat_ioctl = drm_compat_ioctl, | |
305 | #endif | |
306 | .release = drm_release, | |
307 | }; | |
308 | ||
9e1f05b2 | 309 | static struct drm_driver sti_driver = { |
9bbf86fe | 310 | .driver_features = DRIVER_HAVE_IRQ | DRIVER_MODESET | |
f29ddaf1 | 311 | DRIVER_GEM | DRIVER_PRIME | DRIVER_ATOMIC, |
9e1f05b2 | 312 | .load = sti_load, |
9bbf86fe BG |
313 | .gem_free_object = drm_gem_cma_free_object, |
314 | .gem_vm_ops = &drm_gem_cma_vm_ops, | |
315 | .dumb_create = drm_gem_cma_dumb_create, | |
316 | .dumb_map_offset = drm_gem_cma_dumb_map_offset, | |
317 | .dumb_destroy = drm_gem_dumb_destroy, | |
9e1f05b2 | 318 | .fops = &sti_driver_fops, |
9bbf86fe | 319 | |
b44f8408 | 320 | .get_vblank_counter = drm_vblank_no_hw_counter, |
9e1f05b2 VA |
321 | .enable_vblank = sti_crtc_enable_vblank, |
322 | .disable_vblank = sti_crtc_disable_vblank, | |
9bbf86fe BG |
323 | |
324 | .prime_handle_to_fd = drm_gem_prime_handle_to_fd, | |
325 | .prime_fd_to_handle = drm_gem_prime_fd_to_handle, | |
ffd157ce | 326 | .gem_prime_export = drm_gem_prime_export, |
9bbf86fe BG |
327 | .gem_prime_import = drm_gem_prime_import, |
328 | .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, | |
329 | .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, | |
330 | .gem_prime_vmap = drm_gem_cma_prime_vmap, | |
331 | .gem_prime_vunmap = drm_gem_cma_prime_vunmap, | |
332 | .gem_prime_mmap = drm_gem_cma_prime_mmap, | |
333 | ||
bf8f9e4a VA |
334 | .debugfs_init = sti_drm_dbg_init, |
335 | .debugfs_cleanup = sti_drm_dbg_cleanup, | |
336 | ||
9bbf86fe BG |
337 | .name = DRIVER_NAME, |
338 | .desc = DRIVER_DESC, | |
339 | .date = DRIVER_DATE, | |
340 | .major = DRIVER_MAJOR, | |
341 | .minor = DRIVER_MINOR, | |
342 | }; | |
343 | ||
344 | static int compare_of(struct device *dev, void *data) | |
345 | { | |
346 | return dev->of_node == data; | |
347 | } | |
348 | ||
9e1f05b2 | 349 | static int sti_bind(struct device *dev) |
9bbf86fe | 350 | { |
9e1f05b2 | 351 | return drm_platform_init(&sti_driver, to_platform_device(dev)); |
9bbf86fe BG |
352 | } |
353 | ||
9e1f05b2 | 354 | static void sti_unbind(struct device *dev) |
9bbf86fe BG |
355 | { |
356 | drm_put_dev(dev_get_drvdata(dev)); | |
357 | } | |
358 | ||
9e1f05b2 VA |
359 | static const struct component_master_ops sti_ops = { |
360 | .bind = sti_bind, | |
361 | .unbind = sti_unbind, | |
9bbf86fe BG |
362 | }; |
363 | ||
9e1f05b2 | 364 | static int sti_platform_probe(struct platform_device *pdev) |
9bbf86fe BG |
365 | { |
366 | struct device *dev = &pdev->dev; | |
53bdcf5f | 367 | struct device_node *node = dev->of_node; |
9bbf86fe BG |
368 | struct device_node *child_np; |
369 | struct component_match *match = NULL; | |
370 | ||
371 | dma_set_coherent_mask(dev, DMA_BIT_MASK(32)); | |
372 | ||
53bdcf5f BG |
373 | of_platform_populate(node, NULL, NULL, dev); |
374 | ||
9bbf86fe BG |
375 | child_np = of_get_next_available_child(node, NULL); |
376 | ||
377 | while (child_np) { | |
378 | component_match_add(dev, &match, compare_of, child_np); | |
379 | of_node_put(child_np); | |
380 | child_np = of_get_next_available_child(node, child_np); | |
381 | } | |
382 | ||
9e1f05b2 | 383 | return component_master_add_with_match(dev, &sti_ops, match); |
9bbf86fe BG |
384 | } |
385 | ||
9e1f05b2 | 386 | static int sti_platform_remove(struct platform_device *pdev) |
9bbf86fe | 387 | { |
9e1f05b2 | 388 | component_master_del(&pdev->dev, &sti_ops); |
9bbf86fe | 389 | of_platform_depopulate(&pdev->dev); |
53bdcf5f | 390 | |
9bbf86fe BG |
391 | return 0; |
392 | } | |
393 | ||
9e1f05b2 | 394 | static const struct of_device_id sti_dt_ids[] = { |
9bbf86fe BG |
395 | { .compatible = "st,sti-display-subsystem", }, |
396 | { /* end node */ }, | |
397 | }; | |
9e1f05b2 | 398 | MODULE_DEVICE_TABLE(of, sti_dt_ids); |
9bbf86fe | 399 | |
9e1f05b2 VA |
400 | static struct platform_driver sti_platform_driver = { |
401 | .probe = sti_platform_probe, | |
402 | .remove = sti_platform_remove, | |
9bbf86fe | 403 | .driver = { |
9bbf86fe | 404 | .name = DRIVER_NAME, |
9e1f05b2 | 405 | .of_match_table = sti_dt_ids, |
9bbf86fe BG |
406 | }, |
407 | }; | |
408 | ||
dcec16ef TR |
409 | static struct platform_driver * const drivers[] = { |
410 | &sti_tvout_driver, | |
411 | &sti_vtac_driver, | |
412 | &sti_hqvdp_driver, | |
413 | &sti_hdmi_driver, | |
414 | &sti_hda_driver, | |
415 | &sti_dvo_driver, | |
416 | &sti_vtg_driver, | |
417 | &sti_compositor_driver, | |
418 | &sti_platform_driver, | |
419 | }; | |
420 | ||
421 | static int sti_drm_init(void) | |
422 | { | |
423 | return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); | |
424 | } | |
425 | module_init(sti_drm_init); | |
426 | ||
427 | static void sti_drm_exit(void) | |
428 | { | |
429 | platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); | |
430 | } | |
431 | module_exit(sti_drm_exit); | |
9bbf86fe BG |
432 | |
433 | MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>"); | |
434 | MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver"); | |
435 | MODULE_LICENSE("GPL"); |