1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) STMicroelectronics SA 2014
  4 * Author: Benjamin Gaignard <benjamin.gaignard@st.com> for STMicroelectronics.
  5 */
  6
  7#include <linux/component.h>
  8#include <linux/dma-mapping.h>
  9#include <linux/kernel.h>
 10#include <linux/module.h>
 11#include <linux/of_platform.h>
 12
 13#include <drm/drm_atomic.h>
 14#include <drm/drm_atomic_helper.h>
 15#include <drm/drm_debugfs.h>
 16#include <drm/drm_drv.h>
 17#include <drm/drm_fb_cma_helper.h>
 18#include <drm/drm_fb_helper.h>
 19#include <drm/drm_gem_cma_helper.h>
 20#include <drm/drm_gem_framebuffer_helper.h>
 21#include <drm/drm_of.h>
 22#include <drm/drm_probe_helper.h>
 23
 24#include "sti_drv.h"
 25#include "sti_plane.h"
 26
 27#define DRIVER_NAME	"sti"
 28#define DRIVER_DESC	"STMicroelectronics SoC DRM"
 29#define DRIVER_DATE	"20140601"
 30#define DRIVER_MAJOR	1
 31#define DRIVER_MINOR	0
 32
 33#define STI_MAX_FB_HEIGHT	4096
 34#define STI_MAX_FB_WIDTH	4096
 35
 36static int sti_drm_fps_get(void *data, u64 *val)
 37{
 38	struct drm_device *drm_dev = data;
 39	struct drm_plane *p;
 40	unsigned int i = 0;
 41
 42	*val = 0;
 43	list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) {
 44		struct sti_plane *plane = to_sti_plane(p);
 45
 46		*val |= plane->fps_info.output << i;
 47		i++;
 48	}
 49
 50	return 0;
 51}
 52
 53static int sti_drm_fps_set(void *data, u64 val)
 54{
 55	struct drm_device *drm_dev = data;
 56	struct drm_plane *p;
 57	unsigned int i = 0;
 58
 59	list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) {
 60		struct sti_plane *plane = to_sti_plane(p);
 61
 62		memset(&plane->fps_info, 0, sizeof(plane->fps_info));
 63		plane->fps_info.output = (val >> i) & 1;
 64
 65		i++;
 66	}
 67
 68	return 0;
 69}
 70
 71DEFINE_SIMPLE_ATTRIBUTE(sti_drm_fps_fops,
 72			sti_drm_fps_get, sti_drm_fps_set, "%llu\n");
 73
 74static int sti_drm_fps_dbg_show(struct seq_file *s, void *data)
 75{
 76	struct drm_info_node *node = s->private;
 77	struct drm_device *dev = node->minor->dev;
 78	struct drm_plane *p;
 79
 80	list_for_each_entry(p, &dev->mode_config.plane_list, head) {
 81		struct sti_plane *plane = to_sti_plane(p);
 82
 83		seq_printf(s, "%s%s\n",
 84			   plane->fps_info.fps_str,
 85			   plane->fps_info.fips_str);
 86	}
 87
 88	return 0;
 89}
 90
 91static struct drm_info_list sti_drm_dbg_list[] = {
 92	{"fps_get", sti_drm_fps_dbg_show, 0},
 93};
 94
 95static void sti_drm_dbg_init(struct drm_minor *minor)
 96{
 97	drm_debugfs_create_files(sti_drm_dbg_list,
 98				 ARRAY_SIZE(sti_drm_dbg_list),
 99				 minor->debugfs_root, minor);
100
101	debugfs_create_file("fps_show", S_IRUGO | S_IWUSR, minor->debugfs_root,
102			    minor->dev, &sti_drm_fps_fops);
103
104	DRM_INFO("%s: debugfs installed\n", DRIVER_NAME);
105}
106
107static const struct drm_mode_config_funcs sti_mode_config_funcs = {
108	.fb_create = drm_gem_fb_create,
109	.atomic_check = drm_atomic_helper_check,
110	.atomic_commit = drm_atomic_helper_commit,
111};
112
113static void sti_mode_config_init(struct drm_device *dev)
114{
115	dev->mode_config.min_width = 0;
116	dev->mode_config.min_height = 0;
117
118	/*
119	 * set max width and height as default value.
120	 * this value would be used to check framebuffer size limitation
121	 * at drm_mode_addfb().
122	 */
123	dev->mode_config.max_width = STI_MAX_FB_WIDTH;
124	dev->mode_config.max_height = STI_MAX_FB_HEIGHT;
125
126	dev->mode_config.funcs = &sti_mode_config_funcs;
127
128	dev->mode_config.normalize_zpos = true;
129}
130
131DEFINE_DRM_GEM_CMA_FOPS(sti_driver_fops);
132
133static struct drm_driver sti_driver = {
134	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
135	.fops = &sti_driver_fops,
136	DRM_GEM_CMA_DRIVER_OPS,
137
138	.debugfs_init = sti_drm_dbg_init,
139
140	.name = DRIVER_NAME,
141	.desc = DRIVER_DESC,
142	.date = DRIVER_DATE,
143	.major = DRIVER_MAJOR,
144	.minor = DRIVER_MINOR,
145};
146
147static int compare_of(struct device *dev, void *data)
148{
149	return dev->of_node == data;
150}
151
152static int sti_init(struct drm_device *ddev)
153{
154	struct sti_private *private;
155
156	private = kzalloc(sizeof(*private), GFP_KERNEL);
157	if (!private)
158		return -ENOMEM;
159
160	ddev->dev_private = (void *)private;
161	dev_set_drvdata(ddev->dev, ddev);
162	private->drm_dev = ddev;
163
164	drm_mode_config_init(ddev);
165
166	sti_mode_config_init(ddev);
167
168	drm_kms_helper_poll_init(ddev);
169
170	return 0;
171}
172
173static void sti_cleanup(struct drm_device *ddev)
174{
175	struct sti_private *private = ddev->dev_private;
176
177	drm_kms_helper_poll_fini(ddev);
178	drm_atomic_helper_shutdown(ddev);
179	drm_mode_config_cleanup(ddev);
180	component_unbind_all(ddev->dev, ddev);
181	kfree(private);
182	ddev->dev_private = NULL;
183}
184
185static int sti_bind(struct device *dev)
186{
187	struct drm_device *ddev;
188	int ret;
189
190	ddev = drm_dev_alloc(&sti_driver, dev);
191	if (IS_ERR(ddev))
192		return PTR_ERR(ddev);
193
194	ret = sti_init(ddev);
195	if (ret)
196		goto err_drm_dev_put;
197
198	ret = component_bind_all(ddev->dev, ddev);
199	if (ret)
200		goto err_cleanup;
201
202	ret = drm_dev_register(ddev, 0);
203	if (ret)
204		goto err_cleanup;
205
206	drm_mode_config_reset(ddev);
207
208	drm_fbdev_generic_setup(ddev, 32);
209
210	return 0;
211
212err_cleanup:
213	sti_cleanup(ddev);
214err_drm_dev_put:
215	drm_dev_put(ddev);
216	return ret;
217}
218
219static void sti_unbind(struct device *dev)
220{
221	struct drm_device *ddev = dev_get_drvdata(dev);
222
223	drm_dev_unregister(ddev);
224	sti_cleanup(ddev);
225	drm_dev_put(ddev);
226}
227
228static const struct component_master_ops sti_ops = {
229	.bind = sti_bind,
230	.unbind = sti_unbind,
231};
232
233static int sti_platform_probe(struct platform_device *pdev)
234{
235	struct device *dev = &pdev->dev;
236	struct device_node *node = dev->of_node;
237	struct device_node *child_np;
238	struct component_match *match = NULL;
239
240	dma_set_coherent_mask(dev, DMA_BIT_MASK(32));
241
242	devm_of_platform_populate(dev);
243
244	child_np = of_get_next_available_child(node, NULL);
245
246	while (child_np) {
247		drm_of_component_match_add(dev, &match, compare_of,
248					   child_np);
249		child_np = of_get_next_available_child(node, child_np);
250	}
251
252	return component_master_add_with_match(dev, &sti_ops, match);
253}
254
255static int sti_platform_remove(struct platform_device *pdev)
256{
257	component_master_del(&pdev->dev, &sti_ops);
258
259	return 0;
260}
261
262static const struct of_device_id sti_dt_ids[] = {
263	{ .compatible = "st,sti-display-subsystem", },
264	{ /* end node */ },
265};
266MODULE_DEVICE_TABLE(of, sti_dt_ids);
267
268static struct platform_driver sti_platform_driver = {
269	.probe = sti_platform_probe,
270	.remove = sti_platform_remove,
271	.driver = {
272		.name = DRIVER_NAME,
273		.of_match_table = sti_dt_ids,
274	},
275};
276
277static struct platform_driver * const drivers[] = {
278	&sti_tvout_driver,
279	&sti_hqvdp_driver,
280	&sti_hdmi_driver,
281	&sti_hda_driver,
282	&sti_dvo_driver,
283	&sti_vtg_driver,
284	&sti_compositor_driver,
285	&sti_platform_driver,
286};
287
288static int sti_drm_init(void)
289{
290	return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
291}
292module_init(sti_drm_init);
293
294static void sti_drm_exit(void)
295{
296	platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
297}
298module_exit(sti_drm_exit);
299
300MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>");
301MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver");
302MODULE_LICENSE("GPL");