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