drivers/video/fbdev/omap/omapfb_main.c

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