xref: /linux/drivers/video/fbdev/simplefb.c (revision 9025cebf12d1763de36d5e09e2b0a1e4f9b13b28)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Simplest possible simple frame-buffer driver, as a platform device
4  *
5  * Copyright (c) 2013, Stephen Warren
6  *
7  * Based on q40fb.c, which was:
8  * Copyright (C) 2001 Richard Zidlicky <rz@linux-m68k.org>
9  *
10  * Also based on offb.c, which was:
11  * Copyright (C) 1997 Geert Uytterhoeven
12  * Copyright (C) 1996 Paul Mackerras
13  */
14 
15 #include <linux/errno.h>
16 #include <linux/fb.h>
17 #include <linux/io.h>
18 #include <linux/module.h>
19 #include <linux/platform_data/simplefb.h>
20 #include <linux/platform_device.h>
21 #include <linux/clk.h>
22 #include <linux/of.h>
23 #include <linux/of_clk.h>
24 #include <linux/of_platform.h>
25 #include <linux/parser.h>
26 #include <linux/regulator/consumer.h>
27 
28 static const struct fb_fix_screeninfo simplefb_fix = {
29 	.id		= "simple",
30 	.type		= FB_TYPE_PACKED_PIXELS,
31 	.visual		= FB_VISUAL_TRUECOLOR,
32 	.accel		= FB_ACCEL_NONE,
33 };
34 
35 static const struct fb_var_screeninfo simplefb_var = {
36 	.height		= -1,
37 	.width		= -1,
38 	.activate	= FB_ACTIVATE_NOW,
39 	.vmode		= FB_VMODE_NONINTERLACED,
40 };
41 
42 #define PSEUDO_PALETTE_SIZE 16
43 
44 static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
45 			      u_int transp, struct fb_info *info)
46 {
47 	u32 *pal = info->pseudo_palette;
48 	u32 cr = red >> (16 - info->var.red.length);
49 	u32 cg = green >> (16 - info->var.green.length);
50 	u32 cb = blue >> (16 - info->var.blue.length);
51 	u32 value;
52 
53 	if (regno >= PSEUDO_PALETTE_SIZE)
54 		return -EINVAL;
55 
56 	value = (cr << info->var.red.offset) |
57 		(cg << info->var.green.offset) |
58 		(cb << info->var.blue.offset);
59 	if (info->var.transp.length > 0) {
60 		u32 mask = (1 << info->var.transp.length) - 1;
61 		mask <<= info->var.transp.offset;
62 		value |= mask;
63 	}
64 	pal[regno] = value;
65 
66 	return 0;
67 }
68 
69 struct simplefb_par {
70 	u32 palette[PSEUDO_PALETTE_SIZE];
71 	struct resource *mem;
72 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
73 	bool clks_enabled;
74 	unsigned int clk_count;
75 	struct clk **clks;
76 #endif
77 #if defined CONFIG_OF && defined CONFIG_REGULATOR
78 	bool regulators_enabled;
79 	u32 regulator_count;
80 	struct regulator **regulators;
81 #endif
82 };
83 
84 static void simplefb_clocks_destroy(struct simplefb_par *par);
85 static void simplefb_regulators_destroy(struct simplefb_par *par);
86 
87 /*
88  * fb_ops.fb_destroy is called by the last put_fb_info() call at the end
89  * of unregister_framebuffer() or fb_release(). Do any cleanup here.
90  */
91 static void simplefb_destroy(struct fb_info *info)
92 {
93 	struct simplefb_par *par = info->par;
94 	struct resource *mem = par->mem;
95 
96 	simplefb_regulators_destroy(info->par);
97 	simplefb_clocks_destroy(info->par);
98 	if (info->screen_base)
99 		iounmap(info->screen_base);
100 
101 	framebuffer_release(info);
102 
103 	if (mem)
104 		release_mem_region(mem->start, resource_size(mem));
105 }
106 
107 static const struct fb_ops simplefb_ops = {
108 	.owner		= THIS_MODULE,
109 	.fb_destroy	= simplefb_destroy,
110 	.fb_setcolreg	= simplefb_setcolreg,
111 	.fb_fillrect	= cfb_fillrect,
112 	.fb_copyarea	= cfb_copyarea,
113 	.fb_imageblit	= cfb_imageblit,
114 };
115 
116 static struct simplefb_format simplefb_formats[] = SIMPLEFB_FORMATS;
117 
118 struct simplefb_params {
119 	u32 width;
120 	u32 height;
121 	u32 stride;
122 	struct simplefb_format *format;
123 };
124 
125 static int simplefb_parse_dt(struct platform_device *pdev,
126 			   struct simplefb_params *params)
127 {
128 	struct device_node *np = pdev->dev.of_node;
129 	int ret;
130 	const char *format;
131 	int i;
132 
133 	ret = of_property_read_u32(np, "width", &params->width);
134 	if (ret) {
135 		dev_err(&pdev->dev, "Can't parse width property\n");
136 		return ret;
137 	}
138 
139 	ret = of_property_read_u32(np, "height", &params->height);
140 	if (ret) {
141 		dev_err(&pdev->dev, "Can't parse height property\n");
142 		return ret;
143 	}
144 
145 	ret = of_property_read_u32(np, "stride", &params->stride);
146 	if (ret) {
147 		dev_err(&pdev->dev, "Can't parse stride property\n");
148 		return ret;
149 	}
150 
151 	ret = of_property_read_string(np, "format", &format);
152 	if (ret) {
153 		dev_err(&pdev->dev, "Can't parse format property\n");
154 		return ret;
155 	}
156 	params->format = NULL;
157 	for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
158 		if (strcmp(format, simplefb_formats[i].name))
159 			continue;
160 		params->format = &simplefb_formats[i];
161 		break;
162 	}
163 	if (!params->format) {
164 		dev_err(&pdev->dev, "Invalid format value\n");
165 		return -EINVAL;
166 	}
167 
168 	return 0;
169 }
170 
171 static int simplefb_parse_pd(struct platform_device *pdev,
172 			     struct simplefb_params *params)
173 {
174 	struct simplefb_platform_data *pd = dev_get_platdata(&pdev->dev);
175 	int i;
176 
177 	params->width = pd->width;
178 	params->height = pd->height;
179 	params->stride = pd->stride;
180 
181 	params->format = NULL;
182 	for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
183 		if (strcmp(pd->format, simplefb_formats[i].name))
184 			continue;
185 
186 		params->format = &simplefb_formats[i];
187 		break;
188 	}
189 
190 	if (!params->format) {
191 		dev_err(&pdev->dev, "Invalid format value\n");
192 		return -EINVAL;
193 	}
194 
195 	return 0;
196 }
197 
198 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
199 /*
200  * Clock handling code.
201  *
202  * Here we handle the clocks property of our "simple-framebuffer" dt node.
203  * This is necessary so that we can make sure that any clocks needed by
204  * the display engine that the bootloader set up for us (and for which it
205  * provided a simplefb dt node), stay up, for the life of the simplefb
206  * driver.
207  *
208  * When the driver unloads, we cleanly disable, and then release the clocks.
209  *
210  * We only complain about errors here, no action is taken as the most likely
211  * error can only happen due to a mismatch between the bootloader which set
212  * up simplefb, and the clock definitions in the device tree. Chances are
213  * that there are no adverse effects, and if there are, a clean teardown of
214  * the fb probe will not help us much either. So just complain and carry on,
215  * and hope that the user actually gets a working fb at the end of things.
216  */
217 static int simplefb_clocks_get(struct simplefb_par *par,
218 			       struct platform_device *pdev)
219 {
220 	struct device_node *np = pdev->dev.of_node;
221 	struct clk *clock;
222 	int i;
223 
224 	if (dev_get_platdata(&pdev->dev) || !np)
225 		return 0;
226 
227 	par->clk_count = of_clk_get_parent_count(np);
228 	if (!par->clk_count)
229 		return 0;
230 
231 	par->clks = kcalloc(par->clk_count, sizeof(struct clk *), GFP_KERNEL);
232 	if (!par->clks)
233 		return -ENOMEM;
234 
235 	for (i = 0; i < par->clk_count; i++) {
236 		clock = of_clk_get(np, i);
237 		if (IS_ERR(clock)) {
238 			if (PTR_ERR(clock) == -EPROBE_DEFER) {
239 				while (--i >= 0) {
240 					clk_put(par->clks[i]);
241 				}
242 				kfree(par->clks);
243 				return -EPROBE_DEFER;
244 			}
245 			dev_err(&pdev->dev, "%s: clock %d not found: %ld\n",
246 				__func__, i, PTR_ERR(clock));
247 			continue;
248 		}
249 		par->clks[i] = clock;
250 	}
251 
252 	return 0;
253 }
254 
255 static void simplefb_clocks_enable(struct simplefb_par *par,
256 				   struct platform_device *pdev)
257 {
258 	int i, ret;
259 
260 	for (i = 0; i < par->clk_count; i++) {
261 		if (par->clks[i]) {
262 			ret = clk_prepare_enable(par->clks[i]);
263 			if (ret) {
264 				dev_err(&pdev->dev,
265 					"%s: failed to enable clock %d: %d\n",
266 					__func__, i, ret);
267 				clk_put(par->clks[i]);
268 				par->clks[i] = NULL;
269 			}
270 		}
271 	}
272 	par->clks_enabled = true;
273 }
274 
275 static void simplefb_clocks_destroy(struct simplefb_par *par)
276 {
277 	int i;
278 
279 	if (!par->clks)
280 		return;
281 
282 	for (i = 0; i < par->clk_count; i++) {
283 		if (par->clks[i]) {
284 			if (par->clks_enabled)
285 				clk_disable_unprepare(par->clks[i]);
286 			clk_put(par->clks[i]);
287 		}
288 	}
289 
290 	kfree(par->clks);
291 }
292 #else
293 static int simplefb_clocks_get(struct simplefb_par *par,
294 	struct platform_device *pdev) { return 0; }
295 static void simplefb_clocks_enable(struct simplefb_par *par,
296 	struct platform_device *pdev) { }
297 static void simplefb_clocks_destroy(struct simplefb_par *par) { }
298 #endif
299 
300 #if defined CONFIG_OF && defined CONFIG_REGULATOR
301 
302 #define SUPPLY_SUFFIX "-supply"
303 
304 /*
305  * Regulator handling code.
306  *
307  * Here we handle the num-supplies and vin*-supply properties of our
308  * "simple-framebuffer" dt node. This is necessary so that we can make sure
309  * that any regulators needed by the display hardware that the bootloader
310  * set up for us (and for which it provided a simplefb dt node), stay up,
311  * for the life of the simplefb driver.
312  *
313  * When the driver unloads, we cleanly disable, and then release the
314  * regulators.
315  *
316  * We only complain about errors here, no action is taken as the most likely
317  * error can only happen due to a mismatch between the bootloader which set
318  * up simplefb, and the regulator definitions in the device tree. Chances are
319  * that there are no adverse effects, and if there are, a clean teardown of
320  * the fb probe will not help us much either. So just complain and carry on,
321  * and hope that the user actually gets a working fb at the end of things.
322  */
323 static int simplefb_regulators_get(struct simplefb_par *par,
324 				   struct platform_device *pdev)
325 {
326 	struct device_node *np = pdev->dev.of_node;
327 	struct property *prop;
328 	struct regulator *regulator;
329 	const char *p;
330 	int count = 0, i = 0;
331 
332 	if (dev_get_platdata(&pdev->dev) || !np)
333 		return 0;
334 
335 	/* Count the number of regulator supplies */
336 	for_each_property_of_node(np, prop) {
337 		p = strstr(prop->name, SUPPLY_SUFFIX);
338 		if (p && p != prop->name)
339 			count++;
340 	}
341 
342 	if (!count)
343 		return 0;
344 
345 	par->regulators = devm_kcalloc(&pdev->dev, count,
346 				       sizeof(struct regulator *), GFP_KERNEL);
347 	if (!par->regulators)
348 		return -ENOMEM;
349 
350 	/* Get all the regulators */
351 	for_each_property_of_node(np, prop) {
352 		char name[32]; /* 32 is max size of property name */
353 
354 		p = strstr(prop->name, SUPPLY_SUFFIX);
355 		if (!p || p == prop->name)
356 			continue;
357 
358 		strscpy(name, prop->name,
359 			strlen(prop->name) - strlen(SUPPLY_SUFFIX) + 1);
360 		regulator = devm_regulator_get_optional(&pdev->dev, name);
361 		if (IS_ERR(regulator)) {
362 			if (PTR_ERR(regulator) == -EPROBE_DEFER)
363 				return -EPROBE_DEFER;
364 			dev_err(&pdev->dev, "regulator %s not found: %ld\n",
365 				name, PTR_ERR(regulator));
366 			continue;
367 		}
368 		par->regulators[i++] = regulator;
369 	}
370 	par->regulator_count = i;
371 
372 	return 0;
373 }
374 
375 static void simplefb_regulators_enable(struct simplefb_par *par,
376 				       struct platform_device *pdev)
377 {
378 	int i, ret;
379 
380 	/* Enable all the regulators */
381 	for (i = 0; i < par->regulator_count; i++) {
382 		ret = regulator_enable(par->regulators[i]);
383 		if (ret) {
384 			dev_err(&pdev->dev,
385 				"failed to enable regulator %d: %d\n",
386 				i, ret);
387 			devm_regulator_put(par->regulators[i]);
388 			par->regulators[i] = NULL;
389 		}
390 	}
391 	par->regulators_enabled = true;
392 }
393 
394 static void simplefb_regulators_destroy(struct simplefb_par *par)
395 {
396 	int i;
397 
398 	if (!par->regulators || !par->regulators_enabled)
399 		return;
400 
401 	for (i = 0; i < par->regulator_count; i++)
402 		if (par->regulators[i])
403 			regulator_disable(par->regulators[i]);
404 }
405 #else
406 static int simplefb_regulators_get(struct simplefb_par *par,
407 	struct platform_device *pdev) { return 0; }
408 static void simplefb_regulators_enable(struct simplefb_par *par,
409 	struct platform_device *pdev) { }
410 static void simplefb_regulators_destroy(struct simplefb_par *par) { }
411 #endif
412 
413 static int simplefb_probe(struct platform_device *pdev)
414 {
415 	int ret;
416 	struct simplefb_params params;
417 	struct fb_info *info;
418 	struct simplefb_par *par;
419 	struct resource *res, *mem;
420 
421 	if (fb_get_options("simplefb", NULL))
422 		return -ENODEV;
423 
424 	ret = -ENODEV;
425 	if (dev_get_platdata(&pdev->dev))
426 		ret = simplefb_parse_pd(pdev, &params);
427 	else if (pdev->dev.of_node)
428 		ret = simplefb_parse_dt(pdev, &params);
429 
430 	if (ret)
431 		return ret;
432 
433 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
434 	if (!res) {
435 		dev_err(&pdev->dev, "No memory resource\n");
436 		return -EINVAL;
437 	}
438 
439 	mem = request_mem_region(res->start, resource_size(res), "simplefb");
440 	if (!mem) {
441 		/*
442 		 * We cannot make this fatal. Sometimes this comes from magic
443 		 * spaces our resource handlers simply don't know about. Use
444 		 * the I/O-memory resource as-is and try to map that instead.
445 		 */
446 		dev_warn(&pdev->dev, "simplefb: cannot reserve video memory at %pR\n", res);
447 		mem = res;
448 	}
449 
450 	info = framebuffer_alloc(sizeof(struct simplefb_par), &pdev->dev);
451 	if (!info) {
452 		ret = -ENOMEM;
453 		goto error_release_mem_region;
454 	}
455 	platform_set_drvdata(pdev, info);
456 
457 	par = info->par;
458 
459 	info->fix = simplefb_fix;
460 	info->fix.smem_start = mem->start;
461 	info->fix.smem_len = resource_size(mem);
462 	info->fix.line_length = params.stride;
463 
464 	info->var = simplefb_var;
465 	info->var.xres = params.width;
466 	info->var.yres = params.height;
467 	info->var.xres_virtual = params.width;
468 	info->var.yres_virtual = params.height;
469 	info->var.bits_per_pixel = params.format->bits_per_pixel;
470 	info->var.red = params.format->red;
471 	info->var.green = params.format->green;
472 	info->var.blue = params.format->blue;
473 	info->var.transp = params.format->transp;
474 
475 	info->apertures = alloc_apertures(1);
476 	if (!info->apertures) {
477 		ret = -ENOMEM;
478 		goto error_fb_release;
479 	}
480 	info->apertures->ranges[0].base = info->fix.smem_start;
481 	info->apertures->ranges[0].size = info->fix.smem_len;
482 
483 	info->fbops = &simplefb_ops;
484 	info->flags = FBINFO_DEFAULT | FBINFO_MISC_FIRMWARE;
485 	info->screen_base = ioremap_wc(info->fix.smem_start,
486 				       info->fix.smem_len);
487 	if (!info->screen_base) {
488 		ret = -ENOMEM;
489 		goto error_fb_release;
490 	}
491 	info->pseudo_palette = par->palette;
492 
493 	ret = simplefb_clocks_get(par, pdev);
494 	if (ret < 0)
495 		goto error_unmap;
496 
497 	ret = simplefb_regulators_get(par, pdev);
498 	if (ret < 0)
499 		goto error_clocks;
500 
501 	simplefb_clocks_enable(par, pdev);
502 	simplefb_regulators_enable(par, pdev);
503 
504 	dev_info(&pdev->dev, "framebuffer at 0x%lx, 0x%x bytes\n",
505 			     info->fix.smem_start, info->fix.smem_len);
506 	dev_info(&pdev->dev, "format=%s, mode=%dx%dx%d, linelength=%d\n",
507 			     params.format->name,
508 			     info->var.xres, info->var.yres,
509 			     info->var.bits_per_pixel, info->fix.line_length);
510 
511 	if (mem != res)
512 		par->mem = mem; /* release in clean-up handler */
513 
514 	ret = register_framebuffer(info);
515 	if (ret < 0) {
516 		dev_err(&pdev->dev, "Unable to register simplefb: %d\n", ret);
517 		goto error_regulators;
518 	}
519 
520 	dev_info(&pdev->dev, "fb%d: simplefb registered!\n", info->node);
521 
522 	return 0;
523 
524 error_regulators:
525 	simplefb_regulators_destroy(par);
526 error_clocks:
527 	simplefb_clocks_destroy(par);
528 error_unmap:
529 	iounmap(info->screen_base);
530 error_fb_release:
531 	framebuffer_release(info);
532 error_release_mem_region:
533 	if (mem != res)
534 		release_mem_region(mem->start, resource_size(mem));
535 	return ret;
536 }
537 
538 static int simplefb_remove(struct platform_device *pdev)
539 {
540 	struct fb_info *info = platform_get_drvdata(pdev);
541 
542 	/* simplefb_destroy takes care of info cleanup */
543 	unregister_framebuffer(info);
544 
545 	return 0;
546 }
547 
548 static const struct of_device_id simplefb_of_match[] = {
549 	{ .compatible = "simple-framebuffer", },
550 	{ },
551 };
552 MODULE_DEVICE_TABLE(of, simplefb_of_match);
553 
554 static struct platform_driver simplefb_driver = {
555 	.driver = {
556 		.name = "simple-framebuffer",
557 		.of_match_table = simplefb_of_match,
558 	},
559 	.probe = simplefb_probe,
560 	.remove = simplefb_remove,
561 };
562 
563 module_platform_driver(simplefb_driver);
564 
565 MODULE_AUTHOR("Stephen Warren <swarren@wwwdotorg.org>");
566 MODULE_DESCRIPTION("Simple framebuffer driver");
567 MODULE_LICENSE("GPL v2");
568