?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
linux/audit.h: move ptrace.h include to kernel header
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / video / omap / omapfb_main.c
blobe31f5b33b501e155fed50e9a5463614e9cdc1690
1 /*
2 * Framebuffer driver for TI OMAP boards
3 *
4 * Copyright (C) 2004 Nokia Corporation
5 * Author: Imre Deak <imre.deak@nokia.com>
6 *
7 * Acknowledgements:
8 * Alex McMains <aam@ridgerun.com> - Original driver
9 * Juha Yrjola <juha.yrjola@nokia.com> - Original driver and improvements
10 * Dirk Behme <dirk.behme@de.bosch.com> - changes for 2.6 kernel API
11 * Texas Instruments - H3 support
12 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 */
27 #include <linux/platform_device.h>
28 #include <linux/mm.h>
29 #include <linux/slab.h>
30 #include <linux/uaccess.h>
31 #include <linux/module.h>
32
33 #include <linux/omap-dma.h>
34
35 #include "omapfb.h"
36 #include "lcdc.h"
37
38 #define MODULE_NAME "omapfb"
39
40 static unsigned int def_accel;
41 static unsigned long def_vram[OMAPFB_PLANE_NUM];
42 static unsigned int def_vram_cnt;
43 static unsigned long def_vxres;
44 static unsigned long def_vyres;
45 static unsigned int def_rotate;
46 static unsigned int def_mirror;
47
48 #ifdef CONFIG_FB_OMAP_MANUAL_UPDATE
49 static bool manual_update = 1;
50 #else
51 static bool manual_update;
52 #endif
53
54 static struct platform_device *fbdev_pdev;
55 static struct lcd_panel *fbdev_panel;
56 static struct omapfb_device *omapfb_dev;
57
58 struct caps_table_struct {
59 unsigned long flag;
60 const char *name;
61 };
62
63 static struct caps_table_struct ctrl_caps[] = {
64 { OMAPFB_CAPS_MANUAL_UPDATE, "manual update" },
65 { OMAPFB_CAPS_TEARSYNC, "tearing synchronization" },
66 { OMAPFB_CAPS_PLANE_RELOCATE_MEM, "relocate plane memory" },
67 { OMAPFB_CAPS_PLANE_SCALE, "scale plane" },
68 { OMAPFB_CAPS_WINDOW_PIXEL_DOUBLE, "pixel double window" },
69 { OMAPFB_CAPS_WINDOW_SCALE, "scale window" },
70 { OMAPFB_CAPS_WINDOW_OVERLAY, "overlay window" },
71 { OMAPFB_CAPS_WINDOW_ROTATE, "rotate window" },
72 { OMAPFB_CAPS_SET_BACKLIGHT, "backlight setting" },
73 };
74
75 static struct caps_table_struct color_caps[] = {
76 { 1 << OMAPFB_COLOR_RGB565, "RGB565", },
77 { 1 << OMAPFB_COLOR_YUV422, "YUV422", },
78 { 1 << OMAPFB_COLOR_YUV420, "YUV420", },
79 { 1 << OMAPFB_COLOR_CLUT_8BPP, "CLUT8", },
80 { 1 << OMAPFB_COLOR_CLUT_4BPP, "CLUT4", },
81 { 1 << OMAPFB_COLOR_CLUT_2BPP, "CLUT2", },
82 { 1 << OMAPFB_COLOR_CLUT_1BPP, "CLUT1", },
83 { 1 << OMAPFB_COLOR_RGB444, "RGB444", },
84 { 1 << OMAPFB_COLOR_YUY422, "YUY422", },
85 };
86
87 static void omapdss_release(struct device *dev)
88 {
89 }
90
91 /* dummy device for clocks */
92 static struct platform_device omapdss_device = {
93 .name = "omapdss_dss",
94 .id = -1,
95 .dev = {
96 .release = omapdss_release,
97 },
98 };
99
100 /*
101 * ---------------------------------------------------------------------------
102 * LCD panel
103 * ---------------------------------------------------------------------------
104 */
105 extern struct lcd_ctrl hwa742_ctrl;
106
107 static const struct lcd_ctrl *ctrls[] = {
108 &omap1_int_ctrl,
109
110 #ifdef CONFIG_FB_OMAP_LCDC_HWA742
111 &hwa742_ctrl,
112 #endif
113 };
114
115 #ifdef CONFIG_FB_OMAP_LCDC_EXTERNAL
116 extern struct lcd_ctrl_extif omap1_ext_if;
117 #endif
118
119 static void omapfb_rqueue_lock(struct omapfb_device *fbdev)
120 {
121 mutex_lock(&fbdev->rqueue_mutex);
122 }
123
124 static void omapfb_rqueue_unlock(struct omapfb_device *fbdev)
125 {
126 mutex_unlock(&fbdev->rqueue_mutex);
127 }
128
129 /*
130 * ---------------------------------------------------------------------------
131 * LCD controller and LCD DMA
132 * ---------------------------------------------------------------------------
133 */
134 /*
135 * Allocate resources needed for LCD controller and LCD DMA operations. Video
136 * memory is allocated from system memory according to the virtual display
137 * size, except if a bigger memory size is specified explicitly as a kernel
138 * parameter.
139 */
140 static int ctrl_init(struct omapfb_device *fbdev)
141 {
142 int r;
143 int i;
144
145 /* kernel/module vram parameters override boot tags/board config */
146 if (def_vram_cnt) {
147 for (i = 0; i < def_vram_cnt; i++)
148 fbdev->mem_desc.region[i].size =
149 PAGE_ALIGN(def_vram[i]);
150 fbdev->mem_desc.region_cnt = i;
151 }
152
153 if (!fbdev->mem_desc.region_cnt) {
154 struct lcd_panel *panel = fbdev->panel;
155 int def_size;
156 int bpp = panel->bpp;
157
158 /* 12 bpp is packed in 16 bits */
159 if (bpp == 12)
160 bpp = 16;
161 def_size = def_vxres * def_vyres * bpp / 8;
162 fbdev->mem_desc.region_cnt = 1;
163 fbdev->mem_desc.region[0].size = PAGE_ALIGN(def_size);
164 }
165 r = fbdev->ctrl->init(fbdev, 0, &fbdev->mem_desc);
166 if (r < 0) {
167 dev_err(fbdev->dev, "controller initialization failed (%d)\n",
168 r);
169 return r;
170 }
171
172 #ifdef DEBUG
173 for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
174 dev_dbg(fbdev->dev, "region%d phys %08x virt %p size=%lu\n",
175 i,
176 fbdev->mem_desc.region[i].paddr,
177 fbdev->mem_desc.region[i].vaddr,
178 fbdev->mem_desc.region[i].size);
179 }
180 #endif
181 return 0;
182 }
183
184 static void ctrl_cleanup(struct omapfb_device *fbdev)
185 {
186 fbdev->ctrl->cleanup();
187 }
188
189 /* Must be called with fbdev->rqueue_mutex held. */
190 static int ctrl_change_mode(struct fb_info *fbi)
191 {
192 int r;
193 unsigned long offset;
194 struct omapfb_plane_struct *plane = fbi->par;
195 struct omapfb_device *fbdev = plane->fbdev;
196 struct fb_var_screeninfo *var = &fbi->var;
197
198 offset = var->yoffset * fbi->fix.line_length +
199 var->xoffset * var->bits_per_pixel / 8;
200
201 if (fbdev->ctrl->sync)
202 fbdev->ctrl->sync();
203 r = fbdev->ctrl->setup_plane(plane->idx, plane->info.channel_out,
204 offset, var->xres_virtual,
205 plane->info.pos_x, plane->info.pos_y,
206 var->xres, var->yres, plane->color_mode);
207 if (r < 0)
208 return r;
209
210 if (fbdev->ctrl->set_rotate != NULL) {
211 r = fbdev->ctrl->set_rotate(var->rotate);
212 if (r < 0)
213 return r;
214 }
215
216 if (fbdev->ctrl->set_scale != NULL)
217 r = fbdev->ctrl->set_scale(plane->idx,
218 var->xres, var->yres,
219 plane->info.out_width,
220 plane->info.out_height);
221
222 return r;
223 }
224
225 /*
226 * ---------------------------------------------------------------------------
227 * fbdev framework callbacks and the ioctl interface
228 * ---------------------------------------------------------------------------
229 */
230 /* Called each time the omapfb device is opened */
231 static int omapfb_open(struct fb_info *info, int user)
232 {
233 return 0;
234 }
235
236 static void omapfb_sync(struct fb_info *info);
237
238 /* Called when the omapfb device is closed. We make sure that any pending
239 * gfx DMA operations are ended, before we return. */
240 static int omapfb_release(struct fb_info *info, int user)
241 {
242 omapfb_sync(info);
243 return 0;
244 }
245
246 /* Store a single color palette entry into a pseudo palette or the hardware
247 * palette if one is available. For now we support only 16bpp and thus store
248 * the entry only to the pseudo palette.
249 */
250 static int _setcolreg(struct fb_info *info, u_int regno, u_int red, u_int green,
251 u_int blue, u_int transp, int update_hw_pal)
252 {
253 struct omapfb_plane_struct *plane = info->par;
254 struct omapfb_device *fbdev = plane->fbdev;
255 struct fb_var_screeninfo *var = &info->var;
256 int r = 0;
257
258 switch (plane->color_mode) {
259 case OMAPFB_COLOR_YUV422:
260 case OMAPFB_COLOR_YUV420:
261 case OMAPFB_COLOR_YUY422:
262 r = -EINVAL;
263 break;
264 case OMAPFB_COLOR_CLUT_8BPP:
265 case OMAPFB_COLOR_CLUT_4BPP:
266 case OMAPFB_COLOR_CLUT_2BPP:
267 case OMAPFB_COLOR_CLUT_1BPP:
268 if (fbdev->ctrl->setcolreg)
269 r = fbdev->ctrl->setcolreg(regno, red, green, blue,
270 transp, update_hw_pal);
271 /* Fallthrough */
272 case OMAPFB_COLOR_RGB565:
273 case OMAPFB_COLOR_RGB444:
274 if (r != 0)
275 break;
276
277 if (regno < 0) {
278 r = -EINVAL;
279 break;
280 }
281
282 if (regno < 16) {
283 u16 pal;
284 pal = ((red >> (16 - var->red.length)) <<
285 var->red.offset) |
286 ((green >> (16 - var->green.length)) <<
287 var->green.offset) |
288 (blue >> (16 - var->blue.length));
289 ((u32 *)(info->pseudo_palette))[regno] = pal;
290 }
291 break;
292 default:
293 BUG();
294 }
295 return r;
296 }
297
298 static int omapfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
299 u_int transp, struct fb_info *info)
300 {
301 return _setcolreg(info, regno, red, green, blue, transp, 1);
302 }
303
304 static int omapfb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
305 {
306 int count, index, r;
307 u16 *red, *green, *blue, *transp;
308 u16 trans = 0xffff;
309
310 red = cmap->red;
311 green = cmap->green;
312 blue = cmap->blue;
313 transp = cmap->transp;
314 index = cmap->start;
315
316 for (count = 0; count < cmap->len; count++) {
317 if (transp)
318 trans = *transp++;
319 r = _setcolreg(info, index++, *red++, *green++, *blue++, trans,
320 count == cmap->len - 1);
321 if (r != 0)
322 return r;
323 }
324
325 return 0;
326 }
327
328 static int omapfb_update_full_screen(struct fb_info *fbi);
329
330 static int omapfb_blank(int blank, struct fb_info *fbi)
331 {
332 struct omapfb_plane_struct *plane = fbi->par;
333 struct omapfb_device *fbdev = plane->fbdev;
334 int do_update = 0;
335 int r = 0;
336
337 omapfb_rqueue_lock(fbdev);
338 switch (blank) {
339 case FB_BLANK_UNBLANK:
340 if (fbdev->state == OMAPFB_SUSPENDED) {
341 if (fbdev->ctrl->resume)
342 fbdev->ctrl->resume();
343 fbdev->panel->enable(fbdev->panel);
344 fbdev->state = OMAPFB_ACTIVE;
345 if (fbdev->ctrl->get_update_mode() ==
346 OMAPFB_MANUAL_UPDATE)
347 do_update = 1;
348 }
349 break;
350 case FB_BLANK_POWERDOWN:
351 if (fbdev->state == OMAPFB_ACTIVE) {
352 fbdev->panel->disable(fbdev->panel);
353 if (fbdev->ctrl->suspend)
354 fbdev->ctrl->suspend();
355 fbdev->state = OMAPFB_SUSPENDED;
356 }
357 break;
358 default:
359 r = -EINVAL;
360 }
361 omapfb_rqueue_unlock(fbdev);
362
363 if (r == 0 && do_update)
364 r = omapfb_update_full_screen(fbi);
365
366 return r;
367 }
368
369 static void omapfb_sync(struct fb_info *fbi)
370 {
371 struct omapfb_plane_struct *plane = fbi->par;
372 struct omapfb_device *fbdev = plane->fbdev;
373
374 omapfb_rqueue_lock(fbdev);
375 if (fbdev->ctrl->sync)
376 fbdev->ctrl->sync();
377 omapfb_rqueue_unlock(fbdev);
378 }
379
380 /*
381 * Set fb_info.fix fields and also updates fbdev.
382 * When calling this fb_info.var must be set up already.
383 */
384 static void set_fb_fix(struct fb_info *fbi, int from_init)
385 {
386 struct fb_fix_screeninfo *fix = &fbi->fix;
387 struct fb_var_screeninfo *var = &fbi->var;
388 struct omapfb_plane_struct *plane = fbi->par;
389 struct omapfb_mem_region *rg;
390 int bpp;
391
392 rg = &plane->fbdev->mem_desc.region[plane->idx];
393 fbi->screen_base = rg->vaddr;
394
395 if (!from_init) {
396 mutex_lock(&fbi->mm_lock);
397 fix->smem_start = rg->paddr;
398 fix->smem_len = rg->size;
399 mutex_unlock(&fbi->mm_lock);
400 } else {
401 fix->smem_start = rg->paddr;
402 fix->smem_len = rg->size;
403 }
404
405 fix->type = FB_TYPE_PACKED_PIXELS;
406 bpp = var->bits_per_pixel;
407 if (var->nonstd)
408 fix->visual = FB_VISUAL_PSEUDOCOLOR;
409 else switch (var->bits_per_pixel) {
410 case 16:
411 case 12:
412 fix->visual = FB_VISUAL_TRUECOLOR;
413 /* 12bpp is stored in 16 bits */
414 bpp = 16;
415 break;
416 case 1:
417 case 2:
418 case 4:
419 case 8:
420 fix->visual = FB_VISUAL_PSEUDOCOLOR;
421 break;
422 }
423 fix->accel = FB_ACCEL_OMAP1610;
424 fix->line_length = var->xres_virtual * bpp / 8;
425 }
426
427 static int set_color_mode(struct omapfb_plane_struct *plane,
428 struct fb_var_screeninfo *var)
429 {
430 switch (var->nonstd) {
431 case 0:
432 break;
433 case OMAPFB_COLOR_YUV422:
434 var->bits_per_pixel = 16;
435 plane->color_mode = var->nonstd;
436 return 0;
437 case OMAPFB_COLOR_YUV420:
438 var->bits_per_pixel = 12;
439 plane->color_mode = var->nonstd;
440 return 0;
441 case OMAPFB_COLOR_YUY422:
442 var->bits_per_pixel = 16;
443 plane->color_mode = var->nonstd;
444 return 0;
445 default:
446 return -EINVAL;
447 }
448
449 switch (var->bits_per_pixel) {
450 case 1:
451 plane->color_mode = OMAPFB_COLOR_CLUT_1BPP;
452 return 0;
453 case 2:
454 plane->color_mode = OMAPFB_COLOR_CLUT_2BPP;
455 return 0;
456 case 4:
457 plane->color_mode = OMAPFB_COLOR_CLUT_4BPP;
458 return 0;
459 case 8:
460 plane->color_mode = OMAPFB_COLOR_CLUT_8BPP;
461 return 0;
462 case 12:
463 var->bits_per_pixel = 16;
464 case 16:
465 if (plane->fbdev->panel->bpp == 12)
466 plane->color_mode = OMAPFB_COLOR_RGB444;
467 else
468 plane->color_mode = OMAPFB_COLOR_RGB565;
469 return 0;
470 default:
471 return -EINVAL;
472 }
473 }
474
475 /*
476 * Check the values in var against our capabilities and in case of out of
477 * bound values try to adjust them.
478 */
479 static int set_fb_var(struct fb_info *fbi,
480 struct fb_var_screeninfo *var)
481 {
482 int bpp;
483 unsigned long max_frame_size;
484 unsigned long line_size;
485 int xres_min, xres_max;
486 int yres_min, yres_max;
487 struct omapfb_plane_struct *plane = fbi->par;
488 struct omapfb_device *fbdev = plane->fbdev;
489 struct lcd_panel *panel = fbdev->panel;
490
491 if (set_color_mode(plane, var) < 0)
492 return -EINVAL;
493
494 bpp = var->bits_per_pixel;
495 if (plane->color_mode == OMAPFB_COLOR_RGB444)
496 bpp = 16;
497
498 switch (var->rotate) {
499 case 0:
500 case 180:
501 xres_min = OMAPFB_PLANE_XRES_MIN;
502 xres_max = panel->x_res;
503 yres_min = OMAPFB_PLANE_YRES_MIN;
504 yres_max = panel->y_res;
505 if (cpu_is_omap15xx()) {
506 var->xres = panel->x_res;
507 var->yres = panel->y_res;
508 }
509 break;
510 case 90:
511 case 270:
512 xres_min = OMAPFB_PLANE_YRES_MIN;
513 xres_max = panel->y_res;
514 yres_min = OMAPFB_PLANE_XRES_MIN;
515 yres_max = panel->x_res;
516 if (cpu_is_omap15xx()) {
517 var->xres = panel->y_res;
518 var->yres = panel->x_res;
519 }
520 break;
521 default:
522 return -EINVAL;
523 }
524
525 if (var->xres < xres_min)
526 var->xres = xres_min;
527 if (var->yres < yres_min)
528 var->yres = yres_min;
529 if (var->xres > xres_max)
530 var->xres = xres_max;
531 if (var->yres > yres_max)
532 var->yres = yres_max;
533
534 if (var->xres_virtual < var->xres)
535 var->xres_virtual = var->xres;
536 if (var->yres_virtual < var->yres)
537 var->yres_virtual = var->yres;
538 max_frame_size = fbdev->mem_desc.region[plane->idx].size;
539 line_size = var->xres_virtual * bpp / 8;
540 if (line_size * var->yres_virtual > max_frame_size) {
541 /* Try to keep yres_virtual first */
542 line_size = max_frame_size / var->yres_virtual;
543 var->xres_virtual = line_size * 8 / bpp;
544 if (var->xres_virtual < var->xres) {
545 /* Still doesn't fit. Shrink yres_virtual too */
546 var->xres_virtual = var->xres;
547 line_size = var->xres * bpp / 8;
548 var->yres_virtual = max_frame_size / line_size;
549 }
550 /* Recheck this, as the virtual size changed. */
551 if (var->xres_virtual < var->xres)
552 var->xres = var->xres_virtual;
553 if (var->yres_virtual < var->yres)
554 var->yres = var->yres_virtual;
555 if (var->xres < xres_min || var->yres < yres_min)
556 return -EINVAL;
557 }
558 if (var->xres + var->xoffset > var->xres_virtual)
559 var->xoffset = var->xres_virtual - var->xres;
560 if (var->yres + var->yoffset > var->yres_virtual)
561 var->yoffset = var->yres_virtual - var->yres;
562
563 if (plane->color_mode == OMAPFB_COLOR_RGB444) {
564 var->red.offset = 8; var->red.length = 4;
565 var->red.msb_right = 0;
566 var->green.offset = 4; var->green.length = 4;
567 var->green.msb_right = 0;
568 var->blue.offset = 0; var->blue.length = 4;
569 var->blue.msb_right = 0;
570 } else {
571 var->red.offset = 11; var->red.length = 5;
572 var->red.msb_right = 0;
573 var->green.offset = 5; var->green.length = 6;
574 var->green.msb_right = 0;
575 var->blue.offset = 0; var->blue.length = 5;
576 var->blue.msb_right = 0;
577 }
578
579 var->height = -1;
580 var->width = -1;
581 var->grayscale = 0;
582
583 /* pixclock in ps, the rest in pixclock */
584 var->pixclock = 10000000 / (panel->pixel_clock / 100);
585 var->left_margin = panel->hfp;
586 var->right_margin = panel->hbp;
587 var->upper_margin = panel->vfp;
588 var->lower_margin = panel->vbp;
589 var->hsync_len = panel->hsw;
590 var->vsync_len = panel->vsw;
591
592 /* TODO: get these from panel->config */
593 var->vmode = FB_VMODE_NONINTERLACED;
594 var->sync = 0;
595
596 return 0;
597 }
598
599
600 /* Set rotation (0, 90, 180, 270 degree), and switch to the new mode. */
601 static void omapfb_rotate(struct fb_info *fbi, int rotate)
602 {
603 struct omapfb_plane_struct *plane = fbi->par;
604 struct omapfb_device *fbdev = plane->fbdev;
605
606 omapfb_rqueue_lock(fbdev);
607 if (rotate != fbi->var.rotate) {
608 struct fb_var_screeninfo *new_var = &fbdev->new_var;
609
610 memcpy(new_var, &fbi->var, sizeof(*new_var));
611 new_var->rotate = rotate;
612 if (set_fb_var(fbi, new_var) == 0 &&
613 memcmp(new_var, &fbi->var, sizeof(*new_var))) {
614 memcpy(&fbi->var, new_var, sizeof(*new_var));
615 ctrl_change_mode(fbi);
616 }
617 }
618 omapfb_rqueue_unlock(fbdev);
619 }
620
621 /*
622 * Set new x,y offsets in the virtual display for the visible area and switch
623 * to the new mode.
624 */
625 static int omapfb_pan_display(struct fb_var_screeninfo *var,
626 struct fb_info *fbi)
627 {
628 struct omapfb_plane_struct *plane = fbi->par;
629 struct omapfb_device *fbdev = plane->fbdev;
630 int r = 0;
631
632 omapfb_rqueue_lock(fbdev);
633 if (var->xoffset != fbi->var.xoffset ||
634 var->yoffset != fbi->var.yoffset) {
635 struct fb_var_screeninfo *new_var = &fbdev->new_var;
636
637 memcpy(new_var, &fbi->var, sizeof(*new_var));
638 new_var->xoffset = var->xoffset;
639 new_var->yoffset = var->yoffset;
640 if (set_fb_var(fbi, new_var))
641 r = -EINVAL;
642 else {
643 memcpy(&fbi->var, new_var, sizeof(*new_var));
644 ctrl_change_mode(fbi);
645 }
646 }
647 omapfb_rqueue_unlock(fbdev);
648
649 return r;
650 }
651
652 /* Set mirror to vertical axis and switch to the new mode. */
653 static int omapfb_mirror(struct fb_info *fbi, int mirror)
654 {
655 struct omapfb_plane_struct *plane = fbi->par;
656 struct omapfb_device *fbdev = plane->fbdev;
657 int r = 0;
658
659 omapfb_rqueue_lock(fbdev);
660 mirror = mirror ? 1 : 0;
661 if (cpu_is_omap15xx())
662 r = -EINVAL;
663 else if (mirror != plane->info.mirror) {
664 plane->info.mirror = mirror;
665 r = ctrl_change_mode(fbi);
666 }
667 omapfb_rqueue_unlock(fbdev);
668
669 return r;
670 }
671
672 /*
673 * Check values in var, try to adjust them in case of out of bound values if
674 * possible, or return error.
675 */
676 static int omapfb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
677 {
678 struct omapfb_plane_struct *plane = fbi->par;
679 struct omapfb_device *fbdev = plane->fbdev;
680 int r;
681
682 omapfb_rqueue_lock(fbdev);
683 if (fbdev->ctrl->sync != NULL)
684 fbdev->ctrl->sync();
685 r = set_fb_var(fbi, var);
686 omapfb_rqueue_unlock(fbdev);
687
688 return r;
689 }
690
691 /*
692 * Switch to a new mode. The parameters for it has been check already by
693 * omapfb_check_var.
694 */
695 static int omapfb_set_par(struct fb_info *fbi)
696 {
697 struct omapfb_plane_struct *plane = fbi->par;
698 struct omapfb_device *fbdev = plane->fbdev;
699 int r = 0;
700
701 omapfb_rqueue_lock(fbdev);
702 set_fb_fix(fbi, 0);
703 r = ctrl_change_mode(fbi);
704 omapfb_rqueue_unlock(fbdev);
705
706 return r;
707 }
708
709 int omapfb_update_window_async(struct fb_info *fbi,
710 struct omapfb_update_window *win,
711 void (*callback)(void *),
712 void *callback_data)
713 {
714 int xres, yres;
715 struct omapfb_plane_struct *plane = fbi->par;
716 struct omapfb_device *fbdev = plane->fbdev;
717 struct fb_var_screeninfo *var = &fbi->var;
718
719 switch (var->rotate) {
720 case 0:
721 case 180:
722 xres = fbdev->panel->x_res;
723 yres = fbdev->panel->y_res;
724 break;
725 case 90:
726 case 270:
727 xres = fbdev->panel->y_res;
728 yres = fbdev->panel->x_res;
729 break;
730 default:
731 return -EINVAL;
732 }
733
734 if (win->x >= xres || win->y >= yres ||
735 win->out_x > xres || win->out_y > yres)
736 return -EINVAL;
737
738 if (!fbdev->ctrl->update_window ||
739 fbdev->ctrl->get_update_mode() != OMAPFB_MANUAL_UPDATE)
740 return -ENODEV;
741
742 if (win->x + win->width > xres)
743 win->width = xres - win->x;
744 if (win->y + win->height > yres)
745 win->height = yres - win->y;
746 if (win->out_x + win->out_width > xres)
747 win->out_width = xres - win->out_x;
748 if (win->out_y + win->out_height > yres)
749 win->out_height = yres - win->out_y;
750 if (!win->width || !win->height || !win->out_width || !win->out_height)
751 return 0;
752
753 return fbdev->ctrl->update_window(fbi, win, callback, callback_data);
754 }
755 EXPORT_SYMBOL(omapfb_update_window_async);
756
757 static int omapfb_update_win(struct fb_info *fbi,
758 struct omapfb_update_window *win)
759 {
760 struct omapfb_plane_struct *plane = fbi->par;
761 int ret;
762
763 omapfb_rqueue_lock(plane->fbdev);
764 ret = omapfb_update_window_async(fbi, win, NULL, NULL);
765 omapfb_rqueue_unlock(plane->fbdev);
766
767 return ret;
768 }
769
770 static int omapfb_update_full_screen(struct fb_info *fbi)
771 {
772 struct omapfb_plane_struct *plane = fbi->par;
773 struct omapfb_device *fbdev = plane->fbdev;
774 struct omapfb_update_window win;
775 int r;
776
777 if (!fbdev->ctrl->update_window ||
778 fbdev->ctrl->get_update_mode() != OMAPFB_MANUAL_UPDATE)
779 return -ENODEV;
780
781 win.x = 0;
782 win.y = 0;
783 win.width = fbi->var.xres;
784 win.height = fbi->var.yres;
785 win.out_x = 0;
786 win.out_y = 0;
787 win.out_width = fbi->var.xres;
788 win.out_height = fbi->var.yres;
789 win.format = 0;
790
791 omapfb_rqueue_lock(fbdev);
792 r = fbdev->ctrl->update_window(fbi, &win, NULL, NULL);
793 omapfb_rqueue_unlock(fbdev);
794
795 return r;
796 }
797
798 static int omapfb_setup_plane(struct fb_info *fbi, struct omapfb_plane_info *pi)
799 {
800 struct omapfb_plane_struct *plane = fbi->par;
801 struct omapfb_device *fbdev = plane->fbdev;
802 struct lcd_panel *panel = fbdev->panel;
803 struct omapfb_plane_info old_info;
804 int r = 0;
805
806 if (pi->pos_x + pi->out_width > panel->x_res ||
807 pi->pos_y + pi->out_height > panel->y_res)
808 return -EINVAL;
809
810 omapfb_rqueue_lock(fbdev);
811 if (pi->enabled && !fbdev->mem_desc.region[plane->idx].size) {
812 /*
813 * This plane's memory was freed, can't enable it
814 * until it's reallocated.
815 */
816 r = -EINVAL;
817 goto out;
818 }
819 old_info = plane->info;
820 plane->info = *pi;
821 if (pi->enabled) {
822 r = ctrl_change_mode(fbi);
823 if (r < 0) {
824 plane->info = old_info;
825 goto out;
826 }
827 }
828 r = fbdev->ctrl->enable_plane(plane->idx, pi->enabled);
829 if (r < 0) {
830 plane->info = old_info;
831 goto out;
832 }
833 out:
834 omapfb_rqueue_unlock(fbdev);
835 return r;
836 }
837
838 static int omapfb_query_plane(struct fb_info *fbi, struct omapfb_plane_info *pi)
839 {
840 struct omapfb_plane_struct *plane = fbi->par;
841
842 *pi = plane->info;
843 return 0;
844 }
845
846 static int omapfb_setup_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
847 {
848 struct omapfb_plane_struct *plane = fbi->par;
849 struct omapfb_device *fbdev = plane->fbdev;
850 struct omapfb_mem_region *rg = &fbdev->mem_desc.region[plane->idx];
851 size_t size;
852 int r = 0;
853
854 if (fbdev->ctrl->setup_mem == NULL)
855 return -ENODEV;
856 if (mi->type != OMAPFB_MEMTYPE_SDRAM)
857 return -EINVAL;
858
859 size = PAGE_ALIGN(mi->size);
860 omapfb_rqueue_lock(fbdev);
861 if (plane->info.enabled) {
862 r = -EBUSY;
863 goto out;
864 }
865 if (rg->size != size || rg->type != mi->type) {
866 struct fb_var_screeninfo *new_var = &fbdev->new_var;
867 unsigned long old_size = rg->size;
868 u8 old_type = rg->type;
869 unsigned long paddr;
870
871 rg->size = size;
872 rg->type = mi->type;
873 /*
874 * size == 0 is a special case, for which we
875 * don't check / adjust the screen parameters.
876 * This isn't a problem since the plane can't
877 * be reenabled unless its size is > 0.
878 */
879 if (old_size != size && size) {
880 if (size) {
881 memcpy(new_var, &fbi->var, sizeof(*new_var));
882 r = set_fb_var(fbi, new_var);
883 if (r < 0)
884 goto out;
885 }
886 }
887
888 if (fbdev->ctrl->sync)
889 fbdev->ctrl->sync();
890 r = fbdev->ctrl->setup_mem(plane->idx, size, mi->type, &paddr);
891 if (r < 0) {
892 /* Revert changes. */
893 rg->size = old_size;
894 rg->type = old_type;
895 goto out;
896 }
897 rg->paddr = paddr;
898
899 if (old_size != size) {
900 if (size) {
901 memcpy(&fbi->var, new_var, sizeof(fbi->var));
902 set_fb_fix(fbi, 0);
903 } else {
904 /*
905 * Set these explicitly to indicate that the
906 * plane memory is dealloce'd, the other
907 * screen parameters in var / fix are invalid.
908 */
909 mutex_lock(&fbi->mm_lock);
910 fbi->fix.smem_start = 0;
911 fbi->fix.smem_len = 0;
912 mutex_unlock(&fbi->mm_lock);
913 }
914 }
915 }
916 out:
917 omapfb_rqueue_unlock(fbdev);
918
919 return r;
920 }
921
922 static int omapfb_query_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
923 {
924 struct omapfb_plane_struct *plane = fbi->par;
925 struct omapfb_device *fbdev = plane->fbdev;
926 struct omapfb_mem_region *rg;
927
928 rg = &fbdev->mem_desc.region[plane->idx];
929 memset(mi, 0, sizeof(*mi));
930 mi->size = rg->size;
931 mi->type = rg->type;
932
933 return 0;
934 }
935
936 static int omapfb_set_color_key(struct omapfb_device *fbdev,
937 struct omapfb_color_key *ck)
938 {
939 int r;
940
941 if (!fbdev->ctrl->set_color_key)
942 return -ENODEV;
943
944 omapfb_rqueue_lock(fbdev);
945 r = fbdev->ctrl->set_color_key(ck);
946 omapfb_rqueue_unlock(fbdev);
947
948 return r;
949 }
950
951 static int omapfb_get_color_key(struct omapfb_device *fbdev,
952 struct omapfb_color_key *ck)
953 {
954 int r;
955
956 if (!fbdev->ctrl->get_color_key)
957 return -ENODEV;
958
959 omapfb_rqueue_lock(fbdev);
960 r = fbdev->ctrl->get_color_key(ck);
961 omapfb_rqueue_unlock(fbdev);
962
963 return r;
964 }
965
966 static struct blocking_notifier_head omapfb_client_list[OMAPFB_PLANE_NUM];
967 static int notifier_inited;
968
969 static void omapfb_init_notifier(void)
970 {
971 int i;
972
973 for (i = 0; i < OMAPFB_PLANE_NUM; i++)
974 BLOCKING_INIT_NOTIFIER_HEAD(&omapfb_client_list[i]);
975 }
976
977 int omapfb_register_client(struct omapfb_notifier_block *omapfb_nb,
978 omapfb_notifier_callback_t callback,
979 void *callback_data)
980 {
981 int r;
982
983 if ((unsigned)omapfb_nb->plane_idx > OMAPFB_PLANE_NUM)
984 return -EINVAL;
985
986 if (!notifier_inited) {
987 omapfb_init_notifier();
988 notifier_inited = 1;
989 }
990
991 omapfb_nb->nb.notifier_call = (int (*)(struct notifier_block *,
992 unsigned long, void *))callback;
993 omapfb_nb->data = callback_data;
994 r = blocking_notifier_chain_register(
995 &omapfb_client_list[omapfb_nb->plane_idx],
996 &omapfb_nb->nb);
997 if (r)
998 return r;
999 if (omapfb_dev != NULL &&
1000 omapfb_dev->ctrl && omapfb_dev->ctrl->bind_client) {
1001 omapfb_dev->ctrl->bind_client(omapfb_nb);
1002 }
1003
1004 return 0;
1005 }
1006 EXPORT_SYMBOL(omapfb_register_client);
1007
1008 int omapfb_unregister_client(struct omapfb_notifier_block *omapfb_nb)
1009 {
1010 return blocking_notifier_chain_unregister(
1011 &omapfb_client_list[omapfb_nb->plane_idx], &omapfb_nb->nb);
1012 }
1013 EXPORT_SYMBOL(omapfb_unregister_client);
1014
1015 void omapfb_notify_clients(struct omapfb_device *fbdev, unsigned long event)
1016 {
1017 int i;
1018
1019 if (!notifier_inited)
1020 /* no client registered yet */
1021 return;
1022
1023 for (i = 0; i < OMAPFB_PLANE_NUM; i++)
1024 blocking_notifier_call_chain(&omapfb_client_list[i], event,
1025 fbdev->fb_info[i]);
1026 }
1027 EXPORT_SYMBOL(omapfb_notify_clients);
1028
1029 static int omapfb_set_update_mode(struct omapfb_device *fbdev,
1030 enum omapfb_update_mode mode)
1031 {
1032 int r;
1033
1034 omapfb_rqueue_lock(fbdev);
1035 r = fbdev->ctrl->set_update_mode(mode);
1036 omapfb_rqueue_unlock(fbdev);
1037
1038 return r;
1039 }
1040
1041 static enum omapfb_update_mode omapfb_get_update_mode(struct omapfb_device *fbdev)
1042 {
1043 int r;
1044
1045 omapfb_rqueue_lock(fbdev);
1046 r = fbdev->ctrl->get_update_mode();
1047 omapfb_rqueue_unlock(fbdev);
1048
1049 return r;
1050 }
1051
1052 static void omapfb_get_caps(struct omapfb_device *fbdev, int plane,
1053 struct omapfb_caps *caps)
1054 {
1055 memset(caps, 0, sizeof(*caps));
1056 fbdev->ctrl->get_caps(plane, caps);
1057 caps->ctrl |= fbdev->panel->get_caps(fbdev->panel);
1058 }
1059
1060 /* For lcd testing */
1061 void omapfb_write_first_pixel(struct omapfb_device *fbdev, u16 pixval)
1062 {
1063 omapfb_rqueue_lock(fbdev);
1064 *(u16 *)fbdev->mem_desc.region[0].vaddr = pixval;
1065 if (fbdev->ctrl->get_update_mode() == OMAPFB_MANUAL_UPDATE) {
1066 struct omapfb_update_window win;
1067
1068 memset(&win, 0, sizeof(win));
1069 win.width = 2;
1070 win.height = 2;
1071 win.out_width = 2;
1072 win.out_height = 2;
1073 fbdev->ctrl->update_window(fbdev->fb_info[0], &win, NULL, NULL);
1074 }
1075 omapfb_rqueue_unlock(fbdev);
1076 }
1077 EXPORT_SYMBOL(omapfb_write_first_pixel);
1078
1079 /*
1080 * Ioctl interface. Part of the kernel mode frame buffer API is duplicated
1081 * here to be accessible by user mode code.
1082 */
1083 static int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd,
1084 unsigned long arg)
1085 {
1086 struct omapfb_plane_struct *plane = fbi->par;
1087 struct omapfb_device *fbdev = plane->fbdev;
1088 struct fb_ops *ops = fbi->fbops;
1089 union {
1090 struct omapfb_update_window update_window;
1091 struct omapfb_plane_info plane_info;
1092 struct omapfb_mem_info mem_info;
1093 struct omapfb_color_key color_key;
1094 enum omapfb_update_mode update_mode;
1095 struct omapfb_caps caps;
1096 unsigned int mirror;
1097 int plane_out;
1098 int enable_plane;
1099 } p;
1100 int r = 0;
1101
1102 BUG_ON(!ops);
1103 switch (cmd) {
1104 case OMAPFB_MIRROR:
1105 if (get_user(p.mirror, (int __user *)arg))
1106 r = -EFAULT;
1107 else
1108 omapfb_mirror(fbi, p.mirror);
1109 break;
1110 case OMAPFB_SYNC_GFX:
1111 omapfb_sync(fbi);
1112 break;
1113 case OMAPFB_VSYNC:
1114 break;
1115 case OMAPFB_SET_UPDATE_MODE:
1116 if (get_user(p.update_mode, (int __user *)arg))
1117 r = -EFAULT;
1118 else
1119 r = omapfb_set_update_mode(fbdev, p.update_mode);
1120 break;
1121 case OMAPFB_GET_UPDATE_MODE:
1122 p.update_mode = omapfb_get_update_mode(fbdev);
1123 if (put_user(p.update_mode,
1124 (enum omapfb_update_mode __user *)arg))
1125 r = -EFAULT;
1126 break;
1127 case OMAPFB_UPDATE_WINDOW_OLD:
1128 if (copy_from_user(&p.update_window, (void __user *)arg,
1129 sizeof(struct omapfb_update_window_old)))
1130 r = -EFAULT;
1131 else {
1132 struct omapfb_update_window *u = &p.update_window;
1133 u->out_x = u->x;
1134 u->out_y = u->y;
1135 u->out_width = u->width;
1136 u->out_height = u->height;
1137 memset(u->reserved, 0, sizeof(u->reserved));
1138 r = omapfb_update_win(fbi, u);
1139 }
1140 break;
1141 case OMAPFB_UPDATE_WINDOW:
1142 if (copy_from_user(&p.update_window, (void __user *)arg,
1143 sizeof(p.update_window)))
1144 r = -EFAULT;
1145 else
1146 r = omapfb_update_win(fbi, &p.update_window);
1147 break;
1148 case OMAPFB_SETUP_PLANE:
1149 if (copy_from_user(&p.plane_info, (void __user *)arg,
1150 sizeof(p.plane_info)))
1151 r = -EFAULT;
1152 else
1153 r = omapfb_setup_plane(fbi, &p.plane_info);
1154 break;
1155 case OMAPFB_QUERY_PLANE:
1156 if ((r = omapfb_query_plane(fbi, &p.plane_info)) < 0)
1157 break;
1158 if (copy_to_user((void __user *)arg, &p.plane_info,
1159 sizeof(p.plane_info)))
1160 r = -EFAULT;
1161 break;
1162 case OMAPFB_SETUP_MEM:
1163 if (copy_from_user(&p.mem_info, (void __user *)arg,
1164 sizeof(p.mem_info)))
1165 r = -EFAULT;
1166 else
1167 r = omapfb_setup_mem(fbi, &p.mem_info);
1168 break;
1169 case OMAPFB_QUERY_MEM:
1170 if ((r = omapfb_query_mem(fbi, &p.mem_info)) < 0)
1171 break;
1172 if (copy_to_user((void __user *)arg, &p.mem_info,
1173 sizeof(p.mem_info)))
1174 r = -EFAULT;
1175 break;
1176 case OMAPFB_SET_COLOR_KEY:
1177 if (copy_from_user(&p.color_key, (void __user *)arg,
1178 sizeof(p.color_key)))
1179 r = -EFAULT;
1180 else
1181 r = omapfb_set_color_key(fbdev, &p.color_key);
1182 break;
1183 case OMAPFB_GET_COLOR_KEY:
1184 if ((r = omapfb_get_color_key(fbdev, &p.color_key)) < 0)
1185 break;
1186 if (copy_to_user((void __user *)arg, &p.color_key,
1187 sizeof(p.color_key)))
1188 r = -EFAULT;
1189 break;
1190 case OMAPFB_GET_CAPS:
1191 omapfb_get_caps(fbdev, plane->idx, &p.caps);
1192 if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
1193 r = -EFAULT;
1194 break;
1195 case OMAPFB_LCD_TEST:
1196 {
1197 int test_num;
1198
1199 if (get_user(test_num, (int __user *)arg)) {
1200 r = -EFAULT;
1201 break;
1202 }
1203 if (!fbdev->panel->run_test) {
1204 r = -EINVAL;
1205 break;
1206 }
1207 r = fbdev->panel->run_test(fbdev->panel, test_num);
1208 break;
1209 }
1210 case OMAPFB_CTRL_TEST:
1211 {
1212 int test_num;
1213
1214 if (get_user(test_num, (int __user *)arg)) {
1215 r = -EFAULT;
1216 break;
1217 }
1218 if (!fbdev->ctrl->run_test) {
1219 r = -EINVAL;
1220 break;
1221 }
1222 r = fbdev->ctrl->run_test(test_num);
1223 break;
1224 }
1225 default:
1226 r = -EINVAL;
1227 }
1228
1229 return r;
1230 }
1231
1232 static int omapfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
1233 {
1234 struct omapfb_plane_struct *plane = info->par;
1235 struct omapfb_device *fbdev = plane->fbdev;
1236 int r;
1237
1238 omapfb_rqueue_lock(fbdev);
1239 r = fbdev->ctrl->mmap(info, vma);
1240 omapfb_rqueue_unlock(fbdev);
1241
1242 return r;
1243 }
1244
1245 /*
1246 * Callback table for the frame buffer framework. Some of these pointers
1247 * will be changed according to the current setting of fb_info->accel_flags.
1248 */
1249 static struct fb_ops omapfb_ops = {
1250 .owner = THIS_MODULE,
1251 .fb_open = omapfb_open,
1252 .fb_release = omapfb_release,
1253 .fb_setcolreg = omapfb_setcolreg,
1254 .fb_setcmap = omapfb_setcmap,
1255 .fb_fillrect = cfb_fillrect,
1256 .fb_copyarea = cfb_copyarea,
1257 .fb_imageblit = cfb_imageblit,
1258 .fb_blank = omapfb_blank,
1259 .fb_ioctl = omapfb_ioctl,
1260 .fb_check_var = omapfb_check_var,
1261 .fb_set_par = omapfb_set_par,
1262 .fb_rotate = omapfb_rotate,
1263 .fb_pan_display = omapfb_pan_display,
1264 };
1265
1266 /*
1267 * ---------------------------------------------------------------------------
1268 * Sysfs interface
1269 * ---------------------------------------------------------------------------
1270 */
1271 /* omapfbX sysfs entries */
1272 static ssize_t omapfb_show_caps_num(struct device *dev,
1273 struct device_attribute *attr, char *buf)
1274 {
1275 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1276 int plane;
1277 size_t size;
1278 struct omapfb_caps caps;
1279
1280 plane = 0;
1281 size = 0;
1282 while (size < PAGE_SIZE && plane < OMAPFB_PLANE_NUM) {
1283 omapfb_get_caps(fbdev, plane, &caps);
1284 size += snprintf(&buf[size], PAGE_SIZE - size,
1285 "plane#%d %#010x %#010x %#010x\n",
1286 plane, caps.ctrl, caps.plane_color, caps.wnd_color);
1287 plane++;
1288 }
1289 return size;
1290 }
1291
1292 static ssize_t omapfb_show_caps_text(struct device *dev,
1293 struct device_attribute *attr, char *buf)
1294 {
1295 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1296 int i;
1297 struct omapfb_caps caps;
1298 int plane;
1299 size_t size;
1300
1301 plane = 0;
1302 size = 0;
1303 while (size < PAGE_SIZE && plane < OMAPFB_PLANE_NUM) {
1304 omapfb_get_caps(fbdev, plane, &caps);
1305 size += snprintf(&buf[size], PAGE_SIZE - size,
1306 "plane#%d:\n", plane);
1307 for (i = 0; i < ARRAY_SIZE(ctrl_caps) &&
1308 size < PAGE_SIZE; i++) {
1309 if (ctrl_caps[i].flag & caps.ctrl)
1310 size += snprintf(&buf[size], PAGE_SIZE - size,
1311 " %s\n", ctrl_caps[i].name);
1312 }
1313 size += snprintf(&buf[size], PAGE_SIZE - size,
1314 " plane colors:\n");
1315 for (i = 0; i < ARRAY_SIZE(color_caps) &&
1316 size < PAGE_SIZE; i++) {
1317 if (color_caps[i].flag & caps.plane_color)
1318 size += snprintf(&buf[size], PAGE_SIZE - size,
1319 " %s\n", color_caps[i].name);
1320 }
1321 size += snprintf(&buf[size], PAGE_SIZE - size,
1322 " window colors:\n");
1323 for (i = 0; i < ARRAY_SIZE(color_caps) &&
1324 size < PAGE_SIZE; i++) {
1325 if (color_caps[i].flag & caps.wnd_color)
1326 size += snprintf(&buf[size], PAGE_SIZE - size,
1327 " %s\n", color_caps[i].name);
1328 }
1329
1330 plane++;
1331 }
1332 return size;
1333 }
1334
1335 static DEVICE_ATTR(caps_num, 0444, omapfb_show_caps_num, NULL);
1336 static DEVICE_ATTR(caps_text, 0444, omapfb_show_caps_text, NULL);
1337
1338 /* panel sysfs entries */
1339 static ssize_t omapfb_show_panel_name(struct device *dev,
1340 struct device_attribute *attr, char *buf)
1341 {
1342 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1343
1344 return snprintf(buf, PAGE_SIZE, "%s\n", fbdev->panel->name);
1345 }
1346
1347 static ssize_t omapfb_show_bklight_level(struct device *dev,
1348 struct device_attribute *attr,
1349 char *buf)
1350 {
1351 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1352 int r;
1353
1354 if (fbdev->panel->get_bklight_level) {
1355 r = snprintf(buf, PAGE_SIZE, "%d\n",
1356 fbdev->panel->get_bklight_level(fbdev->panel));
1357 } else
1358 r = -ENODEV;
1359 return r;
1360 }
1361
1362 static ssize_t omapfb_store_bklight_level(struct device *dev,
1363 struct device_attribute *attr,
1364 const char *buf, size_t size)
1365 {
1366 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1367 int r;
1368
1369 if (fbdev->panel->set_bklight_level) {
1370 unsigned int level;
1371
1372 if (sscanf(buf, "%10d", &level) == 1) {
1373 r = fbdev->panel->set_bklight_level(fbdev->panel,
1374 level);
1375 } else
1376 r = -EINVAL;
1377 } else
1378 r = -ENODEV;
1379 return r ? r : size;
1380 }
1381
1382 static ssize_t omapfb_show_bklight_max(struct device *dev,
1383 struct device_attribute *attr, char *buf)
1384 {
1385 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1386 int r;
1387
1388 if (fbdev->panel->get_bklight_level) {
1389 r = snprintf(buf, PAGE_SIZE, "%d\n",
1390 fbdev->panel->get_bklight_max(fbdev->panel));
1391 } else
1392 r = -ENODEV;
1393 return r;
1394 }
1395
1396 static struct device_attribute dev_attr_panel_name =
1397 __ATTR(name, 0444, omapfb_show_panel_name, NULL);
1398 static DEVICE_ATTR(backlight_level, 0664,
1399 omapfb_show_bklight_level, omapfb_store_bklight_level);
1400 static DEVICE_ATTR(backlight_max, 0444, omapfb_show_bklight_max, NULL);
1401
1402 static struct attribute *panel_attrs[] = {
1403 &dev_attr_panel_name.attr,
1404 &dev_attr_backlight_level.attr,
1405 &dev_attr_backlight_max.attr,
1406 NULL,
1407 };
1408
1409 static struct attribute_group panel_attr_grp = {
1410 .name = "panel",
1411 .attrs = panel_attrs,
1412 };
1413
1414 /* ctrl sysfs entries */
1415 static ssize_t omapfb_show_ctrl_name(struct device *dev,
1416 struct device_attribute *attr, char *buf)
1417 {
1418 struct omapfb_device *fbdev = dev_get_drvdata(dev);
1419
1420 return snprintf(buf, PAGE_SIZE, "%s\n", fbdev->ctrl->name);
1421 }
1422
1423 static struct device_attribute dev_attr_ctrl_name =
1424 __ATTR(name, 0444, omapfb_show_ctrl_name, NULL);
1425
1426 static struct attribute *ctrl_attrs[] = {
1427 &dev_attr_ctrl_name.attr,
1428 NULL,
1429 };
1430
1431 static struct attribute_group ctrl_attr_grp = {
1432 .name = "ctrl",
1433 .attrs = ctrl_attrs,
1434 };
1435
1436 static int omapfb_register_sysfs(struct omapfb_device *fbdev)
1437 {
1438 int r;
1439
1440 if ((r = device_create_file(fbdev->dev, &dev_attr_caps_num)))
1441 goto fail0;
1442
1443 if ((r = device_create_file(fbdev->dev, &dev_attr_caps_text)))
1444 goto fail1;
1445
1446 if ((r = sysfs_create_group(&fbdev->dev->kobj, &panel_attr_grp)))
1447 goto fail2;
1448
1449 if ((r = sysfs_create_group(&fbdev->dev->kobj, &ctrl_attr_grp)))
1450 goto fail3;
1451
1452 return 0;
1453 fail3:
1454 sysfs_remove_group(&fbdev->dev->kobj, &panel_attr_grp);
1455 fail2:
1456 device_remove_file(fbdev->dev, &dev_attr_caps_text);
1457 fail1:
1458 device_remove_file(fbdev->dev, &dev_attr_caps_num);
1459 fail0:
1460 dev_err(fbdev->dev, "unable to register sysfs interface\n");
1461 return r;
1462 }
1463
1464 static void omapfb_unregister_sysfs(struct omapfb_device *fbdev)
1465 {
1466 sysfs_remove_group(&fbdev->dev->kobj, &ctrl_attr_grp);
1467 sysfs_remove_group(&fbdev->dev->kobj, &panel_attr_grp);
1468 device_remove_file(fbdev->dev, &dev_attr_caps_num);
1469 device_remove_file(fbdev->dev, &dev_attr_caps_text);
1470 }
1471
1472 /*
1473 * ---------------------------------------------------------------------------
1474 * LDM callbacks
1475 * ---------------------------------------------------------------------------
1476 */
1477 /* Initialize system fb_info object and set the default video mode.
1478 * The frame buffer memory already allocated by lcddma_init
1479 */
1480 static int fbinfo_init(struct omapfb_device *fbdev, struct fb_info *info)
1481 {
1482 struct fb_var_screeninfo *var = &info->var;
1483 struct fb_fix_screeninfo *fix = &info->fix;
1484 int r = 0;
1485
1486 info->fbops = &omapfb_ops;
1487 info->flags = FBINFO_FLAG_DEFAULT;
1488
1489 strncpy(fix->id, MODULE_NAME, sizeof(fix->id));
1490
1491 info->pseudo_palette = fbdev->pseudo_palette;
1492
1493 var->accel_flags = def_accel ? FB_ACCELF_TEXT : 0;
1494 var->xres = def_vxres;
1495 var->yres = def_vyres;
1496 var->xres_virtual = def_vxres;
1497 var->yres_virtual = def_vyres;
1498 var->rotate = def_rotate;
1499 var->bits_per_pixel = fbdev->panel->bpp;
1500
1501 set_fb_var(info, var);
1502 set_fb_fix(info, 1);
1503
1504 r = fb_alloc_cmap(&info->cmap, 16, 0);
1505 if (r != 0)
1506 dev_err(fbdev->dev, "unable to allocate color map memory\n");
1507
1508 return r;
1509 }
1510
1511 /* Release the fb_info object */
1512 static void fbinfo_cleanup(struct omapfb_device *fbdev, struct fb_info *fbi)
1513 {
1514 fb_dealloc_cmap(&fbi->cmap);
1515 }
1516
1517 static void planes_cleanup(struct omapfb_device *fbdev)
1518 {
1519 int i;
1520
1521 for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
1522 if (fbdev->fb_info[i] == NULL)
1523 break;
1524 fbinfo_cleanup(fbdev, fbdev->fb_info[i]);
1525 framebuffer_release(fbdev->fb_info[i]);
1526 }
1527 }
1528
1529 static int planes_init(struct omapfb_device *fbdev)
1530 {
1531 struct fb_info *fbi;
1532 int i;
1533 int r;
1534
1535 for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
1536 struct omapfb_plane_struct *plane;
1537 fbi = framebuffer_alloc(sizeof(struct omapfb_plane_struct),
1538 fbdev->dev);
1539 if (fbi == NULL) {
1540 dev_err(fbdev->dev,
1541 "unable to allocate memory for plane info\n");
1542 planes_cleanup(fbdev);
1543 return -ENOMEM;
1544 }
1545 plane = fbi->par;
1546 plane->idx = i;
1547 plane->fbdev = fbdev;
1548 plane->info.mirror = def_mirror;
1549 fbdev->fb_info[i] = fbi;
1550
1551 if ((r = fbinfo_init(fbdev, fbi)) < 0) {
1552 framebuffer_release(fbi);
1553 planes_cleanup(fbdev);
1554 return r;
1555 }
1556 plane->info.out_width = fbi->var.xres;
1557 plane->info.out_height = fbi->var.yres;
1558 }
1559 return 0;
1560 }
1561
1562 /*
1563 * Free driver resources. Can be called to rollback an aborted initialization
1564 * sequence.
1565 */
1566 static void omapfb_free_resources(struct omapfb_device *fbdev, int state)
1567 {
1568 int i;
1569
1570 switch (state) {
1571 case OMAPFB_ACTIVE:
1572 for (i = 0; i < fbdev->mem_desc.region_cnt; i++)
1573 unregister_framebuffer(fbdev->fb_info[i]);
1574 case 7:
1575 omapfb_unregister_sysfs(fbdev);
1576 case 6:
1577 fbdev->panel->disable(fbdev->panel);
1578 case 5:
1579 omapfb_set_update_mode(fbdev, OMAPFB_UPDATE_DISABLED);
1580 case 4:
1581 planes_cleanup(fbdev);
1582 case 3:
1583 ctrl_cleanup(fbdev);
1584 case 2:
1585 fbdev->panel->cleanup(fbdev->panel);
1586 case 1:
1587 dev_set_drvdata(fbdev->dev, NULL);
1588 kfree(fbdev);
1589 case 0:
1590 /* nothing to free */
1591 break;
1592 default:
1593 BUG();
1594 }
1595 }
1596
1597 static int omapfb_find_ctrl(struct omapfb_device *fbdev)
1598 {
1599 struct omapfb_platform_data *conf;
1600 char name[17];
1601 int i;
1602
1603 conf = fbdev->dev->platform_data;
1604
1605 fbdev->ctrl = NULL;
1606
1607 strncpy(name, conf->lcd.ctrl_name, sizeof(name) - 1);
1608 name[sizeof(name) - 1] = '\0';
1609
1610 if (strcmp(name, "internal") == 0) {
1611 fbdev->ctrl = fbdev->int_ctrl;
1612 return 0;
1613 }
1614
1615 for (i = 0; i < ARRAY_SIZE(ctrls); i++) {
1616 dev_dbg(fbdev->dev, "ctrl %s\n", ctrls[i]->name);
1617 if (strcmp(ctrls[i]->name, name) == 0) {
1618 fbdev->ctrl = ctrls[i];
1619 break;
1620 }
1621 }
1622
1623 if (fbdev->ctrl == NULL) {
1624 dev_dbg(fbdev->dev, "ctrl %s not supported\n", name);
1625 return -1;
1626 }
1627
1628 return 0;
1629 }
1630
1631 static void check_required_callbacks(struct omapfb_device *fbdev)
1632 {
1633 #define _C(x) (fbdev->ctrl->x != NULL)
1634 #define _P(x) (fbdev->panel->x != NULL)
1635 BUG_ON(fbdev->ctrl == NULL || fbdev->panel == NULL);
1636 BUG_ON(!(_C(init) && _C(cleanup) && _C(get_caps) &&
1637 _C(set_update_mode) && _C(setup_plane) && _C(enable_plane) &&
1638 _P(init) && _P(cleanup) && _P(enable) && _P(disable) &&
1639 _P(get_caps)));
1640 #undef _P
1641 #undef _C
1642 }
1643
1644 /*
1645 * Called by LDM binding to probe and attach a new device.
1646 * Initialization sequence:
1647 * 1. allocate system omapfb_device structure
1648 * 2. select controller type according to platform configuration
1649 * init LCD panel
1650 * 3. init LCD controller and LCD DMA
1651 * 4. init system fb_info structure for all planes
1652 * 5. setup video mode for first plane and enable it
1653 * 6. enable LCD panel
1654 * 7. register sysfs attributes
1655 * OMAPFB_ACTIVE: register system fb_info structure for all planes
1656 */
1657 static int omapfb_do_probe(struct platform_device *pdev,
1658 struct lcd_panel *panel)
1659 {
1660 struct omapfb_device *fbdev = NULL;
1661 int init_state;
1662 unsigned long phz, hhz, vhz;
1663 unsigned long vram;
1664 int i;
1665 int r = 0;
1666
1667 init_state = 0;
1668
1669 if (pdev->num_resources != 0) {
1670 dev_err(&pdev->dev, "probed for an unknown device\n");
1671 r = -ENODEV;
1672 goto cleanup;
1673 }
1674
1675 if (pdev->dev.platform_data == NULL) {
1676 dev_err(&pdev->dev, "missing platform data\n");
1677 r = -ENOENT;
1678 goto cleanup;
1679 }
1680
1681 fbdev = kzalloc(sizeof(struct omapfb_device), GFP_KERNEL);
1682 if (fbdev == NULL) {
1683 dev_err(&pdev->dev,
1684 "unable to allocate memory for device info\n");
1685 r = -ENOMEM;
1686 goto cleanup;
1687 }
1688 init_state++;
1689
1690 fbdev->dev = &pdev->dev;
1691 fbdev->panel = panel;
1692 fbdev->dssdev = &omapdss_device;
1693 platform_set_drvdata(pdev, fbdev);
1694
1695 mutex_init(&fbdev->rqueue_mutex);
1696
1697 fbdev->int_ctrl = &omap1_int_ctrl;
1698 #ifdef CONFIG_FB_OMAP_LCDC_EXTERNAL
1699 fbdev->ext_if = &omap1_ext_if;
1700 #endif
1701 if (omapfb_find_ctrl(fbdev) < 0) {
1702 dev_err(fbdev->dev,
1703 "LCD controller not found, board not supported\n");
1704 r = -ENODEV;
1705 goto cleanup;
1706 }
1707
1708 r = fbdev->panel->init(fbdev->panel, fbdev);
1709 if (r)
1710 goto cleanup;
1711
1712 pr_info("omapfb: configured for panel %s\n", fbdev->panel->name);
1713
1714 def_vxres = def_vxres ? def_vxres : fbdev->panel->x_res;
1715 def_vyres = def_vyres ? def_vyres : fbdev->panel->y_res;
1716
1717 init_state++;
1718
1719 r = ctrl_init(fbdev);
1720 if (r)
1721 goto cleanup;
1722 if (fbdev->ctrl->mmap != NULL)
1723 omapfb_ops.fb_mmap = omapfb_mmap;
1724 init_state++;
1725
1726 check_required_callbacks(fbdev);
1727
1728 r = planes_init(fbdev);
1729 if (r)
1730 goto cleanup;
1731 init_state++;
1732
1733 #ifdef CONFIG_FB_OMAP_DMA_TUNE
1734 /* Set DMA priority for EMIFF access to highest */
1735 omap_set_dma_priority(0, OMAP_DMA_PORT_EMIFF, 15);
1736 #endif
1737
1738 r = ctrl_change_mode(fbdev->fb_info[0]);
1739 if (r) {
1740 dev_err(fbdev->dev, "mode setting failed\n");
1741 goto cleanup;
1742 }
1743
1744 /* GFX plane is enabled by default */
1745 r = fbdev->ctrl->enable_plane(OMAPFB_PLANE_GFX, 1);
1746 if (r)
1747 goto cleanup;
1748
1749 omapfb_set_update_mode(fbdev, manual_update ?
1750 OMAPFB_MANUAL_UPDATE : OMAPFB_AUTO_UPDATE);
1751 init_state++;
1752
1753 r = fbdev->panel->enable(fbdev->panel);
1754 if (r)
1755 goto cleanup;
1756 init_state++;
1757
1758 r = omapfb_register_sysfs(fbdev);
1759 if (r)
1760 goto cleanup;
1761 init_state++;
1762
1763 vram = 0;
1764 for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
1765 r = register_framebuffer(fbdev->fb_info[i]);
1766 if (r != 0) {
1767 dev_err(fbdev->dev,
1768 "registering framebuffer %d failed\n", i);
1769 goto cleanup;
1770 }
1771 vram += fbdev->mem_desc.region[i].size;
1772 }
1773
1774 fbdev->state = OMAPFB_ACTIVE;
1775
1776 panel = fbdev->panel;
1777 phz = panel->pixel_clock * 1000;
1778 hhz = phz * 10 / (panel->hfp + panel->x_res + panel->hbp + panel->hsw);
1779 vhz = hhz / (panel->vfp + panel->y_res + panel->vbp + panel->vsw);
1780
1781 omapfb_dev = fbdev;
1782
1783 pr_info("omapfb: Framebuffer initialized. Total vram %lu planes %d\n",
1784 vram, fbdev->mem_desc.region_cnt);
1785 pr_info("omapfb: Pixclock %lu kHz hfreq %lu.%lu kHz "
1786 "vfreq %lu.%lu Hz\n",
1787 phz / 1000, hhz / 10000, hhz % 10, vhz / 10, vhz % 10);
1788
1789 return 0;
1790
1791 cleanup:
1792 omapfb_free_resources(fbdev, init_state);
1793
1794 return r;
1795 }
1796
1797 static int omapfb_probe(struct platform_device *pdev)
1798 {
1799 int r;
1800
1801 BUG_ON(fbdev_pdev != NULL);
1802
1803 r = platform_device_register(&omapdss_device);
1804 if (r) {
1805 dev_err(&pdev->dev, "can't register omapdss device\n");
1806 return r;
1807 }
1808
1809 /* Delay actual initialization until the LCD is registered */
1810 fbdev_pdev = pdev;
1811 if (fbdev_panel != NULL)
1812 omapfb_do_probe(fbdev_pdev, fbdev_panel);
1813 return 0;
1814 }
1815
1816 void omapfb_register_panel(struct lcd_panel *panel)
1817 {
1818 BUG_ON(fbdev_panel != NULL);
1819
1820 fbdev_panel = panel;
1821 if (fbdev_pdev != NULL)
1822 omapfb_do_probe(fbdev_pdev, fbdev_panel);
1823 }
1824
1825 /* Called when the device is being detached from the driver */
1826 static int omapfb_remove(struct platform_device *pdev)
1827 {
1828 struct omapfb_device *fbdev = platform_get_drvdata(pdev);
1829 enum omapfb_state saved_state = fbdev->state;
1830
1831 /* FIXME: wait till completion of pending events */
1832
1833 fbdev->state = OMAPFB_DISABLED;
1834 omapfb_free_resources(fbdev, saved_state);
1835
1836 platform_device_unregister(&omapdss_device);
1837 fbdev->dssdev = NULL;
1838
1839 return 0;
1840 }
1841
1842 /* PM suspend */
1843 static int omapfb_suspend(struct platform_device *pdev, pm_message_t mesg)
1844 {
1845 struct omapfb_device *fbdev = platform_get_drvdata(pdev);
1846
1847 if (fbdev != NULL)
1848 omapfb_blank(FB_BLANK_POWERDOWN, fbdev->fb_info[0]);
1849 return 0;
1850 }
1851
1852 /* PM resume */
1853 static int omapfb_resume(struct platform_device *pdev)
1854 {
1855 struct omapfb_device *fbdev = platform_get_drvdata(pdev);
1856
1857 if (fbdev != NULL)
1858 omapfb_blank(FB_BLANK_UNBLANK, fbdev->fb_info[0]);
1859 return 0;
1860 }
1861
1862 static struct platform_driver omapfb_driver = {
1863 .probe = omapfb_probe,
1864 .remove = omapfb_remove,
1865 .suspend = omapfb_suspend,
1866 .resume = omapfb_resume,
1867 .driver = {
1868 .name = MODULE_NAME,
1869 .owner = THIS_MODULE,
1870 },
1871 };
1872
1873 #ifndef MODULE
1874
1875 /* Process kernel command line parameters */
1876 static int __init omapfb_setup(char *options)
1877 {
1878 char *this_opt = NULL;
1879 int r = 0;
1880
1881 pr_debug("omapfb: options %s\n", options);
1882
1883 if (!options || !*options)
1884 return 0;
1885
1886 while (!r && (this_opt = strsep(&options, ",")) != NULL) {
1887 if (!strncmp(this_opt, "accel", 5))
1888 def_accel = 1;
1889 else if (!strncmp(this_opt, "vram:", 5)) {
1890 char *suffix;
1891 unsigned long vram;
1892 vram = (simple_strtoul(this_opt + 5, &suffix, 0));
1893 switch (suffix[0]) {
1894 case '\0':
1895 break;
1896 case 'm':
1897 case 'M':
1898 vram *= 1024;
1899 /* Fall through */
1900 case 'k':
1901 case 'K':
1902 vram *= 1024;
1903 break;
1904 default:
1905 pr_debug("omapfb: invalid vram suffix %c\n",
1906 suffix[0]);
1907 r = -1;
1908 }
1909 def_vram[def_vram_cnt++] = vram;
1910 }
1911 else if (!strncmp(this_opt, "vxres:", 6))
1912 def_vxres = simple_strtoul(this_opt + 6, NULL, 0);
1913 else if (!strncmp(this_opt, "vyres:", 6))
1914 def_vyres = simple_strtoul(this_opt + 6, NULL, 0);
1915 else if (!strncmp(this_opt, "rotate:", 7))
1916 def_rotate = (simple_strtoul(this_opt + 7, NULL, 0));
1917 else if (!strncmp(this_opt, "mirror:", 7))
1918 def_mirror = (simple_strtoul(this_opt + 7, NULL, 0));
1919 else if (!strncmp(this_opt, "manual_update", 13))
1920 manual_update = 1;
1921 else {
1922 pr_debug("omapfb: invalid option\n");
1923 r = -1;
1924 }
1925 }
1926
1927 return r;
1928 }
1929
1930 #endif
1931
1932 /* Register both the driver and the device */
1933 static int __init omapfb_init(void)
1934 {
1935 #ifndef MODULE
1936 char *option;
1937
1938 if (fb_get_options("omapfb", &option))
1939 return -ENODEV;
1940 omapfb_setup(option);
1941 #endif
1942 /* Register the driver with LDM */
1943 if (platform_driver_register(&omapfb_driver)) {
1944 pr_debug("failed to register omapfb driver\n");
1945 return -ENODEV;
1946 }
1947
1948 return 0;
1949 }
1950
1951 static void __exit omapfb_cleanup(void)
1952 {
1953 platform_driver_unregister(&omapfb_driver);
1954 }
1955
1956 module_param_named(accel, def_accel, uint, 0664);
1957 module_param_array_named(vram, def_vram, ulong, &def_vram_cnt, 0664);
1958 module_param_named(vxres, def_vxres, long, 0664);
1959 module_param_named(vyres, def_vyres, long, 0664);
1960 module_param_named(rotate, def_rotate, uint, 0664);
1961 module_param_named(mirror, def_mirror, uint, 0664);
1962 module_param_named(manual_update, manual_update, bool, 0664);
1963
1964 module_init(omapfb_init);
1965 module_exit(omapfb_cleanup);
1966
1967 MODULE_DESCRIPTION("TI OMAP framebuffer driver");
1968 MODULE_AUTHOR("Imre Deak <imre.deak@nokia.com>");
1969 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree