1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/slab.h>
20#include <linux/fb.h>
21#include <linux/console.h>
22#include <linux/module.h>
23
24#define FB_SYSFS_FLAG_ATTR 1
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
40{
41#define BYTES_PER_LONG (BITS_PER_LONG/8)
42#define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
43 int fb_info_size = sizeof(struct fb_info);
44 struct fb_info *info;
45 char *p;
46
47 if (size)
48 fb_info_size += PADDING;
49
50 p = kzalloc(fb_info_size + size, GFP_KERNEL);
51
52 if (!p)
53 return NULL;
54
55 info = (struct fb_info *) p;
56
57 if (size)
58 info->par = p + fb_info_size;
59
60 info->device = dev;
61 info->fbcon_rotate_hint = -1;
62
63#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
64 mutex_init(&info->bl_curve_mutex);
65#endif
66
67 return info;
68#undef PADDING
69#undef BYTES_PER_LONG
70}
71EXPORT_SYMBOL(framebuffer_alloc);
72
73
74
75
76
77
78
79
80
81
82void framebuffer_release(struct fb_info *info)
83{
84 if (!info)
85 return;
86 kfree(info->apertures);
87 kfree(info);
88}
89EXPORT_SYMBOL(framebuffer_release);
90
91static int activate(struct fb_info *fb_info, struct fb_var_screeninfo *var)
92{
93 int err;
94
95 var->activate |= FB_ACTIVATE_FORCE;
96 console_lock();
97 fb_info->flags |= FBINFO_MISC_USEREVENT;
98 err = fb_set_var(fb_info, var);
99 fb_info->flags &= ~FBINFO_MISC_USEREVENT;
100 console_unlock();
101 if (err)
102 return err;
103 return 0;
104}
105
106static int mode_string(char *buf, unsigned int offset,
107 const struct fb_videomode *mode)
108{
109 char m = 'U';
110 char v = 'p';
111
112 if (mode->flag & FB_MODE_IS_DETAILED)
113 m = 'D';
114 if (mode->flag & FB_MODE_IS_VESA)
115 m = 'V';
116 if (mode->flag & FB_MODE_IS_STANDARD)
117 m = 'S';
118
119 if (mode->vmode & FB_VMODE_INTERLACED)
120 v = 'i';
121 if (mode->vmode & FB_VMODE_DOUBLE)
122 v = 'd';
123
124 return snprintf(&buf[offset], PAGE_SIZE - offset, "%c:%dx%d%c-%d\n",
125 m, mode->xres, mode->yres, v, mode->refresh);
126}
127
128static ssize_t store_mode(struct device *device, struct device_attribute *attr,
129 const char *buf, size_t count)
130{
131 struct fb_info *fb_info = dev_get_drvdata(device);
132 char mstr[100];
133 struct fb_var_screeninfo var;
134 struct fb_modelist *modelist;
135 struct fb_videomode *mode;
136 struct list_head *pos;
137 size_t i;
138 int err;
139
140 memset(&var, 0, sizeof(var));
141
142 list_for_each(pos, &fb_info->modelist) {
143 modelist = list_entry(pos, struct fb_modelist, list);
144 mode = &modelist->mode;
145 i = mode_string(mstr, 0, mode);
146 if (strncmp(mstr, buf, max(count, i)) == 0) {
147
148 var = fb_info->var;
149 fb_videomode_to_var(&var, mode);
150 if ((err = activate(fb_info, &var)))
151 return err;
152 fb_info->mode = mode;
153 return count;
154 }
155 }
156 return -EINVAL;
157}
158
159static ssize_t show_mode(struct device *device, struct device_attribute *attr,
160 char *buf)
161{
162 struct fb_info *fb_info = dev_get_drvdata(device);
163
164 if (!fb_info->mode)
165 return 0;
166
167 return mode_string(buf, 0, fb_info->mode);
168}
169
170static ssize_t store_modes(struct device *device,
171 struct device_attribute *attr,
172 const char *buf, size_t count)
173{
174 struct fb_info *fb_info = dev_get_drvdata(device);
175 LIST_HEAD(old_list);
176 int i = count / sizeof(struct fb_videomode);
177
178 if (i * sizeof(struct fb_videomode) != count)
179 return -EINVAL;
180
181 console_lock();
182 if (!lock_fb_info(fb_info)) {
183 console_unlock();
184 return -ENODEV;
185 }
186
187 list_splice(&fb_info->modelist, &old_list);
188 fb_videomode_to_modelist((const struct fb_videomode *)buf, i,
189 &fb_info->modelist);
190 if (fb_new_modelist(fb_info)) {
191 fb_destroy_modelist(&fb_info->modelist);
192 list_splice(&old_list, &fb_info->modelist);
193 } else
194 fb_destroy_modelist(&old_list);
195
196 unlock_fb_info(fb_info);
197 console_unlock();
198
199 return 0;
200}
201
202static ssize_t show_modes(struct device *device, struct device_attribute *attr,
203 char *buf)
204{
205 struct fb_info *fb_info = dev_get_drvdata(device);
206 unsigned int i;
207 struct list_head *pos;
208 struct fb_modelist *modelist;
209 const struct fb_videomode *mode;
210
211 i = 0;
212 list_for_each(pos, &fb_info->modelist) {
213 modelist = list_entry(pos, struct fb_modelist, list);
214 mode = &modelist->mode;
215 i += mode_string(buf, i, mode);
216 }
217 return i;
218}
219
220static ssize_t store_bpp(struct device *device, struct device_attribute *attr,
221 const char *buf, size_t count)
222{
223 struct fb_info *fb_info = dev_get_drvdata(device);
224 struct fb_var_screeninfo var;
225 char ** last = NULL;
226 int err;
227
228 var = fb_info->var;
229 var.bits_per_pixel = simple_strtoul(buf, last, 0);
230 if ((err = activate(fb_info, &var)))
231 return err;
232 return count;
233}
234
235static ssize_t show_bpp(struct device *device, struct device_attribute *attr,
236 char *buf)
237{
238 struct fb_info *fb_info = dev_get_drvdata(device);
239 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.bits_per_pixel);
240}
241
242static ssize_t store_rotate(struct device *device,
243 struct device_attribute *attr,
244 const char *buf, size_t count)
245{
246 struct fb_info *fb_info = dev_get_drvdata(device);
247 struct fb_var_screeninfo var;
248 char **last = NULL;
249 int err;
250
251 var = fb_info->var;
252 var.rotate = simple_strtoul(buf, last, 0);
253
254 if ((err = activate(fb_info, &var)))
255 return err;
256
257 return count;
258}
259
260
261static ssize_t show_rotate(struct device *device,
262 struct device_attribute *attr, char *buf)
263{
264 struct fb_info *fb_info = dev_get_drvdata(device);
265
266 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.rotate);
267}
268
269static ssize_t store_virtual(struct device *device,
270 struct device_attribute *attr,
271 const char *buf, size_t count)
272{
273 struct fb_info *fb_info = dev_get_drvdata(device);
274 struct fb_var_screeninfo var;
275 char *last = NULL;
276 int err;
277
278 var = fb_info->var;
279 var.xres_virtual = simple_strtoul(buf, &last, 0);
280 last++;
281 if (last - buf >= count)
282 return -EINVAL;
283 var.yres_virtual = simple_strtoul(last, &last, 0);
284
285 if ((err = activate(fb_info, &var)))
286 return err;
287 return count;
288}
289
290static ssize_t show_virtual(struct device *device,
291 struct device_attribute *attr, char *buf)
292{
293 struct fb_info *fb_info = dev_get_drvdata(device);
294 return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xres_virtual,
295 fb_info->var.yres_virtual);
296}
297
298static ssize_t show_stride(struct device *device,
299 struct device_attribute *attr, char *buf)
300{
301 struct fb_info *fb_info = dev_get_drvdata(device);
302 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->fix.line_length);
303}
304
305static ssize_t store_blank(struct device *device,
306 struct device_attribute *attr,
307 const char *buf, size_t count)
308{
309 struct fb_info *fb_info = dev_get_drvdata(device);
310 char *last = NULL;
311 int err;
312
313 console_lock();
314 fb_info->flags |= FBINFO_MISC_USEREVENT;
315 err = fb_blank(fb_info, simple_strtoul(buf, &last, 0));
316 fb_info->flags &= ~FBINFO_MISC_USEREVENT;
317 console_unlock();
318 if (err < 0)
319 return err;
320 return count;
321}
322
323static ssize_t show_blank(struct device *device,
324 struct device_attribute *attr, char *buf)
325{
326
327 return 0;
328}
329
330static ssize_t store_console(struct device *device,
331 struct device_attribute *attr,
332 const char *buf, size_t count)
333{
334
335 return 0;
336}
337
338static ssize_t show_console(struct device *device,
339 struct device_attribute *attr, char *buf)
340{
341
342 return 0;
343}
344
345static ssize_t store_cursor(struct device *device,
346 struct device_attribute *attr,
347 const char *buf, size_t count)
348{
349
350 return 0;
351}
352
353static ssize_t show_cursor(struct device *device,
354 struct device_attribute *attr, char *buf)
355{
356
357 return 0;
358}
359
360static ssize_t store_pan(struct device *device,
361 struct device_attribute *attr,
362 const char *buf, size_t count)
363{
364 struct fb_info *fb_info = dev_get_drvdata(device);
365 struct fb_var_screeninfo var;
366 char *last = NULL;
367 int err;
368
369 var = fb_info->var;
370 var.xoffset = simple_strtoul(buf, &last, 0);
371 last++;
372 if (last - buf >= count)
373 return -EINVAL;
374 var.yoffset = simple_strtoul(last, &last, 0);
375
376 console_lock();
377 err = fb_pan_display(fb_info, &var);
378 console_unlock();
379
380 if (err < 0)
381 return err;
382 return count;
383}
384
385static ssize_t show_pan(struct device *device,
386 struct device_attribute *attr, char *buf)
387{
388 struct fb_info *fb_info = dev_get_drvdata(device);
389 return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
390 fb_info->var.yoffset);
391}
392
393static ssize_t show_name(struct device *device,
394 struct device_attribute *attr, char *buf)
395{
396 struct fb_info *fb_info = dev_get_drvdata(device);
397
398 return snprintf(buf, PAGE_SIZE, "%s\n", fb_info->fix.id);
399}
400
401static ssize_t store_fbstate(struct device *device,
402 struct device_attribute *attr,
403 const char *buf, size_t count)
404{
405 struct fb_info *fb_info = dev_get_drvdata(device);
406 u32 state;
407 char *last = NULL;
408
409 state = simple_strtoul(buf, &last, 0);
410
411 console_lock();
412 if (!lock_fb_info(fb_info)) {
413 console_unlock();
414 return -ENODEV;
415 }
416
417 fb_set_suspend(fb_info, (int)state);
418
419 unlock_fb_info(fb_info);
420 console_unlock();
421
422 return count;
423}
424
425static ssize_t show_fbstate(struct device *device,
426 struct device_attribute *attr, char *buf)
427{
428 struct fb_info *fb_info = dev_get_drvdata(device);
429 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
430}
431
432#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
433static ssize_t store_bl_curve(struct device *device,
434 struct device_attribute *attr,
435 const char *buf, size_t count)
436{
437 struct fb_info *fb_info = dev_get_drvdata(device);
438 u8 tmp_curve[FB_BACKLIGHT_LEVELS];
439 unsigned int i;
440
441
442
443
444 if (!fb_info || !fb_info->bl_dev)
445 return -ENODEV;
446
447 if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
448 return -EINVAL;
449
450 for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
451 if (sscanf(&buf[i * 24],
452 "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
453 &tmp_curve[i * 8 + 0],
454 &tmp_curve[i * 8 + 1],
455 &tmp_curve[i * 8 + 2],
456 &tmp_curve[i * 8 + 3],
457 &tmp_curve[i * 8 + 4],
458 &tmp_curve[i * 8 + 5],
459 &tmp_curve[i * 8 + 6],
460 &tmp_curve[i * 8 + 7]) != 8)
461 return -EINVAL;
462
463
464
465
466 mutex_lock(&fb_info->bl_curve_mutex);
467 for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
468 fb_info->bl_curve[i] = tmp_curve[i];
469 mutex_unlock(&fb_info->bl_curve_mutex);
470
471 return count;
472}
473
474static ssize_t show_bl_curve(struct device *device,
475 struct device_attribute *attr, char *buf)
476{
477 struct fb_info *fb_info = dev_get_drvdata(device);
478 ssize_t len = 0;
479 unsigned int i;
480
481
482
483
484 if (!fb_info || !fb_info->bl_dev)
485 return -ENODEV;
486
487 mutex_lock(&fb_info->bl_curve_mutex);
488 for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
489 len += scnprintf(&buf[len], PAGE_SIZE - len, "%8ph\n",
490 fb_info->bl_curve + i);
491 mutex_unlock(&fb_info->bl_curve_mutex);
492
493 return len;
494}
495#endif
496
497
498
499
500static struct device_attribute device_attrs[] = {
501 __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
502 __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
503 __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
504 __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
505 __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
506 __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
507 __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
508 __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
509 __ATTR(name, S_IRUGO, show_name, NULL),
510 __ATTR(stride, S_IRUGO, show_stride, NULL),
511 __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
512 __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
513#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
514 __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
515#endif
516};
517
518int fb_init_device(struct fb_info *fb_info)
519{
520 int i, error = 0;
521
522 dev_set_drvdata(fb_info->dev, fb_info);
523
524 fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;
525
526 for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
527 error = device_create_file(fb_info->dev, &device_attrs[i]);
528
529 if (error)
530 break;
531 }
532
533 if (error) {
534 while (--i >= 0)
535 device_remove_file(fb_info->dev, &device_attrs[i]);
536 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
537 }
538
539 return 0;
540}
541
542void fb_cleanup_device(struct fb_info *fb_info)
543{
544 unsigned int i;
545
546 if (fb_info->class_flag & FB_SYSFS_FLAG_ATTR) {
547 for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
548 device_remove_file(fb_info->dev, &device_attrs[i]);
549
550 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
551 }
552}
553
554#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
555
556
557
558
559
560
561void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max)
562{
563 unsigned int i, flat, count, range = (max - min);
564
565 mutex_lock(&fb_info->bl_curve_mutex);
566
567 fb_info->bl_curve[0] = off;
568
569 for (flat = 1; flat < (FB_BACKLIGHT_LEVELS / 16); ++flat)
570 fb_info->bl_curve[flat] = min;
571
572 count = FB_BACKLIGHT_LEVELS * 15 / 16;
573 for (i = 0; i < count; ++i)
574 fb_info->bl_curve[flat + i] = min + (range * (i + 1) / count);
575
576 mutex_unlock(&fb_info->bl_curve_mutex);
577}
578EXPORT_SYMBOL_GPL(fb_bl_default_curve);
579#endif
580