Commit | Line | Data |
---|---|---|
e2842570 | 1 | // SPDX-License-Identifier: GPL-2.0 |
9bbf86fe BG |
2 | /* |
3 | * Copyright (C) STMicroelectronics SA 2014 | |
4 | * Author: Benjamin Gaignard <benjamin.gaignard@st.com> for STMicroelectronics. | |
9bbf86fe BG |
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 | 17 | #include <drm/drm_gem_cma_helper.h> |
80cad29f | 18 | #include <drm/drm_gem_framebuffer_helper.h> |
53889c92 | 19 | #include <drm/drm_fb_helper.h> |
9bbf86fe | 20 | #include <drm/drm_fb_cma_helper.h> |
97ac0e47 | 21 | #include <drm/drm_of.h> |
fcd70cd3 | 22 | #include <drm/drm_probe_helper.h> |
9bbf86fe | 23 | |
9e1f05b2 VA |
24 | #include "sti_crtc.h" |
25 | #include "sti_drv.h" | |
bf8f9e4a | 26 | #include "sti_plane.h" |
9bbf86fe BG |
27 | |
28 | #define DRIVER_NAME "sti" | |
29 | #define DRIVER_DESC "STMicroelectronics SoC DRM" | |
30 | #define DRIVER_DATE "20140601" | |
31 | #define DRIVER_MAJOR 1 | |
32 | #define DRIVER_MINOR 0 | |
33 | ||
34 | #define STI_MAX_FB_HEIGHT 4096 | |
35 | #define STI_MAX_FB_WIDTH 4096 | |
36 | ||
bf8f9e4a VA |
37 | static int sti_drm_fps_get(void *data, u64 *val) |
38 | { | |
39 | struct drm_device *drm_dev = data; | |
40 | struct drm_plane *p; | |
41 | unsigned int i = 0; | |
42 | ||
43 | *val = 0; | |
44 | list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) { | |
45 | struct sti_plane *plane = to_sti_plane(p); | |
46 | ||
47 | *val |= plane->fps_info.output << i; | |
48 | i++; | |
49 | } | |
50 | ||
51 | return 0; | |
52 | } | |
53 | ||
54 | static int sti_drm_fps_set(void *data, u64 val) | |
55 | { | |
56 | struct drm_device *drm_dev = data; | |
57 | struct drm_plane *p; | |
58 | unsigned int i = 0; | |
59 | ||
60 | list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) { | |
61 | struct sti_plane *plane = to_sti_plane(p); | |
62 | ||
c462c2f5 | 63 | memset(&plane->fps_info, 0, sizeof(plane->fps_info)); |
bf8f9e4a | 64 | plane->fps_info.output = (val >> i) & 1; |
c462c2f5 | 65 | |
bf8f9e4a VA |
66 | i++; |
67 | } | |
68 | ||
69 | return 0; | |
70 | } | |
71 | ||
72 | DEFINE_SIMPLE_ATTRIBUTE(sti_drm_fps_fops, | |
73 | sti_drm_fps_get, sti_drm_fps_set, "%llu\n"); | |
74 | ||
75 | static int sti_drm_fps_dbg_show(struct seq_file *s, void *data) | |
76 | { | |
77 | struct drm_info_node *node = s->private; | |
78 | struct drm_device *dev = node->minor->dev; | |
79 | struct drm_plane *p; | |
bf8f9e4a VA |
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 | ||
bf8f9e4a VA |
89 | return 0; |
90 | } | |
91 | ||
92 | static struct drm_info_list sti_drm_dbg_list[] = { | |
93 | {"fps_get", sti_drm_fps_dbg_show, 0}, | |
94 | }; | |
95 | ||
bf8f9e4a VA |
96 | static int sti_drm_dbg_init(struct drm_minor *minor) |
97 | { | |
fc3706ea | 98 | struct dentry *dentry; |
bf8f9e4a VA |
99 | int ret; |
100 | ||
101 | ret = drm_debugfs_create_files(sti_drm_dbg_list, | |
102 | ARRAY_SIZE(sti_drm_dbg_list), | |
103 | minor->debugfs_root, minor); | |
104 | if (ret) | |
105 | goto err; | |
106 | ||
fc3706ea NT |
107 | dentry = debugfs_create_file("fps_show", S_IRUGO | S_IWUSR, |
108 | minor->debugfs_root, minor->dev, | |
bf8f9e4a | 109 | &sti_drm_fps_fops); |
fc3706ea NT |
110 | if (!dentry) { |
111 | ret = -ENOMEM; | |
bf8f9e4a | 112 | goto err; |
fc3706ea | 113 | } |
bf8f9e4a VA |
114 | |
115 | DRM_INFO("%s: debugfs installed\n", DRIVER_NAME); | |
116 | return 0; | |
117 | err: | |
118 | DRM_ERROR("%s: cannot install debugfs\n", DRIVER_NAME); | |
119 | return ret; | |
120 | } | |
121 | ||
c5de4853 | 122 | static const struct drm_mode_config_funcs sti_mode_config_funcs = { |
80cad29f | 123 | .fb_create = drm_gem_fb_create, |
352f9a84 | 124 | .atomic_check = drm_atomic_helper_check, |
5e60f595 | 125 | .atomic_commit = drm_atomic_helper_commit, |
9bbf86fe BG |
126 | }; |
127 | ||
9e1f05b2 | 128 | static void sti_mode_config_init(struct drm_device *dev) |
9bbf86fe BG |
129 | { |
130 | dev->mode_config.min_width = 0; | |
131 | dev->mode_config.min_height = 0; | |
132 | ||
133 | /* | |
134 | * set max width and height as default value. | |
135 | * this value would be used to check framebuffer size limitation | |
136 | * at drm_mode_addfb(). | |
137 | */ | |
738be9d6 VA |
138 | dev->mode_config.max_width = STI_MAX_FB_WIDTH; |
139 | dev->mode_config.max_height = STI_MAX_FB_HEIGHT; | |
9bbf86fe | 140 | |
9e1f05b2 | 141 | dev->mode_config.funcs = &sti_mode_config_funcs; |
352f9a84 PU |
142 | |
143 | dev->mode_config.normalize_zpos = true; | |
9bbf86fe BG |
144 | } |
145 | ||
d55f7e5d | 146 | DEFINE_DRM_GEM_CMA_FOPS(sti_driver_fops); |
9bbf86fe | 147 | |
9e1f05b2 | 148 | static struct drm_driver sti_driver = { |
e1f96ef4 | 149 | .driver_features = DRIVER_MODESET | |
f29ddaf1 | 150 | DRIVER_GEM | DRIVER_PRIME | DRIVER_ATOMIC, |
d41ec9ca | 151 | .gem_free_object_unlocked = drm_gem_cma_free_object, |
9bbf86fe BG |
152 | .gem_vm_ops = &drm_gem_cma_vm_ops, |
153 | .dumb_create = drm_gem_cma_dumb_create, | |
9e1f05b2 | 154 | .fops = &sti_driver_fops, |
9bbf86fe | 155 | |
9e1f05b2 VA |
156 | .enable_vblank = sti_crtc_enable_vblank, |
157 | .disable_vblank = sti_crtc_disable_vblank, | |
9bbf86fe BG |
158 | |
159 | .prime_handle_to_fd = drm_gem_prime_handle_to_fd, | |
160 | .prime_fd_to_handle = drm_gem_prime_fd_to_handle, | |
ffd157ce | 161 | .gem_prime_export = drm_gem_prime_export, |
9bbf86fe BG |
162 | .gem_prime_import = drm_gem_prime_import, |
163 | .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, | |
164 | .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, | |
165 | .gem_prime_vmap = drm_gem_cma_prime_vmap, | |
166 | .gem_prime_vunmap = drm_gem_cma_prime_vunmap, | |
167 | .gem_prime_mmap = drm_gem_cma_prime_mmap, | |
168 | ||
bf8f9e4a | 169 | .debugfs_init = sti_drm_dbg_init, |
bf8f9e4a | 170 | |
9bbf86fe BG |
171 | .name = DRIVER_NAME, |
172 | .desc = DRIVER_DESC, | |
173 | .date = DRIVER_DATE, | |
174 | .major = DRIVER_MAJOR, | |
175 | .minor = DRIVER_MINOR, | |
176 | }; | |
177 | ||
178 | static int compare_of(struct device *dev, void *data) | |
179 | { | |
180 | return dev->of_node == data; | |
181 | } | |
182 | ||
84601dbd BG |
183 | static int sti_init(struct drm_device *ddev) |
184 | { | |
185 | struct sti_private *private; | |
186 | ||
187 | private = kzalloc(sizeof(*private), GFP_KERNEL); | |
188 | if (!private) | |
189 | return -ENOMEM; | |
190 | ||
191 | ddev->dev_private = (void *)private; | |
192 | dev_set_drvdata(ddev->dev, ddev); | |
193 | private->drm_dev = ddev; | |
194 | ||
84601dbd BG |
195 | drm_mode_config_init(ddev); |
196 | ||
197 | sti_mode_config_init(ddev); | |
198 | ||
199 | drm_kms_helper_poll_init(ddev); | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
204 | static void sti_cleanup(struct drm_device *ddev) | |
205 | { | |
206 | struct sti_private *private = ddev->dev_private; | |
207 | ||
84601dbd | 208 | drm_kms_helper_poll_fini(ddev); |
a2b50bab DV |
209 | drm_atomic_helper_shutdown(ddev); |
210 | drm_mode_config_cleanup(ddev); | |
b7e05db3 | 211 | component_unbind_all(ddev->dev, ddev); |
84601dbd BG |
212 | kfree(private); |
213 | ddev->dev_private = NULL; | |
214 | } | |
215 | ||
9e1f05b2 | 216 | static int sti_bind(struct device *dev) |
9bbf86fe | 217 | { |
84601dbd BG |
218 | struct drm_device *ddev; |
219 | int ret; | |
220 | ||
221 | ddev = drm_dev_alloc(&sti_driver, dev); | |
0f288605 TG |
222 | if (IS_ERR(ddev)) |
223 | return PTR_ERR(ddev); | |
84601dbd | 224 | |
84601dbd BG |
225 | ret = sti_init(ddev); |
226 | if (ret) | |
a08eac47 | 227 | goto err_drm_dev_put; |
84601dbd BG |
228 | |
229 | ret = component_bind_all(ddev->dev, ddev); | |
230 | if (ret) | |
231 | goto err_cleanup; | |
232 | ||
233 | ret = drm_dev_register(ddev, 0); | |
234 | if (ret) | |
a2b50bab | 235 | goto err_cleanup; |
84601dbd BG |
236 | |
237 | drm_mode_config_reset(ddev); | |
238 | ||
0f26e5ce | 239 | drm_fbdev_generic_setup(ddev, 32); |
8953e9ee | 240 | |
84601dbd BG |
241 | return 0; |
242 | ||
84601dbd BG |
243 | err_cleanup: |
244 | sti_cleanup(ddev); | |
a08eac47 TZ |
245 | err_drm_dev_put: |
246 | drm_dev_put(ddev); | |
84601dbd | 247 | return ret; |
9bbf86fe BG |
248 | } |
249 | ||
9e1f05b2 | 250 | static void sti_unbind(struct device *dev) |
9bbf86fe | 251 | { |
84601dbd BG |
252 | struct drm_device *ddev = dev_get_drvdata(dev); |
253 | ||
254 | drm_dev_unregister(ddev); | |
255 | sti_cleanup(ddev); | |
a08eac47 | 256 | drm_dev_put(ddev); |
9bbf86fe BG |
257 | } |
258 | ||
9e1f05b2 VA |
259 | static const struct component_master_ops sti_ops = { |
260 | .bind = sti_bind, | |
261 | .unbind = sti_unbind, | |
9bbf86fe BG |
262 | }; |
263 | ||
9e1f05b2 | 264 | static int sti_platform_probe(struct platform_device *pdev) |
9bbf86fe BG |
265 | { |
266 | struct device *dev = &pdev->dev; | |
53bdcf5f | 267 | struct device_node *node = dev->of_node; |
9bbf86fe BG |
268 | struct device_node *child_np; |
269 | struct component_match *match = NULL; | |
270 | ||
271 | dma_set_coherent_mask(dev, DMA_BIT_MASK(32)); | |
272 | ||
ac7d3af8 | 273 | devm_of_platform_populate(dev); |
53bdcf5f | 274 | |
9bbf86fe BG |
275 | child_np = of_get_next_available_child(node, NULL); |
276 | ||
277 | while (child_np) { | |
97ac0e47 RK |
278 | drm_of_component_match_add(dev, &match, compare_of, |
279 | child_np); | |
9bbf86fe BG |
280 | child_np = of_get_next_available_child(node, child_np); |
281 | } | |
282 | ||
9e1f05b2 | 283 | return component_master_add_with_match(dev, &sti_ops, match); |
9bbf86fe BG |
284 | } |
285 | ||
9e1f05b2 | 286 | static int sti_platform_remove(struct platform_device *pdev) |
9bbf86fe | 287 | { |
9e1f05b2 | 288 | component_master_del(&pdev->dev, &sti_ops); |
53bdcf5f | 289 | |
9bbf86fe BG |
290 | return 0; |
291 | } | |
292 | ||
9e1f05b2 | 293 | static const struct of_device_id sti_dt_ids[] = { |
9bbf86fe BG |
294 | { .compatible = "st,sti-display-subsystem", }, |
295 | { /* end node */ }, | |
296 | }; | |
9e1f05b2 | 297 | MODULE_DEVICE_TABLE(of, sti_dt_ids); |
9bbf86fe | 298 | |
9e1f05b2 VA |
299 | static struct platform_driver sti_platform_driver = { |
300 | .probe = sti_platform_probe, | |
301 | .remove = sti_platform_remove, | |
9bbf86fe | 302 | .driver = { |
9bbf86fe | 303 | .name = DRIVER_NAME, |
9e1f05b2 | 304 | .of_match_table = sti_dt_ids, |
9bbf86fe BG |
305 | }, |
306 | }; | |
307 | ||
dcec16ef TR |
308 | static struct platform_driver * const drivers[] = { |
309 | &sti_tvout_driver, | |
dcec16ef TR |
310 | &sti_hqvdp_driver, |
311 | &sti_hdmi_driver, | |
312 | &sti_hda_driver, | |
313 | &sti_dvo_driver, | |
314 | &sti_vtg_driver, | |
315 | &sti_compositor_driver, | |
316 | &sti_platform_driver, | |
317 | }; | |
318 | ||
319 | static int sti_drm_init(void) | |
320 | { | |
321 | return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); | |
322 | } | |
323 | module_init(sti_drm_init); | |
324 | ||
325 | static void sti_drm_exit(void) | |
326 | { | |
327 | platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); | |
328 | } | |
329 | module_exit(sti_drm_exit); | |
9bbf86fe BG |
330 | |
331 | MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>"); | |
332 | MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver"); | |
333 | MODULE_LICENSE("GPL"); |