1 /*
2 * linux/drivers/video/fbmem.c
3 *
4 * Copyright (C) 1994 Martin Schaller
5 *
6 * 2001 - Documented with DocBook
7 * - Brad Douglas <brad@neruo.com>
8 *
9 * This file is subject to the terms and conditions of the GNU General Public
10 * License. See the file COPYING in the main directory of this archive
11 * for more details.
12 */
13
14 #include <linux/console.h>
15 #include <linux/export.h>
16 #include <linux/fb.h>
17 #include <linux/fbcon.h>
18
19 #include <video/nomodeset.h>
20
21 #include "fb_internal.h"
22
23 /*
24 * Frame buffer device initialization and setup routines
25 */
26
27 #define FBPIXMAPSIZE (1024 * 8)
28
29 struct class *fb_class;
30
31 DEFINE_MUTEX(registration_lock);
32 struct fb_info *registered_fb[FB_MAX] __read_mostly;
33 int num_registered_fb __read_mostly;
34 #define for_each_registered_fb(i) \
35 for (i = 0; i < FB_MAX; i++) \
36 if (!registered_fb[i]) {} else
37
get_fb_info(unsigned int idx)38 struct fb_info *get_fb_info(unsigned int idx)
39 {
40 struct fb_info *fb_info;
41
42 if (idx >= FB_MAX)
43 return ERR_PTR(-ENODEV);
44
45 mutex_lock(®istration_lock);
46 fb_info = registered_fb[idx];
47 if (fb_info)
48 refcount_inc(&fb_info->count);
49 mutex_unlock(®istration_lock);
50
51 return fb_info;
52 }
53
put_fb_info(struct fb_info * fb_info)54 void put_fb_info(struct fb_info *fb_info)
55 {
56 if (!refcount_dec_and_test(&fb_info->count))
57 return;
58 if (fb_info->fbops->fb_destroy)
59 fb_info->fbops->fb_destroy(fb_info);
60 }
61
62 /*
63 * Helpers
64 */
65
fb_get_color_depth(struct fb_var_screeninfo * var,struct fb_fix_screeninfo * fix)66 int fb_get_color_depth(struct fb_var_screeninfo *var,
67 struct fb_fix_screeninfo *fix)
68 {
69 int depth = 0;
70
71 if (fix->visual == FB_VISUAL_MONO01 ||
72 fix->visual == FB_VISUAL_MONO10)
73 depth = 1;
74 else {
75 if (var->green.length == var->blue.length &&
76 var->green.length == var->red.length &&
77 var->green.offset == var->blue.offset &&
78 var->green.offset == var->red.offset)
79 depth = var->green.length;
80 else
81 depth = var->green.length + var->red.length +
82 var->blue.length;
83 }
84
85 return depth;
86 }
87 EXPORT_SYMBOL(fb_get_color_depth);
88
89 /*
90 * Data padding functions.
91 */
fb_pad_aligned_buffer(u8 * dst,u32 d_pitch,u8 * src,u32 s_pitch,u32 height)92 void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height)
93 {
94 __fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, height);
95 }
96 EXPORT_SYMBOL(fb_pad_aligned_buffer);
97
fb_pad_unaligned_buffer(u8 * dst,u32 d_pitch,u8 * src,u32 idx,u32 height,u32 shift_high,u32 shift_low,u32 mod)98 void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx, u32 height,
99 u32 shift_high, u32 shift_low, u32 mod)
100 {
101 u8 mask = (u8) (0xfff << shift_high), tmp;
102 int i, j;
103
104 for (i = height; i--; ) {
105 for (j = 0; j < idx; j++) {
106 tmp = dst[j];
107 tmp &= mask;
108 tmp |= *src >> shift_low;
109 dst[j] = tmp;
110 tmp = *src << shift_high;
111 dst[j+1] = tmp;
112 src++;
113 }
114 tmp = dst[idx];
115 tmp &= mask;
116 tmp |= *src >> shift_low;
117 dst[idx] = tmp;
118 if (shift_high < mod) {
119 tmp = *src << shift_high;
120 dst[idx+1] = tmp;
121 }
122 src++;
123 dst += d_pitch;
124 }
125 }
126 EXPORT_SYMBOL(fb_pad_unaligned_buffer);
127
128 /*
129 * we need to lock this section since fb_cursor
130 * may use fb_imageblit()
131 */
fb_get_buffer_offset(struct fb_info * info,struct fb_pixmap * buf,u32 size)132 char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size)
133 {
134 u32 align = buf->buf_align - 1, offset;
135 char *addr = buf->addr;
136
137 /* If IO mapped, we need to sync before access, no sharing of
138 * the pixmap is done
139 */
140 if (buf->flags & FB_PIXMAP_IO) {
141 if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
142 info->fbops->fb_sync(info);
143 return addr;
144 }
145
146 /* See if we fit in the remaining pixmap space */
147 offset = buf->offset + align;
148 offset &= ~align;
149 if (offset + size > buf->size) {
150 /* We do not fit. In order to be able to re-use the buffer,
151 * we must ensure no asynchronous DMA'ing or whatever operation
152 * is in progress, we sync for that.
153 */
154 if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
155 info->fbops->fb_sync(info);
156 offset = 0;
157 }
158 buf->offset = offset + size;
159 addr += offset;
160
161 return addr;
162 }
163 EXPORT_SYMBOL(fb_get_buffer_offset);
164
165 int
fb_pan_display(struct fb_info * info,struct fb_var_screeninfo * var)166 fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
167 {
168 struct fb_fix_screeninfo *fix = &info->fix;
169 unsigned int yres = info->var.yres;
170 int err = 0;
171
172 if (var->yoffset > 0) {
173 if (var->vmode & FB_VMODE_YWRAP) {
174 if (!fix->ywrapstep || (var->yoffset % fix->ywrapstep))
175 err = -EINVAL;
176 else
177 yres = 0;
178 } else if (!fix->ypanstep || (var->yoffset % fix->ypanstep))
179 err = -EINVAL;
180 }
181
182 if (var->xoffset > 0 && (!fix->xpanstep ||
183 (var->xoffset % fix->xpanstep)))
184 err = -EINVAL;
185
186 if (err || !info->fbops->fb_pan_display ||
187 var->yoffset > info->var.yres_virtual - yres ||
188 var->xoffset > info->var.xres_virtual - info->var.xres)
189 return -EINVAL;
190
191 if ((err = info->fbops->fb_pan_display(var, info)))
192 return err;
193 info->var.xoffset = var->xoffset;
194 info->var.yoffset = var->yoffset;
195 if (var->vmode & FB_VMODE_YWRAP)
196 info->var.vmode |= FB_VMODE_YWRAP;
197 else
198 info->var.vmode &= ~FB_VMODE_YWRAP;
199 return 0;
200 }
201 EXPORT_SYMBOL(fb_pan_display);
202
fb_check_caps(struct fb_info * info,struct fb_var_screeninfo * var,u32 activate)203 static int fb_check_caps(struct fb_info *info, struct fb_var_screeninfo *var,
204 u32 activate)
205 {
206 struct fb_blit_caps caps, fbcaps;
207 int err = 0;
208
209 memset(&caps, 0, sizeof(caps));
210 memset(&fbcaps, 0, sizeof(fbcaps));
211 caps.flags = (activate & FB_ACTIVATE_ALL) ? 1 : 0;
212 fbcon_get_requirement(info, &caps);
213 info->fbops->fb_get_caps(info, &fbcaps, var);
214
215 if (!bitmap_subset(caps.x, fbcaps.x, FB_MAX_BLIT_WIDTH) ||
216 !bitmap_subset(caps.y, fbcaps.y, FB_MAX_BLIT_HEIGHT) ||
217 (fbcaps.len < caps.len))
218 err = -EINVAL;
219
220 return err;
221 }
222
223 int
fb_set_var(struct fb_info * info,struct fb_var_screeninfo * var)224 fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
225 {
226 int ret = 0;
227 u32 activate;
228 struct fb_var_screeninfo old_var;
229 struct fb_videomode mode;
230 struct fb_event event;
231 u32 unused;
232
233 if (var->activate & FB_ACTIVATE_INV_MODE) {
234 struct fb_videomode mode1, mode2;
235
236 fb_var_to_videomode(&mode1, var);
237 fb_var_to_videomode(&mode2, &info->var);
238 /* make sure we don't delete the videomode of current var */
239 ret = fb_mode_is_equal(&mode1, &mode2);
240 if (!ret) {
241 ret = fbcon_mode_deleted(info, &mode1);
242 if (!ret)
243 fb_delete_videomode(&mode1, &info->modelist);
244 }
245
246 return ret ? -EINVAL : 0;
247 }
248
249 if (!(var->activate & FB_ACTIVATE_FORCE) &&
250 !memcmp(&info->var, var, sizeof(struct fb_var_screeninfo)))
251 return 0;
252
253 activate = var->activate;
254
255 /* When using FOURCC mode, make sure the red, green, blue and
256 * transp fields are set to 0.
257 */
258 if ((info->fix.capabilities & FB_CAP_FOURCC) &&
259 var->grayscale > 1) {
260 if (var->red.offset || var->green.offset ||
261 var->blue.offset || var->transp.offset ||
262 var->red.length || var->green.length ||
263 var->blue.length || var->transp.length ||
264 var->red.msb_right || var->green.msb_right ||
265 var->blue.msb_right || var->transp.msb_right)
266 return -EINVAL;
267 }
268
269 if (!info->fbops->fb_check_var) {
270 *var = info->var;
271 return 0;
272 }
273
274 /* bitfill_aligned() assumes that it's at least 8x8 */
275 if (var->xres < 8 || var->yres < 8)
276 return -EINVAL;
277
278 /* Too huge resolution causes multiplication overflow. */
279 if (check_mul_overflow(var->xres, var->yres, &unused) ||
280 check_mul_overflow(var->xres_virtual, var->yres_virtual, &unused))
281 return -EINVAL;
282
283 ret = info->fbops->fb_check_var(var, info);
284
285 if (ret)
286 return ret;
287
288 /* verify that virtual resolution >= physical resolution */
289 if (var->xres_virtual < var->xres ||
290 var->yres_virtual < var->yres) {
291 pr_warn("WARNING: fbcon: Driver '%s' missed to adjust virtual screen size (%ux%u vs. %ux%u)\n",
292 info->fix.id,
293 var->xres_virtual, var->yres_virtual,
294 var->xres, var->yres);
295 return -EINVAL;
296 }
297
298 if ((var->activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW)
299 return 0;
300
301 if (info->fbops->fb_get_caps) {
302 ret = fb_check_caps(info, var, activate);
303
304 if (ret)
305 return ret;
306 }
307
308 old_var = info->var;
309 info->var = *var;
310
311 if (info->fbops->fb_set_par) {
312 ret = info->fbops->fb_set_par(info);
313
314 if (ret) {
315 info->var = old_var;
316 printk(KERN_WARNING "detected "
317 "fb_set_par error, "
318 "error code: %d\n", ret);
319 return ret;
320 }
321 }
322
323 fb_pan_display(info, &info->var);
324 fb_set_cmap(&info->cmap, info);
325 fb_var_to_videomode(&mode, &info->var);
326
327 if (info->modelist.prev && info->modelist.next &&
328 !list_empty(&info->modelist))
329 ret = fb_add_videomode(&mode, &info->modelist);
330
331 if (ret) {
332 info->var = old_var;
333 return ret;
334 }
335
336 event.info = info;
337 event.data = &mode;
338 fb_notifier_call_chain(FB_EVENT_MODE_CHANGE, &event);
339
340 return 0;
341 }
342 EXPORT_SYMBOL(fb_set_var);
343
344 int
fb_blank(struct fb_info * info,int blank)345 fb_blank(struct fb_info *info, int blank)
346 {
347 struct fb_event event;
348 int ret = -EINVAL;
349
350 if (blank > FB_BLANK_POWERDOWN)
351 blank = FB_BLANK_POWERDOWN;
352
353 event.info = info;
354 event.data = ␣
355
356 if (info->fbops->fb_blank)
357 ret = info->fbops->fb_blank(blank, info);
358
359 if (!ret)
360 fb_notifier_call_chain(FB_EVENT_BLANK, &event);
361
362 return ret;
363 }
364 EXPORT_SYMBOL(fb_blank);
365
fb_check_foreignness(struct fb_info * fi)366 static int fb_check_foreignness(struct fb_info *fi)
367 {
368 const bool foreign_endian = fi->flags & FBINFO_FOREIGN_ENDIAN;
369
370 fi->flags &= ~FBINFO_FOREIGN_ENDIAN;
371
372 #ifdef __BIG_ENDIAN
373 fi->flags |= foreign_endian ? 0 : FBINFO_BE_MATH;
374 #else
375 fi->flags |= foreign_endian ? FBINFO_BE_MATH : 0;
376 #endif /* __BIG_ENDIAN */
377
378 if (fi->flags & FBINFO_BE_MATH && !fb_be_math(fi)) {
379 pr_err("%s: enable CONFIG_FB_BIG_ENDIAN to "
380 "support this framebuffer\n", fi->fix.id);
381 return -ENOSYS;
382 } else if (!(fi->flags & FBINFO_BE_MATH) && fb_be_math(fi)) {
383 pr_err("%s: enable CONFIG_FB_LITTLE_ENDIAN to "
384 "support this framebuffer\n", fi->fix.id);
385 return -ENOSYS;
386 }
387
388 return 0;
389 }
390
do_register_framebuffer(struct fb_info * fb_info)391 static int do_register_framebuffer(struct fb_info *fb_info)
392 {
393 int i, err = 0;
394 struct fb_videomode mode;
395
396 if (fb_check_foreignness(fb_info))
397 return -ENOSYS;
398
399 if (num_registered_fb == FB_MAX)
400 return -ENXIO;
401
402 for (i = 0 ; i < FB_MAX; i++)
403 if (!registered_fb[i])
404 break;
405
406 if (i >= FB_MAX)
407 return -ENXIO;
408
409 if (!fb_info->modelist.prev || !fb_info->modelist.next)
410 INIT_LIST_HEAD(&fb_info->modelist);
411
412 fb_var_to_videomode(&mode, &fb_info->var);
413 err = fb_add_videomode(&mode, &fb_info->modelist);
414 if (err < 0)
415 return err;
416
417 fb_info->node = i;
418 refcount_set(&fb_info->count, 1);
419 mutex_init(&fb_info->lock);
420 mutex_init(&fb_info->mm_lock);
421
422 fb_device_create(fb_info);
423
424 if (fb_info->pixmap.addr == NULL) {
425 fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);
426 if (fb_info->pixmap.addr) {
427 fb_info->pixmap.size = FBPIXMAPSIZE;
428 fb_info->pixmap.buf_align = 1;
429 fb_info->pixmap.scan_align = 1;
430 fb_info->pixmap.access_align = 32;
431 fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
432 }
433 }
434 fb_info->pixmap.offset = 0;
435
436 if (bitmap_empty(fb_info->pixmap.blit_x, FB_MAX_BLIT_WIDTH))
437 bitmap_fill(fb_info->pixmap.blit_x, FB_MAX_BLIT_WIDTH);
438
439 if (bitmap_empty(fb_info->pixmap.blit_y, FB_MAX_BLIT_HEIGHT))
440 bitmap_fill(fb_info->pixmap.blit_y, FB_MAX_BLIT_HEIGHT);
441
442 if (fb_info->skip_vt_switch)
443 pm_vt_switch_required(fb_info->device, false);
444 else
445 pm_vt_switch_required(fb_info->device, true);
446
447 num_registered_fb++;
448 registered_fb[i] = fb_info;
449
450 #ifdef CONFIG_GUMSTIX_AM200EPD
451 {
452 struct fb_event event;
453 event.info = fb_info;
454 fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);
455 }
456 #endif
457
458 return fbcon_fb_registered(fb_info);
459 }
460
unbind_console(struct fb_info * fb_info)461 static void unbind_console(struct fb_info *fb_info)
462 {
463 int i = fb_info->node;
464
465 if (WARN_ON(i < 0 || i >= FB_MAX || registered_fb[i] != fb_info))
466 return;
467
468 fbcon_fb_unbind(fb_info);
469 }
470
unlink_framebuffer(struct fb_info * fb_info)471 static void unlink_framebuffer(struct fb_info *fb_info)
472 {
473 int i;
474
475 i = fb_info->node;
476 if (WARN_ON(i < 0 || i >= FB_MAX || registered_fb[i] != fb_info))
477 return;
478
479 fb_device_destroy(fb_info);
480 pm_vt_switch_unregister(fb_info->device);
481 unbind_console(fb_info);
482 }
483
do_unregister_framebuffer(struct fb_info * fb_info)484 static void do_unregister_framebuffer(struct fb_info *fb_info)
485 {
486 unlink_framebuffer(fb_info);
487 if (fb_info->pixmap.addr &&
488 (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT)) {
489 kfree(fb_info->pixmap.addr);
490 fb_info->pixmap.addr = NULL;
491 }
492
493 fb_destroy_modelist(&fb_info->modelist);
494 registered_fb[fb_info->node] = NULL;
495 num_registered_fb--;
496 #ifdef CONFIG_GUMSTIX_AM200EPD
497 {
498 struct fb_event event;
499 event.info = fb_info;
500 fb_notifier_call_chain(FB_EVENT_FB_UNREGISTERED, &event);
501 }
502 #endif
503 fbcon_fb_unregistered(fb_info);
504
505 /* this may free fb info */
506 put_fb_info(fb_info);
507 }
508
509 /**
510 * register_framebuffer - registers a frame buffer device
511 * @fb_info: frame buffer info structure
512 *
513 * Registers a frame buffer device @fb_info.
514 *
515 * Returns negative errno on error, or zero for success.
516 *
517 */
518 int
register_framebuffer(struct fb_info * fb_info)519 register_framebuffer(struct fb_info *fb_info)
520 {
521 int ret;
522
523 mutex_lock(®istration_lock);
524 ret = do_register_framebuffer(fb_info);
525 mutex_unlock(®istration_lock);
526
527 return ret;
528 }
529 EXPORT_SYMBOL(register_framebuffer);
530
531 /**
532 * unregister_framebuffer - releases a frame buffer device
533 * @fb_info: frame buffer info structure
534 *
535 * Unregisters a frame buffer device @fb_info.
536 *
537 * Returns negative errno on error, or zero for success.
538 *
539 * This function will also notify the framebuffer console
540 * to release the driver.
541 *
542 * This is meant to be called within a driver's module_exit()
543 * function. If this is called outside module_exit(), ensure
544 * that the driver implements fb_open() and fb_release() to
545 * check that no processes are using the device.
546 */
547 void
unregister_framebuffer(struct fb_info * fb_info)548 unregister_framebuffer(struct fb_info *fb_info)
549 {
550 mutex_lock(®istration_lock);
551 do_unregister_framebuffer(fb_info);
552 mutex_unlock(®istration_lock);
553 }
554 EXPORT_SYMBOL(unregister_framebuffer);
555
devm_unregister_framebuffer(void * data)556 static void devm_unregister_framebuffer(void *data)
557 {
558 struct fb_info *info = data;
559
560 unregister_framebuffer(info);
561 }
562
563 /**
564 * devm_register_framebuffer - resource-managed frame buffer device registration
565 * @dev: device the framebuffer belongs to
566 * @fb_info: frame buffer info structure
567 *
568 * Registers a frame buffer device @fb_info to device @dev.
569 *
570 * Returns negative errno on error, or zero for success.
571 *
572 */
573 int
devm_register_framebuffer(struct device * dev,struct fb_info * fb_info)574 devm_register_framebuffer(struct device *dev, struct fb_info *fb_info)
575 {
576 int ret;
577
578 ret = register_framebuffer(fb_info);
579 if (ret)
580 return ret;
581
582 return devm_add_action_or_reset(dev, devm_unregister_framebuffer, fb_info);
583 }
584 EXPORT_SYMBOL(devm_register_framebuffer);
585
586 /**
587 * fb_set_suspend - low level driver signals suspend
588 * @info: framebuffer affected
589 * @state: 0 = resuming, !=0 = suspending
590 *
591 * This is meant to be used by low level drivers to
592 * signal suspend/resume to the core & clients.
593 * It must be called with the console semaphore held
594 */
fb_set_suspend(struct fb_info * info,int state)595 void fb_set_suspend(struct fb_info *info, int state)
596 {
597 WARN_CONSOLE_UNLOCKED();
598
599 if (state) {
600 fbcon_suspended(info);
601 info->state = FBINFO_STATE_SUSPENDED;
602 } else {
603 info->state = FBINFO_STATE_RUNNING;
604 fbcon_resumed(info);
605 }
606 }
607 EXPORT_SYMBOL(fb_set_suspend);
608
fbmem_init(void)609 static int __init fbmem_init(void)
610 {
611 int ret;
612
613 fb_class = class_create("graphics");
614 if (IS_ERR(fb_class)) {
615 ret = PTR_ERR(fb_class);
616 pr_err("Unable to create fb class; errno = %d\n", ret);
617 goto err_fb_class;
618 }
619
620 ret = fb_init_procfs();
621 if (ret)
622 goto err_class_destroy;
623
624 ret = fb_register_chrdev();
625 if (ret)
626 goto err_fb_cleanup_procfs;
627
628 fb_console_init();
629
630 return 0;
631
632 err_fb_cleanup_procfs:
633 fb_cleanup_procfs();
634 err_class_destroy:
635 class_destroy(fb_class);
636 err_fb_class:
637 fb_class = NULL;
638 return ret;
639 }
640
641 #ifdef MODULE
fbmem_exit(void)642 static void __exit fbmem_exit(void)
643 {
644 fb_console_exit();
645 fb_unregister_chrdev();
646 fb_cleanup_procfs();
647 class_destroy(fb_class);
648 }
649
650 module_init(fbmem_init);
651 module_exit(fbmem_exit);
652 MODULE_LICENSE("GPL");
653 MODULE_DESCRIPTION("Framebuffer base");
654 #else
655 subsys_initcall(fbmem_init);
656 #endif
657
fb_new_modelist(struct fb_info * info)658 int fb_new_modelist(struct fb_info *info)
659 {
660 struct fb_var_screeninfo var = info->var;
661 struct list_head *pos, *n;
662 struct fb_modelist *modelist;
663 struct fb_videomode *m, mode;
664 int err;
665
666 list_for_each_safe(pos, n, &info->modelist) {
667 modelist = list_entry(pos, struct fb_modelist, list);
668 m = &modelist->mode;
669 fb_videomode_to_var(&var, m);
670 var.activate = FB_ACTIVATE_TEST;
671 err = fb_set_var(info, &var);
672 fb_var_to_videomode(&mode, &var);
673 if (err || !fb_mode_is_equal(m, &mode)) {
674 list_del(pos);
675 kfree(pos);
676 }
677 }
678
679 if (list_empty(&info->modelist))
680 return 1;
681
682 fbcon_new_modelist(info);
683
684 return 0;
685 }
686
fb_modesetting_disabled(const char * drvname)687 bool fb_modesetting_disabled(const char *drvname)
688 {
689 bool fwonly = video_firmware_drivers_only();
690
691 if (fwonly)
692 pr_warn("Driver %s not loading because of nomodeset parameter\n",
693 drvname);
694
695 return fwonly;
696 }
697 EXPORT_SYMBOL(fb_modesetting_disabled);
698
699 MODULE_LICENSE("GPL");
700