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
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>
15 #include <drm/drm_atomic.h>
16 #include <drm/drm_atomic_helper.h>
17 #include <drm/drm_crtc_helper.h>
18 #include <drm/drm_gem_cma_helper.h>
19 #include <drm/drm_fb_cma_helper.h>
20 #include <drm/drm_of.h>
24 #include "sti_plane.h"
26 #define DRIVER_NAME "sti"
27 #define DRIVER_DESC "STMicroelectronics SoC DRM"
28 #define DRIVER_DATE "20140601"
29 #define DRIVER_MAJOR 1
30 #define DRIVER_MINOR 0
32 #define STI_MAX_FB_HEIGHT 4096
33 #define STI_MAX_FB_WIDTH 4096
35 static int sti_drm_fps_get(void *data, u64 *val)
37 struct drm_device *drm_dev = data;
42 list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) {
43 struct sti_plane *plane = to_sti_plane(p);
45 *val |= plane->fps_info.output << i;
52 static int sti_drm_fps_set(void *data, u64 val)
54 struct drm_device *drm_dev = data;
58 list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) {
59 struct sti_plane *plane = to_sti_plane(p);
61 plane->fps_info.output = (val >> i) & 1;
68 DEFINE_SIMPLE_ATTRIBUTE(sti_drm_fps_fops,
69 sti_drm_fps_get, sti_drm_fps_set, "%llu\n");
71 static int sti_drm_fps_dbg_show(struct seq_file *s, void *data)
73 struct drm_info_node *node = s->private;
74 struct drm_device *dev = node->minor->dev;
77 list_for_each_entry(p, &dev->mode_config.plane_list, head) {
78 struct sti_plane *plane = to_sti_plane(p);
80 seq_printf(s, "%s%s\n",
81 plane->fps_info.fps_str,
82 plane->fps_info.fips_str);
88 static struct drm_info_list sti_drm_dbg_list[] = {
89 {"fps_get", sti_drm_fps_dbg_show, 0},
92 static int sti_drm_dbg_init(struct drm_minor *minor)
94 struct dentry *dentry;
97 ret = drm_debugfs_create_files(sti_drm_dbg_list,
98 ARRAY_SIZE(sti_drm_dbg_list),
99 minor->debugfs_root, minor);
103 dentry = debugfs_create_file("fps_show", S_IRUGO | S_IWUSR,
104 minor->debugfs_root, minor->dev,
111 DRM_INFO("%s: debugfs installed\n", DRIVER_NAME);
114 DRM_ERROR("%s: cannot install debugfs\n", DRIVER_NAME);
118 static void sti_atomic_schedule(struct sti_private *private,
119 struct drm_atomic_state *state)
121 private->commit.state = state;
122 schedule_work(&private->commit.work);
125 static void sti_atomic_complete(struct sti_private *private,
126 struct drm_atomic_state *state)
128 struct drm_device *drm = private->drm_dev;
131 * Everything below can be run asynchronously without the need to grab
132 * any modeset locks at all under one condition: It must be guaranteed
133 * that the asynchronous work has either been cancelled (if the driver
134 * supports it, which at least requires that the framebuffers get
135 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
136 * before the new state gets committed on the software side with
137 * drm_atomic_helper_swap_state().
139 * This scheme allows new atomic state updates to be prepared and
140 * checked in parallel to the asynchronous completion of the previous
141 * update. Which is important since compositors need to figure out the
142 * composition of the next frame right after having submitted the
146 drm_atomic_helper_commit_modeset_disables(drm, state);
147 drm_atomic_helper_commit_planes(drm, state, 0);
148 drm_atomic_helper_commit_modeset_enables(drm, state);
150 drm_atomic_helper_wait_for_vblanks(drm, state);
152 drm_atomic_helper_cleanup_planes(drm, state);
153 drm_atomic_state_put(state);
156 static void sti_atomic_work(struct work_struct *work)
158 struct sti_private *private = container_of(work,
159 struct sti_private, commit.work);
161 sti_atomic_complete(private, private->commit.state);
164 static int sti_atomic_check(struct drm_device *dev,
165 struct drm_atomic_state *state)
169 ret = drm_atomic_helper_check_modeset(dev, state);
173 ret = drm_atomic_normalize_zpos(dev, state);
177 ret = drm_atomic_helper_check_planes(dev, state);
184 static int sti_atomic_commit(struct drm_device *drm,
185 struct drm_atomic_state *state, bool nonblock)
187 struct sti_private *private = drm->dev_private;
190 err = drm_atomic_helper_prepare_planes(drm, state);
194 /* serialize outstanding nonblocking commits */
195 mutex_lock(&private->commit.lock);
196 flush_work(&private->commit.work);
199 * This is the point of no return - everything below never fails except
200 * when the hw goes bonghits. Which means we can commit the new state on
201 * the software side now.
204 drm_atomic_helper_swap_state(state, true);
206 drm_atomic_state_get(state);
208 sti_atomic_schedule(private, state);
210 sti_atomic_complete(private, state);
212 mutex_unlock(&private->commit.lock);
216 static void sti_output_poll_changed(struct drm_device *ddev)
218 struct sti_private *private = ddev->dev_private;
220 drm_fbdev_cma_hotplug_event(private->fbdev);
223 static const struct drm_mode_config_funcs sti_mode_config_funcs = {
224 .fb_create = drm_fb_cma_create,
225 .output_poll_changed = sti_output_poll_changed,
226 .atomic_check = sti_atomic_check,
227 .atomic_commit = sti_atomic_commit,
230 static void sti_mode_config_init(struct drm_device *dev)
232 dev->mode_config.min_width = 0;
233 dev->mode_config.min_height = 0;
236 * set max width and height as default value.
237 * this value would be used to check framebuffer size limitation
238 * at drm_mode_addfb().
240 dev->mode_config.max_width = STI_MAX_FB_WIDTH;
241 dev->mode_config.max_height = STI_MAX_FB_HEIGHT;
243 dev->mode_config.funcs = &sti_mode_config_funcs;
246 static const struct file_operations sti_driver_fops = {
247 .owner = THIS_MODULE,
249 .mmap = drm_gem_cma_mmap,
252 .unlocked_ioctl = drm_ioctl,
253 .compat_ioctl = drm_compat_ioctl,
254 .release = drm_release,
257 static struct drm_driver sti_driver = {
258 .driver_features = DRIVER_MODESET |
259 DRIVER_GEM | DRIVER_PRIME | DRIVER_ATOMIC,
260 .gem_free_object_unlocked = drm_gem_cma_free_object,
261 .gem_vm_ops = &drm_gem_cma_vm_ops,
262 .dumb_create = drm_gem_cma_dumb_create,
263 .dumb_map_offset = drm_gem_cma_dumb_map_offset,
264 .dumb_destroy = drm_gem_dumb_destroy,
265 .fops = &sti_driver_fops,
267 .get_vblank_counter = drm_vblank_no_hw_counter,
268 .enable_vblank = sti_crtc_enable_vblank,
269 .disable_vblank = sti_crtc_disable_vblank,
271 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
272 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
273 .gem_prime_export = drm_gem_prime_export,
274 .gem_prime_import = drm_gem_prime_import,
275 .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
276 .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
277 .gem_prime_vmap = drm_gem_cma_prime_vmap,
278 .gem_prime_vunmap = drm_gem_cma_prime_vunmap,
279 .gem_prime_mmap = drm_gem_cma_prime_mmap,
281 .debugfs_init = sti_drm_dbg_init,
286 .major = DRIVER_MAJOR,
287 .minor = DRIVER_MINOR,
290 static int compare_of(struct device *dev, void *data)
292 return dev->of_node == data;
295 static int sti_init(struct drm_device *ddev)
297 struct sti_private *private;
299 private = kzalloc(sizeof(*private), GFP_KERNEL);
303 ddev->dev_private = (void *)private;
304 dev_set_drvdata(ddev->dev, ddev);
305 private->drm_dev = ddev;
307 mutex_init(&private->commit.lock);
308 INIT_WORK(&private->commit.work, sti_atomic_work);
310 drm_mode_config_init(ddev);
312 sti_mode_config_init(ddev);
314 drm_kms_helper_poll_init(ddev);
319 static void sti_cleanup(struct drm_device *ddev)
321 struct sti_private *private = ddev->dev_private;
323 if (private->fbdev) {
324 drm_fbdev_cma_fini(private->fbdev);
325 private->fbdev = NULL;
328 drm_kms_helper_poll_fini(ddev);
329 drm_vblank_cleanup(ddev);
331 ddev->dev_private = NULL;
334 static int sti_bind(struct device *dev)
336 struct drm_device *ddev;
337 struct sti_private *private;
338 struct drm_fbdev_cma *fbdev;
341 ddev = drm_dev_alloc(&sti_driver, dev);
343 return PTR_ERR(ddev);
345 ddev->platformdev = to_platform_device(dev);
347 ret = sti_init(ddev);
349 goto err_drm_dev_unref;
351 ret = component_bind_all(ddev->dev, ddev);
355 ret = drm_dev_register(ddev, 0);
359 drm_mode_config_reset(ddev);
361 private = ddev->dev_private;
362 if (ddev->mode_config.num_connector) {
363 fbdev = drm_fbdev_cma_init(ddev, 32,
364 ddev->mode_config.num_connector);
366 DRM_DEBUG_DRIVER("Warning: fails to create fbdev\n");
369 private->fbdev = fbdev;
375 drm_mode_config_cleanup(ddev);
383 static void sti_unbind(struct device *dev)
385 struct drm_device *ddev = dev_get_drvdata(dev);
387 drm_dev_unregister(ddev);
392 static const struct component_master_ops sti_ops = {
394 .unbind = sti_unbind,
397 static int sti_platform_probe(struct platform_device *pdev)
399 struct device *dev = &pdev->dev;
400 struct device_node *node = dev->of_node;
401 struct device_node *child_np;
402 struct component_match *match = NULL;
404 dma_set_coherent_mask(dev, DMA_BIT_MASK(32));
406 of_platform_populate(node, NULL, NULL, dev);
408 child_np = of_get_next_available_child(node, NULL);
411 drm_of_component_match_add(dev, &match, compare_of,
413 child_np = of_get_next_available_child(node, child_np);
416 return component_master_add_with_match(dev, &sti_ops, match);
419 static int sti_platform_remove(struct platform_device *pdev)
421 component_master_del(&pdev->dev, &sti_ops);
422 of_platform_depopulate(&pdev->dev);
427 static const struct of_device_id sti_dt_ids[] = {
428 { .compatible = "st,sti-display-subsystem", },
431 MODULE_DEVICE_TABLE(of, sti_dt_ids);
433 static struct platform_driver sti_platform_driver = {
434 .probe = sti_platform_probe,
435 .remove = sti_platform_remove,
438 .of_match_table = sti_dt_ids,
442 static struct platform_driver * const drivers[] = {
449 &sti_compositor_driver,
450 &sti_platform_driver,
453 static int sti_drm_init(void)
455 return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
457 module_init(sti_drm_init);
459 static void sti_drm_exit(void)
461 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
463 module_exit(sti_drm_exit);
465 MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>");
466 MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver");
467 MODULE_LICENSE("GPL");