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