1// SPDX-License-Identifier: GPL-2.0-only
2
3#include <linux/aperture.h>
4#include <linux/clk.h>
5#include <linux/minmax.h>
6#include <linux/of_address.h>
7#include <linux/of_clk.h>
8#include <linux/of_reserved_mem.h>
9#include <linux/platform_data/simplefb.h>
10#include <linux/platform_device.h>
11#include <linux/pm_domain.h>
12#include <linux/regulator/consumer.h>
13
14#include <drm/clients/drm_client_setup.h>
15#include <drm/drm_atomic.h>
16#include <drm/drm_atomic_state_helper.h>
17#include <drm/drm_connector.h>
18#include <drm/drm_damage_helper.h>
19#include <drm/drm_device.h>
20#include <drm/drm_drv.h>
21#include <drm/drm_fbdev_shmem.h>
22#include <drm/drm_framebuffer.h>
23#include <drm/drm_gem_atomic_helper.h>
24#include <drm/drm_gem_framebuffer_helper.h>
25#include <drm/drm_gem_shmem_helper.h>
26#include <drm/drm_managed.h>
27#include <drm/drm_modeset_helper_vtables.h>
28#include <drm/drm_print.h>
29#include <drm/drm_probe_helper.h>
30
31#include "drm_sysfb_helper.h"
32
33#define DRIVER_NAME "simpledrm"
34#define DRIVER_DESC "DRM driver for simple-framebuffer platform devices"
35#define DRIVER_MAJOR 1
36#define DRIVER_MINOR 0
37
38/*
39 * Helpers for simplefb
40 */
41
42static int
43simplefb_get_validated_int(struct drm_device *dev, const char *name,
44 uint32_t value)
45{
46 return drm_sysfb_get_validated_int(dev, name, value, INT_MAX);
47}
48
49static int
50simplefb_get_validated_int0(struct drm_device *dev, const char *name,
51 uint32_t value)
52{
53 return drm_sysfb_get_validated_int0(dev, name, value, INT_MAX);
54}
55
56static const struct drm_format_info *
57simplefb_get_validated_format(struct drm_device *dev, const char *format_name)
58{
59 static const struct simplefb_format formats[] = SIMPLEFB_FORMATS;
60 const struct simplefb_format *fmt = formats;
61 const struct simplefb_format *end = fmt + ARRAY_SIZE(formats);
62 const struct drm_format_info *info;
63
64 if (!format_name) {
65 drm_err(dev, "simplefb: missing framebuffer format\n");
66 return ERR_PTR(error: -EINVAL);
67 }
68
69 while (fmt < end) {
70 if (!strcmp(format_name, fmt->name)) {
71 info = drm_format_info(format: fmt->fourcc);
72 if (!info)
73 return ERR_PTR(error: -EINVAL);
74 return info;
75 }
76 ++fmt;
77 }
78
79 drm_err(dev, "simplefb: unknown framebuffer format %s\n",
80 format_name);
81
82 return ERR_PTR(error: -EINVAL);
83}
84
85static int
86simplefb_get_width_pd(struct drm_device *dev,
87 const struct simplefb_platform_data *pd)
88{
89 return simplefb_get_validated_int0(dev, name: "width", value: pd->width);
90}
91
92static int
93simplefb_get_height_pd(struct drm_device *dev,
94 const struct simplefb_platform_data *pd)
95{
96 return simplefb_get_validated_int0(dev, name: "height", value: pd->height);
97}
98
99static int
100simplefb_get_stride_pd(struct drm_device *dev,
101 const struct simplefb_platform_data *pd)
102{
103 return simplefb_get_validated_int(dev, name: "stride", value: pd->stride);
104}
105
106static const struct drm_format_info *
107simplefb_get_format_pd(struct drm_device *dev,
108 const struct simplefb_platform_data *pd)
109{
110 return simplefb_get_validated_format(dev, format_name: pd->format);
111}
112
113static int
114simplefb_read_u32_of(struct drm_device *dev, struct device_node *of_node,
115 const char *name, u32 *value)
116{
117 int ret = of_property_read_u32(np: of_node, propname: name, out_value: value);
118
119 if (ret)
120 drm_err(dev, "simplefb: cannot parse framebuffer %s: error %d\n",
121 name, ret);
122 return ret;
123}
124
125static int
126simplefb_read_string_of(struct drm_device *dev, struct device_node *of_node,
127 const char *name, const char **value)
128{
129 int ret = of_property_read_string(np: of_node, propname: name, out_string: value);
130
131 if (ret)
132 drm_err(dev, "simplefb: cannot parse framebuffer %s: error %d\n",
133 name, ret);
134 return ret;
135}
136
137static int
138simplefb_get_width_of(struct drm_device *dev, struct device_node *of_node)
139{
140 u32 width;
141 int ret = simplefb_read_u32_of(dev, of_node, name: "width", value: &width);
142
143 if (ret)
144 return ret;
145 return simplefb_get_validated_int0(dev, name: "width", value: width);
146}
147
148static int
149simplefb_get_height_of(struct drm_device *dev, struct device_node *of_node)
150{
151 u32 height;
152 int ret = simplefb_read_u32_of(dev, of_node, name: "height", value: &height);
153
154 if (ret)
155 return ret;
156 return simplefb_get_validated_int0(dev, name: "height", value: height);
157}
158
159static int
160simplefb_get_stride_of(struct drm_device *dev, struct device_node *of_node)
161{
162 u32 stride;
163 int ret = simplefb_read_u32_of(dev, of_node, name: "stride", value: &stride);
164
165 if (ret)
166 return ret;
167 return simplefb_get_validated_int(dev, name: "stride", value: stride);
168}
169
170static const struct drm_format_info *
171simplefb_get_format_of(struct drm_device *dev, struct device_node *of_node)
172{
173 const char *format;
174 int ret = simplefb_read_string_of(dev, of_node, name: "format", value: &format);
175
176 if (ret)
177 return ERR_PTR(error: ret);
178 return simplefb_get_validated_format(dev, format_name: format);
179}
180
181static struct resource *
182simplefb_get_memory_of(struct drm_device *dev, struct device_node *of_node)
183{
184 struct resource r, *res;
185 int err;
186
187 err = of_reserved_mem_region_to_resource(np: of_node, idx: 0, res: &r);
188 if (err)
189 return NULL;
190
191 res = devm_kmemdup(dev: dev->dev, src: &r, len: sizeof(r), GFP_KERNEL);
192 if (!res)
193 return ERR_PTR(error: -ENOMEM);
194
195 if (of_property_present(np: of_node, propname: "reg"))
196 drm_warn(dev, "preferring \"memory-region\" over \"reg\" property\n");
197
198 return res;
199}
200
201/*
202 * Simple Framebuffer device
203 */
204
205struct simpledrm_device {
206 struct drm_sysfb_device sysfb;
207
208 /* clocks */
209#if defined CONFIG_OF && defined CONFIG_COMMON_CLK
210 unsigned int clk_count;
211 struct clk **clks;
212#endif
213 /* regulators */
214#if defined CONFIG_OF && defined CONFIG_REGULATOR
215 unsigned int regulator_count;
216 struct regulator **regulators;
217#endif
218 /* power-domains */
219#if defined CONFIG_OF && defined CONFIG_PM_GENERIC_DOMAINS
220 int pwr_dom_count;
221 struct device **pwr_dom_devs;
222 struct device_link **pwr_dom_links;
223#endif
224
225 /* modesetting */
226 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)];
227 struct drm_plane primary_plane;
228 struct drm_crtc crtc;
229 struct drm_encoder encoder;
230 struct drm_connector connector;
231};
232
233/*
234 * Hardware
235 */
236
237#if defined CONFIG_OF && defined CONFIG_COMMON_CLK
238/*
239 * Clock handling code.
240 *
241 * Here we handle the clocks property of our "simple-framebuffer" dt node.
242 * This is necessary so that we can make sure that any clocks needed by
243 * the display engine that the bootloader set up for us (and for which it
244 * provided a simplefb dt node), stay up, for the life of the simplefb
245 * driver.
246 *
247 * When the driver unloads, we cleanly disable, and then release the clocks.
248 *
249 * We only complain about errors here, no action is taken as the most likely
250 * error can only happen due to a mismatch between the bootloader which set
251 * up simplefb, and the clock definitions in the device tree. Chances are
252 * that there are no adverse effects, and if there are, a clean teardown of
253 * the fb probe will not help us much either. So just complain and carry on,
254 * and hope that the user actually gets a working fb at the end of things.
255 */
256
257static void simpledrm_device_release_clocks(void *res)
258{
259 struct simpledrm_device *sdev = res;
260 unsigned int i;
261
262 for (i = 0; i < sdev->clk_count; ++i) {
263 if (sdev->clks[i]) {
264 clk_disable_unprepare(clk: sdev->clks[i]);
265 clk_put(clk: sdev->clks[i]);
266 }
267 }
268}
269
270static int simpledrm_device_init_clocks(struct simpledrm_device *sdev)
271{
272 struct drm_device *dev = &sdev->sysfb.dev;
273 struct platform_device *pdev = to_platform_device(dev->dev);
274 struct device_node *of_node = pdev->dev.of_node;
275 struct clk *clock;
276 unsigned int i;
277 int ret;
278
279 if (dev_get_platdata(dev: &pdev->dev) || !of_node)
280 return 0;
281
282 sdev->clk_count = of_clk_get_parent_count(np: of_node);
283 if (!sdev->clk_count)
284 return 0;
285
286 sdev->clks = drmm_kzalloc(dev, size: sdev->clk_count * sizeof(sdev->clks[0]),
287 GFP_KERNEL);
288 if (!sdev->clks)
289 return -ENOMEM;
290
291 for (i = 0; i < sdev->clk_count; ++i) {
292 clock = of_clk_get(np: of_node, index: i);
293 if (IS_ERR(ptr: clock)) {
294 ret = PTR_ERR(ptr: clock);
295 if (ret == -EPROBE_DEFER)
296 goto err;
297 drm_err(dev, "clock %u not found: %d\n", i, ret);
298 continue;
299 }
300 ret = clk_prepare_enable(clk: clock);
301 if (ret) {
302 drm_err(dev, "failed to enable clock %u: %d\n",
303 i, ret);
304 clk_put(clk: clock);
305 continue;
306 }
307 sdev->clks[i] = clock;
308 }
309
310 return devm_add_action_or_reset(&pdev->dev,
311 simpledrm_device_release_clocks,
312 sdev);
313
314err:
315 while (i) {
316 --i;
317 if (sdev->clks[i]) {
318 clk_disable_unprepare(clk: sdev->clks[i]);
319 clk_put(clk: sdev->clks[i]);
320 }
321 }
322 return ret;
323}
324#else
325static int simpledrm_device_init_clocks(struct simpledrm_device *sdev)
326{
327 return 0;
328}
329#endif
330
331#if defined CONFIG_OF && defined CONFIG_REGULATOR
332
333#define SUPPLY_SUFFIX "-supply"
334
335/*
336 * Regulator handling code.
337 *
338 * Here we handle the num-supplies and vin*-supply properties of our
339 * "simple-framebuffer" dt node. This is necessary so that we can make sure
340 * that any regulators needed by the display hardware that the bootloader
341 * set up for us (and for which it provided a simplefb dt node), stay up,
342 * for the life of the simplefb driver.
343 *
344 * When the driver unloads, we cleanly disable, and then release the
345 * regulators.
346 *
347 * We only complain about errors here, no action is taken as the most likely
348 * error can only happen due to a mismatch between the bootloader which set
349 * up simplefb, and the regulator definitions in the device tree. Chances are
350 * that there are no adverse effects, and if there are, a clean teardown of
351 * the fb probe will not help us much either. So just complain and carry on,
352 * and hope that the user actually gets a working fb at the end of things.
353 */
354
355static void simpledrm_device_release_regulators(void *res)
356{
357 struct simpledrm_device *sdev = res;
358 unsigned int i;
359
360 for (i = 0; i < sdev->regulator_count; ++i) {
361 if (sdev->regulators[i]) {
362 regulator_disable(regulator: sdev->regulators[i]);
363 regulator_put(regulator: sdev->regulators[i]);
364 }
365 }
366}
367
368static int simpledrm_device_init_regulators(struct simpledrm_device *sdev)
369{
370 struct drm_device *dev = &sdev->sysfb.dev;
371 struct platform_device *pdev = to_platform_device(dev->dev);
372 struct device_node *of_node = pdev->dev.of_node;
373 struct property *prop;
374 struct regulator *regulator;
375 const char *p;
376 unsigned int count = 0, i = 0;
377 int ret;
378
379 if (dev_get_platdata(dev: &pdev->dev) || !of_node)
380 return 0;
381
382 /* Count the number of regulator supplies */
383 for_each_property_of_node(of_node, prop) {
384 p = strstr(prop->name, SUPPLY_SUFFIX);
385 if (p && p != prop->name)
386 ++count;
387 }
388
389 if (!count)
390 return 0;
391
392 sdev->regulators = drmm_kzalloc(dev,
393 size: count * sizeof(sdev->regulators[0]),
394 GFP_KERNEL);
395 if (!sdev->regulators)
396 return -ENOMEM;
397
398 for_each_property_of_node(of_node, prop) {
399 char name[32]; /* 32 is max size of property name */
400 size_t len;
401
402 p = strstr(prop->name, SUPPLY_SUFFIX);
403 if (!p || p == prop->name)
404 continue;
405 len = strlen(prop->name) - strlen(SUPPLY_SUFFIX) + 1;
406 strscpy(name, prop->name, min(sizeof(name), len));
407
408 regulator = regulator_get_optional(dev: &pdev->dev, id: name);
409 if (IS_ERR(ptr: regulator)) {
410 ret = PTR_ERR(ptr: regulator);
411 if (ret == -EPROBE_DEFER)
412 goto err;
413 drm_err(dev, "regulator %s not found: %d\n",
414 name, ret);
415 continue;
416 }
417
418 ret = regulator_enable(regulator);
419 if (ret) {
420 drm_err(dev, "failed to enable regulator %u: %d\n",
421 i, ret);
422 regulator_put(regulator);
423 continue;
424 }
425
426 sdev->regulators[i++] = regulator;
427 }
428 sdev->regulator_count = i;
429
430 return devm_add_action_or_reset(&pdev->dev,
431 simpledrm_device_release_regulators,
432 sdev);
433
434err:
435 while (i) {
436 --i;
437 if (sdev->regulators[i]) {
438 regulator_disable(regulator: sdev->regulators[i]);
439 regulator_put(regulator: sdev->regulators[i]);
440 }
441 }
442 return ret;
443}
444#else
445static int simpledrm_device_init_regulators(struct simpledrm_device *sdev)
446{
447 return 0;
448}
449#endif
450
451#if defined CONFIG_OF && defined CONFIG_PM_GENERIC_DOMAINS
452/*
453 * Generic power domain handling code.
454 *
455 * Here we handle the power-domains properties of our "simple-framebuffer"
456 * dt node. This is only necessary if there is more than one power-domain.
457 * A single power-domains is handled automatically by the driver core. Multiple
458 * power-domains have to be handled by drivers since the driver core can't know
459 * the correct power sequencing. Power sequencing is not an issue for simpledrm
460 * since the bootloader has put the power domains already in the correct state.
461 * simpledrm has only to ensure they remain active for its lifetime.
462 *
463 * When the driver unloads, we detach from the power-domains.
464 *
465 * We only complain about errors here, no action is taken as the most likely
466 * error can only happen due to a mismatch between the bootloader which set
467 * up the "simple-framebuffer" dt node, and the PM domain providers in the
468 * device tree. Chances are that there are no adverse effects, and if there are,
469 * a clean teardown of the fb probe will not help us much either. So just
470 * complain and carry on, and hope that the user actually gets a working fb at
471 * the end of things.
472 */
473static void simpledrm_device_detach_genpd(void *res)
474{
475 int i;
476 struct simpledrm_device *sdev = res;
477
478 if (sdev->pwr_dom_count <= 1)
479 return;
480
481 for (i = sdev->pwr_dom_count - 1; i >= 0; i--) {
482 if (sdev->pwr_dom_links[i])
483 device_link_del(link: sdev->pwr_dom_links[i]);
484 if (!IS_ERR_OR_NULL(ptr: sdev->pwr_dom_devs[i]))
485 dev_pm_domain_detach(dev: sdev->pwr_dom_devs[i], power_off: true);
486 }
487}
488
489static int simpledrm_device_attach_genpd(struct simpledrm_device *sdev)
490{
491 struct device *dev = sdev->sysfb.dev.dev;
492 int i;
493
494 sdev->pwr_dom_count = of_count_phandle_with_args(np: dev->of_node, list_name: "power-domains",
495 cells_name: "#power-domain-cells");
496 /*
497 * Single power-domain devices are handled by driver core nothing to do
498 * here. The same for device nodes without "power-domains" property.
499 */
500 if (sdev->pwr_dom_count <= 1)
501 return 0;
502
503 sdev->pwr_dom_devs = devm_kcalloc(dev, n: sdev->pwr_dom_count,
504 size: sizeof(*sdev->pwr_dom_devs),
505 GFP_KERNEL);
506 if (!sdev->pwr_dom_devs)
507 return -ENOMEM;
508
509 sdev->pwr_dom_links = devm_kcalloc(dev, n: sdev->pwr_dom_count,
510 size: sizeof(*sdev->pwr_dom_links),
511 GFP_KERNEL);
512 if (!sdev->pwr_dom_links)
513 return -ENOMEM;
514
515 for (i = 0; i < sdev->pwr_dom_count; i++) {
516 sdev->pwr_dom_devs[i] = dev_pm_domain_attach_by_id(dev, index: i);
517 if (IS_ERR(ptr: sdev->pwr_dom_devs[i])) {
518 int ret = PTR_ERR(ptr: sdev->pwr_dom_devs[i]);
519 if (ret == -EPROBE_DEFER) {
520 simpledrm_device_detach_genpd(res: sdev);
521 return ret;
522 }
523 drm_warn(&sdev->sysfb.dev,
524 "pm_domain_attach_by_id(%u) failed: %d\n", i, ret);
525 continue;
526 }
527
528 sdev->pwr_dom_links[i] = device_link_add(consumer: dev,
529 supplier: sdev->pwr_dom_devs[i],
530 DL_FLAG_STATELESS |
531 DL_FLAG_PM_RUNTIME |
532 DL_FLAG_RPM_ACTIVE);
533 if (!sdev->pwr_dom_links[i])
534 drm_warn(&sdev->sysfb.dev, "failed to link power-domain %d\n", i);
535 }
536
537 return devm_add_action_or_reset(dev, simpledrm_device_detach_genpd, sdev);
538}
539#else
540static int simpledrm_device_attach_genpd(struct simpledrm_device *sdev)
541{
542 return 0;
543}
544#endif
545
546/*
547 * Modesetting
548 */
549
550static const u64 simpledrm_primary_plane_format_modifiers[] = {
551 DRM_SYSFB_PLANE_FORMAT_MODIFIERS,
552};
553
554static const struct drm_plane_helper_funcs simpledrm_primary_plane_helper_funcs = {
555 DRM_SYSFB_PLANE_HELPER_FUNCS,
556};
557
558static const struct drm_plane_funcs simpledrm_primary_plane_funcs = {
559 DRM_SYSFB_PLANE_FUNCS,
560 .destroy = drm_plane_cleanup,
561};
562
563static const struct drm_crtc_helper_funcs simpledrm_crtc_helper_funcs = {
564 DRM_SYSFB_CRTC_HELPER_FUNCS,
565};
566
567static const struct drm_crtc_funcs simpledrm_crtc_funcs = {
568 DRM_SYSFB_CRTC_FUNCS,
569 .destroy = drm_crtc_cleanup,
570};
571
572static const struct drm_encoder_funcs simpledrm_encoder_funcs = {
573 .destroy = drm_encoder_cleanup,
574};
575
576static const struct drm_connector_helper_funcs simpledrm_connector_helper_funcs = {
577 DRM_SYSFB_CONNECTOR_HELPER_FUNCS,
578};
579
580static const struct drm_connector_funcs simpledrm_connector_funcs = {
581 DRM_SYSFB_CONNECTOR_FUNCS,
582 .destroy = drm_connector_cleanup,
583};
584
585static const struct drm_mode_config_funcs simpledrm_mode_config_funcs = {
586 DRM_SYSFB_MODE_CONFIG_FUNCS,
587};
588
589/*
590 * Init / Cleanup
591 */
592
593static struct simpledrm_device *simpledrm_device_create(struct drm_driver *drv,
594 struct platform_device *pdev)
595{
596 const struct simplefb_platform_data *pd = dev_get_platdata(dev: &pdev->dev);
597 struct device_node *of_node = pdev->dev.of_node;
598 struct simpledrm_device *sdev;
599 struct drm_sysfb_device *sysfb;
600 struct drm_device *dev;
601 int width, height, stride;
602 int width_mm = 0, height_mm = 0;
603 struct device_node *panel_node;
604 const struct drm_format_info *format;
605 struct resource *res, *mem = NULL;
606 struct drm_plane *primary_plane;
607 struct drm_crtc *crtc;
608 struct drm_encoder *encoder;
609 struct drm_connector *connector;
610 unsigned long max_width, max_height;
611 size_t nformats;
612 int ret;
613
614 sdev = devm_drm_dev_alloc(&pdev->dev, drv, struct simpledrm_device, sysfb.dev);
615 if (IS_ERR(ptr: sdev))
616 return ERR_CAST(ptr: sdev);
617 sysfb = &sdev->sysfb;
618 dev = &sysfb->dev;
619 platform_set_drvdata(pdev, data: sdev);
620
621 /*
622 * Hardware settings
623 */
624
625 ret = simpledrm_device_init_clocks(sdev);
626 if (ret)
627 return ERR_PTR(error: ret);
628 ret = simpledrm_device_init_regulators(sdev);
629 if (ret)
630 return ERR_PTR(error: ret);
631 ret = simpledrm_device_attach_genpd(sdev);
632 if (ret)
633 return ERR_PTR(error: ret);
634
635 if (pd) {
636 width = simplefb_get_width_pd(dev, pd);
637 if (width < 0)
638 return ERR_PTR(error: width);
639 height = simplefb_get_height_pd(dev, pd);
640 if (height < 0)
641 return ERR_PTR(error: height);
642 stride = simplefb_get_stride_pd(dev, pd);
643 if (stride < 0)
644 return ERR_PTR(error: stride);
645 format = simplefb_get_format_pd(dev, pd);
646 if (IS_ERR(ptr: format))
647 return ERR_CAST(ptr: format);
648 } else if (of_node) {
649 width = simplefb_get_width_of(dev, of_node);
650 if (width < 0)
651 return ERR_PTR(error: width);
652 height = simplefb_get_height_of(dev, of_node);
653 if (height < 0)
654 return ERR_PTR(error: height);
655 stride = simplefb_get_stride_of(dev, of_node);
656 if (stride < 0)
657 return ERR_PTR(error: stride);
658 format = simplefb_get_format_of(dev, of_node);
659 if (IS_ERR(ptr: format))
660 return ERR_CAST(ptr: format);
661 mem = simplefb_get_memory_of(dev, of_node);
662 if (IS_ERR(ptr: mem))
663 return ERR_CAST(ptr: mem);
664 panel_node = of_parse_phandle(np: of_node, phandle_name: "panel", index: 0);
665 if (panel_node) {
666 simplefb_read_u32_of(dev, of_node: panel_node, name: "width-mm", value: &width_mm);
667 simplefb_read_u32_of(dev, of_node: panel_node, name: "height-mm", value: &height_mm);
668 of_node_put(node: panel_node);
669 }
670 } else {
671 drm_err(dev, "no simplefb configuration found\n");
672 return ERR_PTR(error: -ENODEV);
673 }
674 if (!stride) {
675 stride = drm_format_info_min_pitch(info: format, plane: 0, buffer_width: width);
676 if (drm_WARN_ON(dev, !stride))
677 return ERR_PTR(error: -EINVAL);
678 }
679
680 sysfb->fb_mode = drm_sysfb_mode(width, height, width_mm, height_mm);
681 sysfb->fb_format = format;
682 sysfb->fb_pitch = stride;
683
684 drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&sysfb->fb_mode));
685 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d byte\n",
686 &format->format, width, height, stride);
687
688 /*
689 * Memory management
690 */
691
692 if (mem) {
693 void *screen_base;
694
695 ret = devm_aperture_acquire_for_platform_device(pdev, base: mem->start,
696 size: resource_size(res: mem));
697 if (ret) {
698 drm_err(dev, "could not acquire memory range %pr: %d\n", mem, ret);
699 return ERR_PTR(error: ret);
700 }
701
702 drm_dbg(dev, "using system memory framebuffer at %pr\n", mem);
703
704 screen_base = devm_memremap(dev: dev->dev, offset: mem->start, size: resource_size(res: mem), flags: MEMREMAP_WC);
705 if (IS_ERR(ptr: screen_base))
706 return screen_base;
707
708 iosys_map_set_vaddr(map: &sysfb->fb_addr, vaddr: screen_base);
709 } else {
710 void __iomem *screen_base;
711
712 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
713 if (!res)
714 return ERR_PTR(error: -EINVAL);
715
716 ret = devm_aperture_acquire_for_platform_device(pdev, base: res->start,
717 size: resource_size(res));
718 if (ret) {
719 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret);
720 return ERR_PTR(error: ret);
721 }
722
723 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res);
724
725 mem = devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
726 drv->name);
727 if (!mem) {
728 /*
729 * We cannot make this fatal. Sometimes this comes from magic
730 * spaces our resource handlers simply don't know about. Use
731 * the I/O-memory resource as-is and try to map that instead.
732 */
733 drm_warn(dev, "could not acquire memory region %pr\n", res);
734 mem = res;
735 }
736
737 screen_base = devm_ioremap_wc(dev: &pdev->dev, offset: mem->start, size: resource_size(res: mem));
738 if (!screen_base)
739 return ERR_PTR(error: -ENOMEM);
740
741 iosys_map_set_vaddr_iomem(map: &sysfb->fb_addr, vaddr_iomem: screen_base);
742 }
743
744 /*
745 * Modesetting
746 */
747
748 ret = drmm_mode_config_init(dev);
749 if (ret)
750 return ERR_PTR(error: ret);
751
752 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
753 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
754
755 dev->mode_config.min_width = width;
756 dev->mode_config.max_width = max_width;
757 dev->mode_config.min_height = height;
758 dev->mode_config.max_height = max_height;
759 dev->mode_config.preferred_depth = format->depth;
760 dev->mode_config.funcs = &simpledrm_mode_config_funcs;
761
762 /* Primary plane */
763
764 nformats = drm_sysfb_build_fourcc_list(dev, native_fourccs: &format->format, native_nfourccs: 1,
765 fourccs_out: sdev->formats, ARRAY_SIZE(sdev->formats));
766
767 primary_plane = &sdev->primary_plane;
768 ret = drm_universal_plane_init(dev, plane: primary_plane, possible_crtcs: 0, funcs: &simpledrm_primary_plane_funcs,
769 formats: sdev->formats, format_count: nformats,
770 format_modifiers: simpledrm_primary_plane_format_modifiers,
771 type: DRM_PLANE_TYPE_PRIMARY, NULL);
772 if (ret)
773 return ERR_PTR(error: ret);
774 drm_plane_helper_add(plane: primary_plane, funcs: &simpledrm_primary_plane_helper_funcs);
775 drm_plane_enable_fb_damage_clips(plane: primary_plane);
776
777 /* CRTC */
778
779 crtc = &sdev->crtc;
780 ret = drm_crtc_init_with_planes(dev, crtc, primary: primary_plane, NULL,
781 funcs: &simpledrm_crtc_funcs, NULL);
782 if (ret)
783 return ERR_PTR(error: ret);
784 drm_crtc_helper_add(crtc, funcs: &simpledrm_crtc_helper_funcs);
785
786 /* Encoder */
787
788 encoder = &sdev->encoder;
789 ret = drm_encoder_init(dev, encoder, funcs: &simpledrm_encoder_funcs,
790 DRM_MODE_ENCODER_NONE, NULL);
791 if (ret)
792 return ERR_PTR(error: ret);
793 encoder->possible_crtcs = drm_crtc_mask(crtc);
794
795 /* Connector */
796
797 connector = &sdev->connector;
798 ret = drm_connector_init(dev, connector, funcs: &simpledrm_connector_funcs,
799 DRM_MODE_CONNECTOR_Unknown);
800 if (ret)
801 return ERR_PTR(error: ret);
802 drm_connector_helper_add(connector, funcs: &simpledrm_connector_helper_funcs);
803 drm_connector_set_panel_orientation_with_quirk(connector,
804 panel_orientation: DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
805 width, height);
806
807 ret = drm_connector_attach_encoder(connector, encoder);
808 if (ret)
809 return ERR_PTR(error: ret);
810
811 drm_mode_config_reset(dev);
812
813 return sdev;
814}
815
816/*
817 * DRM driver
818 */
819
820DEFINE_DRM_GEM_FOPS(simpledrm_fops);
821
822static struct drm_driver simpledrm_driver = {
823 DRM_GEM_SHMEM_DRIVER_OPS,
824 DRM_FBDEV_SHMEM_DRIVER_OPS,
825 .name = DRIVER_NAME,
826 .desc = DRIVER_DESC,
827 .major = DRIVER_MAJOR,
828 .minor = DRIVER_MINOR,
829 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
830 .fops = &simpledrm_fops,
831};
832
833/*
834 * Platform driver
835 */
836
837static int simpledrm_probe(struct platform_device *pdev)
838{
839 struct simpledrm_device *sdev;
840 struct drm_sysfb_device *sysfb;
841 struct drm_device *dev;
842 int ret;
843
844 sdev = simpledrm_device_create(drv: &simpledrm_driver, pdev);
845 if (IS_ERR(ptr: sdev))
846 return PTR_ERR(ptr: sdev);
847 sysfb = &sdev->sysfb;
848 dev = &sysfb->dev;
849
850 ret = drm_dev_register(dev, flags: 0);
851 if (ret)
852 return ret;
853
854 drm_client_setup(dev, format: sdev->sysfb.fb_format);
855
856 return 0;
857}
858
859static void simpledrm_remove(struct platform_device *pdev)
860{
861 struct simpledrm_device *sdev = platform_get_drvdata(pdev);
862 struct drm_device *dev = &sdev->sysfb.dev;
863
864 drm_dev_unplug(dev);
865}
866
867static const struct of_device_id simpledrm_of_match_table[] = {
868 { .compatible = "simple-framebuffer", },
869 { },
870};
871MODULE_DEVICE_TABLE(of, simpledrm_of_match_table);
872
873static struct platform_driver simpledrm_platform_driver = {
874 .driver = {
875 .name = "simple-framebuffer", /* connect to sysfb */
876 .of_match_table = simpledrm_of_match_table,
877 },
878 .probe = simpledrm_probe,
879 .remove = simpledrm_remove,
880};
881
882module_platform_driver(simpledrm_platform_driver);
883
884MODULE_DESCRIPTION(DRIVER_DESC);
885MODULE_LICENSE("GPL v2");
886

source code of linux/drivers/gpu/drm/sysfb/simpledrm.c