xref: /openbmc/linux/drivers/video/fbdev/simplefb.c (revision 9cfc5c90) 
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_platform.h>
32 
33 static struct fb_fix_screeninfo simplefb_fix = {
34 	.id		= "simple",
35 	.type		= FB_TYPE_PACKED_PIXELS,
36 	.visual		= FB_VISUAL_TRUECOLOR,
37 	.accel		= FB_ACCEL_NONE,
38 };
39 
40 static struct fb_var_screeninfo simplefb_var = {
41 	.height		= -1,
42 	.width		= -1,
43 	.activate	= FB_ACTIVATE_NOW,
44 	.vmode		= FB_VMODE_NONINTERLACED,
45 };
46 
47 #define PSEUDO_PALETTE_SIZE 16
48 
49 static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
50 			      u_int transp, struct fb_info *info)
51 {
52 	u32 *pal = info->pseudo_palette;
53 	u32 cr = red >> (16 - info->var.red.length);
54 	u32 cg = green >> (16 - info->var.green.length);
55 	u32 cb = blue >> (16 - info->var.blue.length);
56 	u32 value;
57 
58 	if (regno >= PSEUDO_PALETTE_SIZE)
59 		return -EINVAL;
60 
61 	value = (cr << info->var.red.offset) |
62 		(cg << info->var.green.offset) |
63 		(cb << info->var.blue.offset);
64 	if (info->var.transp.length > 0) {
65 		u32 mask = (1 << info->var.transp.length) - 1;
66 		mask <<= info->var.transp.offset;
67 		value |= mask;
68 	}
69 	pal[regno] = value;
70 
71 	return 0;
72 }
73 
74 static void simplefb_destroy(struct fb_info *info)
75 {
76 	if (info->screen_base)
77 		iounmap(info->screen_base);
78 }
79 
80 static struct fb_ops simplefb_ops = {
81 	.owner		= THIS_MODULE,
82 	.fb_destroy	= simplefb_destroy,
83 	.fb_setcolreg	= simplefb_setcolreg,
84 	.fb_fillrect	= cfb_fillrect,
85 	.fb_copyarea	= cfb_copyarea,
86 	.fb_imageblit	= cfb_imageblit,
87 };
88 
89 static struct simplefb_format simplefb_formats[] = SIMPLEFB_FORMATS;
90 
91 struct simplefb_params {
92 	u32 width;
93 	u32 height;
94 	u32 stride;
95 	struct simplefb_format *format;
96 };
97 
98 static int simplefb_parse_dt(struct platform_device *pdev,
99 			   struct simplefb_params *params)
100 {
101 	struct device_node *np = pdev->dev.of_node;
102 	int ret;
103 	const char *format;
104 	int i;
105 
106 	ret = of_property_read_u32(np, "width", &params->width);
107 	if (ret) {
108 		dev_err(&pdev->dev, "Can't parse width property\n");
109 		return ret;
110 	}
111 
112 	ret = of_property_read_u32(np, "height", &params->height);
113 	if (ret) {
114 		dev_err(&pdev->dev, "Can't parse height property\n");
115 		return ret;
116 	}
117 
118 	ret = of_property_read_u32(np, "stride", &params->stride);
119 	if (ret) {
120 		dev_err(&pdev->dev, "Can't parse stride property\n");
121 		return ret;
122 	}
123 
124 	ret = of_property_read_string(np, "format", &format);
125 	if (ret) {
126 		dev_err(&pdev->dev, "Can't parse format property\n");
127 		return ret;
128 	}
129 	params->format = NULL;
130 	for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
131 		if (strcmp(format, simplefb_formats[i].name))
132 			continue;
133 		params->format = &simplefb_formats[i];
134 		break;
135 	}
136 	if (!params->format) {
137 		dev_err(&pdev->dev, "Invalid format value\n");
138 		return -EINVAL;
139 	}
140 
141 	return 0;
142 }
143 
144 static int simplefb_parse_pd(struct platform_device *pdev,
145 			     struct simplefb_params *params)
146 {
147 	struct simplefb_platform_data *pd = dev_get_platdata(&pdev->dev);
148 	int i;
149 
150 	params->width = pd->width;
151 	params->height = pd->height;
152 	params->stride = pd->stride;
153 
154 	params->format = NULL;
155 	for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
156 		if (strcmp(pd->format, simplefb_formats[i].name))
157 			continue;
158 
159 		params->format = &simplefb_formats[i];
160 		break;
161 	}
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 struct simplefb_par {
172 	u32 palette[PSEUDO_PALETTE_SIZE];
173 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
174 	int clk_count;
175 	struct clk **clks;
176 #endif
177 };
178 
179 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
180 /*
181  * Clock handling code.
182  *
183  * Here we handle the clocks property of our "simple-framebuffer" dt node.
184  * This is necessary so that we can make sure that any clocks needed by
185  * the display engine that the bootloader set up for us (and for which it
186  * provided a simplefb dt node), stay up, for the life of the simplefb
187  * driver.
188  *
189  * When the driver unloads, we cleanly disable, and then release the clocks.
190  *
191  * We only complain about errors here, no action is taken as the most likely
192  * error can only happen due to a mismatch between the bootloader which set
193  * up simplefb, and the clock definitions in the device tree. Chances are
194  * that there are no adverse effects, and if there are, a clean teardown of
195  * the fb probe will not help us much either. So just complain and carry on,
196  * and hope that the user actually gets a working fb at the end of things.
197  */
198 static int simplefb_clocks_init(struct simplefb_par *par,
199 				struct platform_device *pdev)
200 {
201 	struct device_node *np = pdev->dev.of_node;
202 	struct clk *clock;
203 	int i, ret;
204 
205 	if (dev_get_platdata(&pdev->dev) || !np)
206 		return 0;
207 
208 	par->clk_count = of_clk_get_parent_count(np);
209 	if (par->clk_count <= 0)
210 		return 0;
211 
212 	par->clks = kcalloc(par->clk_count, sizeof(struct clk *), GFP_KERNEL);
213 	if (!par->clks)
214 		return -ENOMEM;
215 
216 	for (i = 0; i < par->clk_count; i++) {
217 		clock = of_clk_get(np, i);
218 		if (IS_ERR(clock)) {
219 			if (PTR_ERR(clock) == -EPROBE_DEFER) {
220 				while (--i >= 0) {
221 					if (par->clks[i])
222 						clk_put(par->clks[i]);
223 				}
224 				kfree(par->clks);
225 				return -EPROBE_DEFER;
226 			}
227 			dev_err(&pdev->dev, "%s: clock %d not found: %ld\n",
228 				__func__, i, PTR_ERR(clock));
229 			continue;
230 		}
231 		par->clks[i] = clock;
232 	}
233 
234 	for (i = 0; i < par->clk_count; i++) {
235 		if (par->clks[i]) {
236 			ret = clk_prepare_enable(par->clks[i]);
237 			if (ret) {
238 				dev_err(&pdev->dev,
239 					"%s: failed to enable clock %d: %d\n",
240 					__func__, i, ret);
241 				clk_put(par->clks[i]);
242 				par->clks[i] = NULL;
243 			}
244 		}
245 	}
246 
247 	return 0;
248 }
249 
250 static void simplefb_clocks_destroy(struct simplefb_par *par)
251 {
252 	int i;
253 
254 	if (!par->clks)
255 		return;
256 
257 	for (i = 0; i < par->clk_count; i++) {
258 		if (par->clks[i]) {
259 			clk_disable_unprepare(par->clks[i]);
260 			clk_put(par->clks[i]);
261 		}
262 	}
263 
264 	kfree(par->clks);
265 }
266 #else
267 static int simplefb_clocks_init(struct simplefb_par *par,
268 	struct platform_device *pdev) { return 0; }
269 static void simplefb_clocks_destroy(struct simplefb_par *par) { }
270 #endif
271 
272 static int simplefb_probe(struct platform_device *pdev)
273 {
274 	int ret;
275 	struct simplefb_params params;
276 	struct fb_info *info;
277 	struct simplefb_par *par;
278 	struct resource *mem;
279 
280 	if (fb_get_options("simplefb", NULL))
281 		return -ENODEV;
282 
283 	ret = -ENODEV;
284 	if (dev_get_platdata(&pdev->dev))
285 		ret = simplefb_parse_pd(pdev, &params);
286 	else if (pdev->dev.of_node)
287 		ret = simplefb_parse_dt(pdev, &params);
288 
289 	if (ret)
290 		return ret;
291 
292 	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
293 	if (!mem) {
294 		dev_err(&pdev->dev, "No memory resource\n");
295 		return -EINVAL;
296 	}
297 
298 	info = framebuffer_alloc(sizeof(struct simplefb_par), &pdev->dev);
299 	if (!info)
300 		return -ENOMEM;
301 	platform_set_drvdata(pdev, info);
302 
303 	par = info->par;
304 
305 	info->fix = simplefb_fix;
306 	info->fix.smem_start = mem->start;
307 	info->fix.smem_len = resource_size(mem);
308 	info->fix.line_length = params.stride;
309 
310 	info->var = simplefb_var;
311 	info->var.xres = params.width;
312 	info->var.yres = params.height;
313 	info->var.xres_virtual = params.width;
314 	info->var.yres_virtual = params.height;
315 	info->var.bits_per_pixel = params.format->bits_per_pixel;
316 	info->var.red = params.format->red;
317 	info->var.green = params.format->green;
318 	info->var.blue = params.format->blue;
319 	info->var.transp = params.format->transp;
320 
321 	info->apertures = alloc_apertures(1);
322 	if (!info->apertures) {
323 		ret = -ENOMEM;
324 		goto error_fb_release;
325 	}
326 	info->apertures->ranges[0].base = info->fix.smem_start;
327 	info->apertures->ranges[0].size = info->fix.smem_len;
328 
329 	info->fbops = &simplefb_ops;
330 	info->flags = FBINFO_DEFAULT | FBINFO_MISC_FIRMWARE;
331 	info->screen_base = ioremap_wc(info->fix.smem_start,
332 				       info->fix.smem_len);
333 	if (!info->screen_base) {
334 		ret = -ENOMEM;
335 		goto error_fb_release;
336 	}
337 	info->pseudo_palette = par->palette;
338 
339 	ret = simplefb_clocks_init(par, pdev);
340 	if (ret < 0)
341 		goto error_unmap;
342 
343 	dev_info(&pdev->dev, "framebuffer at 0x%lx, 0x%x bytes, mapped to 0x%p\n",
344 			     info->fix.smem_start, info->fix.smem_len,
345 			     info->screen_base);
346 	dev_info(&pdev->dev, "format=%s, mode=%dx%dx%d, linelength=%d\n",
347 			     params.format->name,
348 			     info->var.xres, info->var.yres,
349 			     info->var.bits_per_pixel, info->fix.line_length);
350 
351 	ret = register_framebuffer(info);
352 	if (ret < 0) {
353 		dev_err(&pdev->dev, "Unable to register simplefb: %d\n", ret);
354 		goto error_clocks;
355 	}
356 
357 	dev_info(&pdev->dev, "fb%d: simplefb registered!\n", info->node);
358 
359 	return 0;
360 
361 error_clocks:
362 	simplefb_clocks_destroy(par);
363 error_unmap:
364 	iounmap(info->screen_base);
365 error_fb_release:
366 	framebuffer_release(info);
367 	return ret;
368 }
369 
370 static int simplefb_remove(struct platform_device *pdev)
371 {
372 	struct fb_info *info = platform_get_drvdata(pdev);
373 	struct simplefb_par *par = info->par;
374 
375 	unregister_framebuffer(info);
376 	simplefb_clocks_destroy(par);
377 	framebuffer_release(info);
378 
379 	return 0;
380 }
381 
382 static const struct of_device_id simplefb_of_match[] = {
383 	{ .compatible = "simple-framebuffer", },
384 	{ },
385 };
386 MODULE_DEVICE_TABLE(of, simplefb_of_match);
387 
388 static struct platform_driver simplefb_driver = {
389 	.driver = {
390 		.name = "simple-framebuffer",
391 		.of_match_table = simplefb_of_match,
392 	},
393 	.probe = simplefb_probe,
394 	.remove = simplefb_remove,
395 };
396 
397 static int __init simplefb_init(void)
398 {
399 	int ret;
400 	struct device_node *np;
401 
402 	ret = platform_driver_register(&simplefb_driver);
403 	if (ret)
404 		return ret;
405 
406 	if (IS_ENABLED(CONFIG_OF_ADDRESS) && of_chosen) {
407 		for_each_child_of_node(of_chosen, np) {
408 			if (of_device_is_compatible(np, "simple-framebuffer"))
409 				of_platform_device_create(np, NULL, NULL);
410 		}
411 	}
412 
413 	return 0;
414 }
415 
416 fs_initcall(simplefb_init);
417 
418 MODULE_AUTHOR("Stephen Warren <swarren@wwwdotorg.org>");
419 MODULE_DESCRIPTION("Simple framebuffer driver");
420 MODULE_LICENSE("GPL v2");
421