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 #include <linux/sysfs.h>
  20
  21 #include <linux/omap-dma.h>
  22
  23 #include <linux/soc/ti/omap1-soc.h>
  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;
 548                 var->red.length         = 4;
 549                 var->red.msb_right      = 0;
 550                 var->green.offset       = 4;
 551                 var->green.length       = 4;
 552                 var->green.msb_right    = 0;
 553                 var->blue.offset        = 0;
 554                 var->blue.length        = 4;
 555                 var->blue.msb_right     = 0;
 556         } else {
 557                 var->red.offset         = 11;
 558                 var->red.length         = 5;
 559                 var->red.msb_right      = 0;
 560                 var->green.offset       = 5;
 561                 var->green.length       = 6;
 562                 var->green.msb_right    = 0;
 563                 var->blue.offset        = 0;
 564                 var->blue.length        = 5;
 565                 var->blue.msb_right     = 0;
 566         }
 567
 568         var->height             = -1;
 569         var->width              = -1;
 570         var->grayscale          = 0;
 571
 572         /* pixclock in ps, the rest in pixclock */
 573         var->pixclock           = 10000000 / (panel->pixel_clock / 100);
 574         var->left_margin        = panel->hfp;
 575         var->right_margin       = panel->hbp;
 576         var->upper_margin       = panel->vfp;
 577         var->lower_margin       = panel->vbp;
 578         var->hsync_len          = panel->hsw;
 579         var->vsync_len          = panel->vsw;
 580
 581         /* TODO: get these from panel->config */
 582         var->vmode              = FB_VMODE_NONINTERLACED;
 583         var->sync               = 0;
 584
 585         return 0;
 586 }
 587
 588
 589 /*
 590  * Set new x,y offsets in the virtual display for the visible area and switch
 591  * to the new mode.
 592  */
 593 static int omapfb_pan_display(struct fb_var_screeninfo *var,
 594                                struct fb_info *fbi)
 595 {
 596         struct omapfb_plane_struct *plane = fbi->par;
 597         struct omapfb_device *fbdev = plane->fbdev;
 598         int r = 0;
 599
 600         omapfb_rqueue_lock(fbdev);
 601         if (var->xoffset != fbi->var.xoffset ||
 602             var->yoffset != fbi->var.yoffset) {
 603                 struct fb_var_screeninfo *new_var = &fbdev->new_var;
 604
 605                 memcpy(new_var, &fbi->var, sizeof(*new_var));
 606                 new_var->xoffset = var->xoffset;
 607                 new_var->yoffset = var->yoffset;
 608                 if (set_fb_var(fbi, new_var))
 609                         r = -EINVAL;
 610                 else {
 611                         memcpy(&fbi->var, new_var, sizeof(*new_var));
 612                         ctrl_change_mode(fbi);
 613                 }
 614         }
 615         omapfb_rqueue_unlock(fbdev);
 616
 617         return r;
 618 }
 619
 620 /* Set mirror to vertical axis and switch to the new mode. */
 621 static int omapfb_mirror(struct fb_info *fbi, int mirror)
 622 {
 623         struct omapfb_plane_struct *plane = fbi->par;
 624         struct omapfb_device *fbdev = plane->fbdev;
 625         int r = 0;
 626
 627         omapfb_rqueue_lock(fbdev);
 628         mirror = mirror ? 1 : 0;
 629         if (cpu_is_omap15xx())
 630                 r = -EINVAL;
 631         else if (mirror != plane->info.mirror) {
 632                 plane->info.mirror = mirror;
 633                 r = ctrl_change_mode(fbi);
 634         }
 635         omapfb_rqueue_unlock(fbdev);
 636
 637         return r;
 638 }
 639
 640 /*
 641  * Check values in var, try to adjust them in case of out of bound values if
 642  * possible, or return error.
 643  */
 644 static int omapfb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
 645 {
 646         struct omapfb_plane_struct *plane = fbi->par;
 647         struct omapfb_device *fbdev = plane->fbdev;
 648         int r;
 649
 650         omapfb_rqueue_lock(fbdev);
 651         if (fbdev->ctrl->sync != NULL)
 652                 fbdev->ctrl->sync();
 653         r = set_fb_var(fbi, var);
 654         omapfb_rqueue_unlock(fbdev);
 655
 656         return r;
 657 }
 658
 659 /*
 660  * Switch to a new mode. The parameters for it has been check already by
 661  * omapfb_check_var.
 662  */
 663 static int omapfb_set_par(struct fb_info *fbi)
 664 {
 665         struct omapfb_plane_struct *plane = fbi->par;
 666         struct omapfb_device *fbdev = plane->fbdev;
 667         int r = 0;
 668
 669         omapfb_rqueue_lock(fbdev);
 670         set_fb_fix(fbi, 0);
 671         r = ctrl_change_mode(fbi);
 672         omapfb_rqueue_unlock(fbdev);
 673
 674         return r;
 675 }
 676
 677 static int omapfb_update_window_async(struct fb_info *fbi,
 678                                 struct omapfb_update_window *win,
 679                                 void (*callback)(void *),
 680                                 void *callback_data)
 681 {
 682         int xres, yres;
 683         struct omapfb_plane_struct *plane = fbi->par;
 684         struct omapfb_device *fbdev = plane->fbdev;
 685         struct fb_var_screeninfo *var = &fbi->var;
 686
 687         switch (var->rotate) {
 688         case 0:
 689         case 180:
 690                 xres = fbdev->panel->x_res;
 691                 yres = fbdev->panel->y_res;
 692                 break;
 693         case 90:
 694         case 270:
 695                 xres = fbdev->panel->y_res;
 696                 yres = fbdev->panel->x_res;
 697                 break;
 698         default:
 699                 return -EINVAL;
 700         }
 701
 702         if (win->x >= xres || win->y >= yres ||
 703             win->out_x > xres || win->out_y > yres)
 704                 return -EINVAL;
 705
 706         if (!fbdev->ctrl->update_window ||
 707             fbdev->ctrl->get_update_mode() != OMAPFB_MANUAL_UPDATE)
 708                 return -ENODEV;
 709
 710         if (win->x + win->width > xres)
 711                 win->width = xres - win->x;
 712         if (win->y + win->height > yres)
 713                 win->height = yres - win->y;
 714         if (win->out_x + win->out_width > xres)
 715                 win->out_width = xres - win->out_x;
 716         if (win->out_y + win->out_height > yres)
 717                 win->out_height = yres - win->out_y;
 718         if (!win->width || !win->height || !win->out_width || !win->out_height)
 719                 return 0;
 720
 721         return fbdev->ctrl->update_window(fbi, win, callback, callback_data);
 722 }
 723
 724 static int omapfb_update_win(struct fb_info *fbi,
 725                                 struct omapfb_update_window *win)
 726 {
 727         struct omapfb_plane_struct *plane = fbi->par;
 728         int ret;
 729
 730         omapfb_rqueue_lock(plane->fbdev);
 731         ret = omapfb_update_window_async(fbi, win, NULL, NULL);
 732         omapfb_rqueue_unlock(plane->fbdev);
 733
 734         return ret;
 735 }
 736
 737 static int omapfb_update_full_screen(struct fb_info *fbi)
 738 {
 739         struct omapfb_plane_struct *plane = fbi->par;
 740         struct omapfb_device *fbdev = plane->fbdev;
 741         struct omapfb_update_window win;
 742         int r;
 743
 744         if (!fbdev->ctrl->update_window ||
 745             fbdev->ctrl->get_update_mode() != OMAPFB_MANUAL_UPDATE)
 746                 return -ENODEV;
 747
 748         win.x = 0;
 749         win.y = 0;
 750         win.width = fbi->var.xres;
 751         win.height = fbi->var.yres;
 752         win.out_x = 0;
 753         win.out_y = 0;
 754         win.out_width = fbi->var.xres;
 755         win.out_height = fbi->var.yres;
 756         win.format = 0;
 757
 758         omapfb_rqueue_lock(fbdev);
 759         r = fbdev->ctrl->update_window(fbi, &win, NULL, NULL);
 760         omapfb_rqueue_unlock(fbdev);
 761
 762         return r;
 763 }
 764
 765 static int omapfb_setup_plane(struct fb_info *fbi, struct omapfb_plane_info *pi)
 766 {
 767         struct omapfb_plane_struct *plane = fbi->par;
 768         struct omapfb_device *fbdev = plane->fbdev;
 769         struct lcd_panel *panel = fbdev->panel;
 770         struct omapfb_plane_info old_info;
 771         int r = 0;
 772
 773         if (pi->pos_x + pi->out_width > panel->x_res ||
 774             pi->pos_y + pi->out_height > panel->y_res)
 775                 return -EINVAL;
 776
 777         omapfb_rqueue_lock(fbdev);
 778         if (pi->enabled && !fbdev->mem_desc.region[plane->idx].size) {
 779                 /*
 780                  * This plane's memory was freed, can't enable it
 781                  * until it's reallocated.
 782                  */
 783                 r = -EINVAL;
 784                 goto out;
 785         }
 786         old_info = plane->info;
 787         plane->info = *pi;
 788         if (pi->enabled) {
 789                 r = ctrl_change_mode(fbi);
 790                 if (r < 0) {
 791                         plane->info = old_info;
 792                         goto out;
 793                 }
 794         }
 795         r = fbdev->ctrl->enable_plane(plane->idx, pi->enabled);
 796         if (r < 0) {
 797                 plane->info = old_info;
 798                 goto out;
 799         }
 800 out:
 801         omapfb_rqueue_unlock(fbdev);
 802         return r;
 803 }
 804
 805 static int omapfb_query_plane(struct fb_info *fbi, struct omapfb_plane_info *pi)
 806 {
 807         struct omapfb_plane_struct *plane = fbi->par;
 808
 809         *pi = plane->info;
 810         return 0;
 811 }
 812
 813 static int omapfb_setup_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
 814 {
 815         struct omapfb_plane_struct *plane = fbi->par;
 816         struct omapfb_device *fbdev = plane->fbdev;
 817         struct omapfb_mem_region *rg = &fbdev->mem_desc.region[plane->idx];
 818         size_t size;
 819         int r = 0;
 820
 821         if (fbdev->ctrl->setup_mem == NULL)
 822                 return -ENODEV;
 823         if (mi->type != OMAPFB_MEMTYPE_SDRAM)
 824                 return -EINVAL;
 825
 826         size = PAGE_ALIGN(mi->size);
 827         omapfb_rqueue_lock(fbdev);
 828         if (plane->info.enabled) {
 829                 r = -EBUSY;
 830                 goto out;
 831         }
 832         if (rg->size != size || rg->type != mi->type) {
 833                 struct fb_var_screeninfo *new_var = &fbdev->new_var;
 834                 unsigned long old_size = rg->size;
 835                 u8            old_type = rg->type;
 836                 unsigned long paddr;
 837
 838                 rg->size = size;
 839                 rg->type = mi->type;
 840                 /*
 841                  * size == 0 is a special case, for which we
 842                  * don't check / adjust the screen parameters.
 843                  * This isn't a problem since the plane can't
 844                  * be reenabled unless its size is > 0.
 845                  */
 846                 if (old_size != size && size) {
 847                         if (size) {
 848                                 memcpy(new_var, &fbi->var, sizeof(*new_var));
 849                                 r = set_fb_var(fbi, new_var);
 850                                 if (r < 0)
 851                                         goto out;
 852                         }
 853                 }
 854
 855                 if (fbdev->ctrl->sync)
 856                         fbdev->ctrl->sync();
 857                 r = fbdev->ctrl->setup_mem(plane->idx, size, mi->type, &paddr);
 858                 if (r < 0) {
 859                         /* Revert changes. */
 860                         rg->size = old_size;
 861                         rg->type = old_type;
 862                         goto out;
 863                 }
 864                 rg->paddr = paddr;
 865
 866                 if (old_size != size) {
 867                         if (size) {
 868                                 memcpy(&fbi->var, new_var, sizeof(fbi->var));
 869                                 set_fb_fix(fbi, 0);
 870                         } else {
 871                                 /*
 872                                  * Set these explicitly to indicate that the
 873                                  * plane memory is dealloce'd, the other
 874                                  * screen parameters in var / fix are invalid.
 875                                  */
 876                                 mutex_lock(&fbi->mm_lock);
 877                                 fbi->fix.smem_start = 0;
 878                                 fbi->fix.smem_len = 0;
 879                                 mutex_unlock(&fbi->mm_lock);
 880                         }
 881                 }
 882         }
 883 out:
 884         omapfb_rqueue_unlock(fbdev);
 885
 886         return r;
 887 }
 888
 889 static int omapfb_query_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
 890 {
 891         struct omapfb_plane_struct *plane = fbi->par;
 892         struct omapfb_device *fbdev = plane->fbdev;
 893         struct omapfb_mem_region *rg;
 894
 895         rg = &fbdev->mem_desc.region[plane->idx];
 896         memset(mi, 0, sizeof(*mi));
 897         mi->size = rg->size;
 898         mi->type = rg->type;
 899
 900         return 0;
 901 }
 902
 903 static int omapfb_set_color_key(struct omapfb_device *fbdev,
 904                                 struct omapfb_color_key *ck)
 905 {
 906         int r;
 907
 908         if (!fbdev->ctrl->set_color_key)
 909                 return -ENODEV;
 910
 911         omapfb_rqueue_lock(fbdev);
 912         r = fbdev->ctrl->set_color_key(ck);
 913         omapfb_rqueue_unlock(fbdev);
 914
 915         return r;
 916 }
 917
 918 static int omapfb_get_color_key(struct omapfb_device *fbdev,
 919                                 struct omapfb_color_key *ck)
 920 {
 921         int r;
 922
 923         if (!fbdev->ctrl->get_color_key)
 924                 return -ENODEV;
 925
 926         omapfb_rqueue_lock(fbdev);
 927         r = fbdev->ctrl->get_color_key(ck);
 928         omapfb_rqueue_unlock(fbdev);
 929
 930         return r;
 931 }
 932
 933 static struct blocking_notifier_head omapfb_client_list[OMAPFB_PLANE_NUM];
 934 static int notifier_inited;
 935
 936 static void omapfb_init_notifier(void)
 937 {
 938         int i;
 939
 940         for (i = 0; i < OMAPFB_PLANE_NUM; i++)
 941                 BLOCKING_INIT_NOTIFIER_HEAD(&omapfb_client_list[i]);
 942 }
 943
 944 int omapfb_register_client(struct omapfb_notifier_block *omapfb_nb,
 945                                 omapfb_notifier_callback_t callback,
 946                                 void *callback_data)
 947 {
 948         int r;
 949
 950         if ((unsigned)omapfb_nb->plane_idx >= OMAPFB_PLANE_NUM)
 951                 return -EINVAL;
 952
 953         if (!notifier_inited) {
 954                 omapfb_init_notifier();
 955                 notifier_inited = 1;
 956         }
 957
 958         omapfb_nb->nb.notifier_call = (int (*)(struct notifier_block *,
 959                                         unsigned long, void *))callback;
 960         omapfb_nb->data = callback_data;
 961         r = blocking_notifier_chain_register(
 962                                 &omapfb_client_list[omapfb_nb->plane_idx],
 963                                 &omapfb_nb->nb);
 964         if (r)
 965                 return r;
 966         if (omapfb_dev != NULL &&
 967             omapfb_dev->ctrl && omapfb_dev->ctrl->bind_client) {
 968                 omapfb_dev->ctrl->bind_client(omapfb_nb);
 969         }
 970
 971         return 0;
 972 }
 973 EXPORT_SYMBOL(omapfb_register_client);
 974
 975 int omapfb_unregister_client(struct omapfb_notifier_block *omapfb_nb)
 976 {
 977         return blocking_notifier_chain_unregister(
 978                 &omapfb_client_list[omapfb_nb->plane_idx], &omapfb_nb->nb);
 979 }
 980 EXPORT_SYMBOL(omapfb_unregister_client);
 981
 982 void omapfb_notify_clients(struct omapfb_device *fbdev, unsigned long event)
 983 {
 984         int i;
 985
 986         if (!notifier_inited)
 987                 /* no client registered yet */
 988                 return;
 989
 990         for (i = 0; i < OMAPFB_PLANE_NUM; i++)
 991                 blocking_notifier_call_chain(&omapfb_client_list[i], event,
 992                                     fbdev->fb_info[i]);
 993 }
 994 EXPORT_SYMBOL(omapfb_notify_clients);
 995
 996 static int omapfb_set_update_mode(struct omapfb_device *fbdev,
 997                                    enum omapfb_update_mode mode)
 998 {
 999         int r;
1000
1001         omapfb_rqueue_lock(fbdev);
1002         r = fbdev->ctrl->set_update_mode(mode);
1003         omapfb_rqueue_unlock(fbdev);
1004
1005         return r;
1006 }
1007
1008 static enum omapfb_update_mode omapfb_get_update_mode(struct omapfb_device *fbdev)
1009 {
1010         int r;
1011
1012         omapfb_rqueue_lock(fbdev);
1013         r = fbdev->ctrl->get_update_mode();
1014         omapfb_rqueue_unlock(fbdev);
1015
1016         return r;
1017 }
1018
1019 static void omapfb_get_caps(struct omapfb_device *fbdev, int plane,
1020                                      struct omapfb_caps *caps)
1021 {
1022         memset(caps, 0, sizeof(*caps));
1023         fbdev->ctrl->get_caps(plane, caps);
1024         if (fbdev->panel->get_caps)
1025                 caps->ctrl |= fbdev->panel->get_caps(fbdev->panel);
1026 }
1027
1028 /* For lcd testing */
1029 void omapfb_write_first_pixel(struct omapfb_device *fbdev, u16 pixval)
1030 {
1031         omapfb_rqueue_lock(fbdev);
1032         *(u16 *)fbdev->mem_desc.region[0].vaddr = pixval;
1033         if (fbdev->ctrl->get_update_mode() == OMAPFB_MANUAL_UPDATE) {
1034                 struct omapfb_update_window win;
1035
1036                 memset(&win, 0, sizeof(win));
1037                 win.width = 2;
1038                 win.height = 2;
1039                 win.out_width = 2;
1040                 win.out_height = 2;
1041                 fbdev->ctrl->update_window(fbdev->fb_info[0], &win, NULL, NULL);
1042         }
1043         omapfb_rqueue_unlock(fbdev);
1044 }
1045 EXPORT_SYMBOL(omapfb_write_first_pixel);
1046
1047 /*
1048  * Ioctl interface. Part of the kernel mode frame buffer API is duplicated
1049  * here to be accessible by user mode code.
1050  */
1051 static int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd,
1052                         unsigned long arg)
1053 {
1054         struct omapfb_plane_struct *plane = fbi->par;
1055         struct omapfb_device    *fbdev = plane->fbdev;
1056         const struct fb_ops *ops = fbi->fbops;
1057         union {
1058                 struct omapfb_update_window     update_window;
1059                 struct omapfb_plane_info        plane_info;
1060                 struct omapfb_mem_info          mem_info;
1061                 struct omapfb_color_key         color_key;
1062                 enum omapfb_update_mode         update_mode;
1063                 struct omapfb_caps              caps;
1064                 unsigned int            mirror;
1065                 int                     plane_out;
1066                 int                     enable_plane;
1067         } p;
1068         int r = 0;
1069
1070         BUG_ON(!ops);
1071         switch (cmd) {
1072         case OMAPFB_MIRROR:
1073                 if (get_user(p.mirror, (int __user *)arg))
1074                         r = -EFAULT;
1075                 else
1076                         omapfb_mirror(fbi, p.mirror);
1077                 break;
1078         case OMAPFB_SYNC_GFX:
1079                 omapfb_sync(fbi);
1080                 break;
1081         case OMAPFB_VSYNC:
1082                 break;
1083         case OMAPFB_SET_UPDATE_MODE:
1084                 if (get_user(p.update_mode, (int __user *)arg))
1085                         r = -EFAULT;
1086                 else
1087                         r = omapfb_set_update_mode(fbdev, p.update_mode);
1088                 break;
1089         case OMAPFB_GET_UPDATE_MODE:
1090                 p.update_mode = omapfb_get_update_mode(fbdev);
1091                 if (put_user(p.update_mode,
1092                                         (enum omapfb_update_mode __user *)arg))
1093                         r = -EFAULT;
1094                 break;
1095         case OMAPFB_UPDATE_WINDOW_OLD:
1096                 if (copy_from_user(&p.update_window, (void __user *)arg,
1097                                    sizeof(struct omapfb_update_window_old)))
1098                         r = -EFAULT;
1099                 else {
1100                         struct omapfb_update_window *u = &p.update_window;
1101                         u->out_x = u->x;
1102                         u->out_y = u->y;
1103                         u->out_width = u->width;
1104                         u->out_height = u->height;
1105                         memset(u->reserved, 0, sizeof(u->reserved));
1106                         r = omapfb_update_win(fbi, u);
1107                 }
1108                 break;
1109         case OMAPFB_UPDATE_WINDOW:
1110                 if (copy_from_user(&p.update_window, (void __user *)arg,
1111                                    sizeof(p.update_window)))
1112                         r = -EFAULT;
1113                 else
1114                         r = omapfb_update_win(fbi, &p.update_window);
1115                 break;
1116         case OMAPFB_SETUP_PLANE:
1117                 if (copy_from_user(&p.plane_info, (void __user *)arg,
1118                                    sizeof(p.plane_info)))
1119                         r = -EFAULT;
1120                 else
1121                         r = omapfb_setup_plane(fbi, &p.plane_info);
1122                 break;
1123         case OMAPFB_QUERY_PLANE:
1124                 if ((r = omapfb_query_plane(fbi, &p.plane_info)) < 0)
1125                         break;
1126                 if (copy_to_user((void __user *)arg, &p.plane_info,
1127                                    sizeof(p.plane_info)))
1128                         r = -EFAULT;
1129                 break;
1130         case OMAPFB_SETUP_MEM:
1131                 if (copy_from_user(&p.mem_info, (void __user *)arg,
1132                                    sizeof(p.mem_info)))
1133                         r = -EFAULT;
1134                 else
1135                         r = omapfb_setup_mem(fbi, &p.mem_info);
1136                 break;
1137         case OMAPFB_QUERY_MEM:
1138                 if ((r = omapfb_query_mem(fbi, &p.mem_info)) < 0)
1139                         break;
1140                 if (copy_to_user((void __user *)arg, &p.mem_info,
1141                                    sizeof(p.mem_info)))
1142                         r = -EFAULT;
1143                 break;
1144         case OMAPFB_SET_COLOR_KEY:
1145                 if (copy_from_user(&p.color_key, (void __user *)arg,
1146                                    sizeof(p.color_key)))
1147                         r = -EFAULT;
1148                 else
1149                         r = omapfb_set_color_key(fbdev, &p.color_key);
1150                 break;
1151         case OMAPFB_GET_COLOR_KEY:
1152                 if ((r = omapfb_get_color_key(fbdev, &p.color_key)) < 0)
1153                         break;
1154                 if (copy_to_user((void __user *)arg, &p.color_key,
1155                                  sizeof(p.color_key)))
1156                         r = -EFAULT;
1157                 break;
1158         case OMAPFB_GET_CAPS:
1159                 omapfb_get_caps(fbdev, plane->idx, &p.caps);
1160                 if (copy_to_user((void __user *)arg, &p.caps, sizeof(p.caps)))
1161                         r = -EFAULT;
1162                 break;
1163         case OMAPFB_LCD_TEST:
1164                 {
1165                         int test_num;
1166
1167                         if (get_user(test_num, (int __user *)arg)) {
1168                                 r = -EFAULT;
1169                                 break;
1170                         }
1171                         if (!fbdev->panel->run_test) {
1172                                 r = -EINVAL;
1173                                 break;
1174                         }
1175                         r = fbdev->panel->run_test(fbdev->panel, test_num);
1176                         break;
1177                 }
1178         case OMAPFB_CTRL_TEST:
1179                 {
1180                         int test_num;
1181
1182                         if (get_user(test_num, (int __user *)arg)) {
1183                                 r = -EFAULT;
1184                                 break;
1185                         }
1186                         if (!fbdev->ctrl->run_test) {
1187                                 r = -EINVAL;
1188                                 break;
1189                         }
1190                         r = fbdev->ctrl->run_test(test_num);
1191                         break;
1192                 }
1193         default:
1194                 r = -EINVAL;
1195         }
1196
1197         return r;
1198 }
1199
1200 static int omapfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
1201 {
1202         struct omapfb_plane_struct *plane = info->par;
1203         struct omapfb_device *fbdev = plane->fbdev;
1204         int r;
1205
1206         omapfb_rqueue_lock(fbdev);
1207         r = fbdev->ctrl->mmap(info, vma);
1208         omapfb_rqueue_unlock(fbdev);
1209
1210         return r;
1211 }
1212
1213 /*
1214  * Callback table for the frame buffer framework. Some of these pointers
1215  * will be changed according to the current setting of fb_info->accel_flags.
1216  */
1217 static struct fb_ops omapfb_ops = {
1218         .owner          = THIS_MODULE,
1219         FB_DEFAULT_IOMEM_OPS,
1220         .fb_open        = omapfb_open,
1221         .fb_release     = omapfb_release,
1222         .fb_setcolreg   = omapfb_setcolreg,
1223         .fb_setcmap     = omapfb_setcmap,
1224         .fb_blank       = omapfb_blank,
1225         .fb_ioctl       = omapfb_ioctl,
1226         .fb_check_var   = omapfb_check_var,
1227         .fb_set_par     = omapfb_set_par,
1228         .fb_pan_display = omapfb_pan_display,
1229 };
1230
1231 /*
1232  * ---------------------------------------------------------------------------
1233  * Sysfs interface
1234  * ---------------------------------------------------------------------------
1235  */
1236 /* omapfbX sysfs entries */
1237 static ssize_t omapfb_show_caps_num(struct device *dev,
1238                                     struct device_attribute *attr, char *buf)
1239 {
1240         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1241         int plane;
1242         size_t size;
1243         struct omapfb_caps caps;
1244
1245         plane = 0;
1246         size = 0;
1247         while (size < PAGE_SIZE && plane < OMAPFB_PLANE_NUM) {
1248                 omapfb_get_caps(fbdev, plane, &caps);
1249                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1250                         "plane#%d %#010x %#010x %#010x\n",
1251                         plane, caps.ctrl, caps.plane_color, caps.wnd_color);
1252                 plane++;
1253         }
1254         return size;
1255 }
1256
1257 static ssize_t omapfb_show_caps_text(struct device *dev,
1258                                      struct device_attribute *attr, char *buf)
1259 {
1260         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1261         int i;
1262         struct omapfb_caps caps;
1263         int plane;
1264         size_t size;
1265
1266         plane = 0;
1267         size = 0;
1268         while (size < PAGE_SIZE && plane < OMAPFB_PLANE_NUM) {
1269                 omapfb_get_caps(fbdev, plane, &caps);
1270                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1271                                  "plane#%d:\n", plane);
1272                 for (i = 0; i < ARRAY_SIZE(ctrl_caps) &&
1273                      size < PAGE_SIZE; i++) {
1274                         if (ctrl_caps[i].flag & caps.ctrl)
1275                                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1276                                         " %s\n", ctrl_caps[i].name);
1277                 }
1278                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1279                                  " plane colors:\n");
1280                 for (i = 0; i < ARRAY_SIZE(color_caps) &&
1281                      size < PAGE_SIZE; i++) {
1282                         if (color_caps[i].flag & caps.plane_color)
1283                                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1284                                         "  %s\n", color_caps[i].name);
1285                 }
1286                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1287                                  " window colors:\n");
1288                 for (i = 0; i < ARRAY_SIZE(color_caps) &&
1289                      size < PAGE_SIZE; i++) {
1290                         if (color_caps[i].flag & caps.wnd_color)
1291                                 size += scnprintf(&buf[size], PAGE_SIZE - size,
1292                                         "  %s\n", color_caps[i].name);
1293                 }
1294
1295                 plane++;
1296         }
1297         return size;
1298 }
1299
1300 static DEVICE_ATTR(caps_num, 0444, omapfb_show_caps_num, NULL);
1301 static DEVICE_ATTR(caps_text, 0444, omapfb_show_caps_text, NULL);
1302
1303 /* panel sysfs entries */
1304 static ssize_t omapfb_show_panel_name(struct device *dev,
1305                                       struct device_attribute *attr, char *buf)
1306 {
1307         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1308
1309         return sysfs_emit(buf, "%s\n", fbdev->panel->name);
1310 }
1311
1312 static ssize_t omapfb_show_bklight_level(struct device *dev,
1313                                          struct device_attribute *attr,
1314                                          char *buf)
1315 {
1316         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1317         int r;
1318
1319         if (fbdev->panel->get_bklight_level) {
1320                 r = sysfs_emit(buf, "%d\n",
1321                                fbdev->panel->get_bklight_level(fbdev->panel));
1322         } else
1323                 r = -ENODEV;
1324         return r;
1325 }
1326
1327 static ssize_t omapfb_store_bklight_level(struct device *dev,
1328                                           struct device_attribute *attr,
1329                                           const char *buf, size_t size)
1330 {
1331         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1332         int r;
1333
1334         if (fbdev->panel->set_bklight_level) {
1335                 unsigned int level;
1336
1337                 if (sscanf(buf, "%10d", &level) == 1) {
1338                         r = fbdev->panel->set_bklight_level(fbdev->panel,
1339                                                             level);
1340                 } else
1341                         r = -EINVAL;
1342         } else
1343                 r = -ENODEV;
1344         return r ? r : size;
1345 }
1346
1347 static ssize_t omapfb_show_bklight_max(struct device *dev,
1348                                        struct device_attribute *attr, char *buf)
1349 {
1350         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1351         int r;
1352
1353         if (fbdev->panel->get_bklight_level) {
1354                 r = sysfs_emit(buf, "%d\n",
1355                                fbdev->panel->get_bklight_max(fbdev->panel));
1356         } else
1357                 r = -ENODEV;
1358         return r;
1359 }
1360
1361 static struct device_attribute dev_attr_panel_name =
1362         __ATTR(name, 0444, omapfb_show_panel_name, NULL);
1363 static DEVICE_ATTR(backlight_level, 0664,
1364                    omapfb_show_bklight_level, omapfb_store_bklight_level);
1365 static DEVICE_ATTR(backlight_max, 0444, omapfb_show_bklight_max, NULL);
1366
1367 static struct attribute *panel_attrs[] = {
1368         &dev_attr_panel_name.attr,
1369         &dev_attr_backlight_level.attr,
1370         &dev_attr_backlight_max.attr,
1371         NULL,
1372 };
1373
1374 static const struct attribute_group panel_attr_grp = {
1375         .name  = "panel",
1376         .attrs = panel_attrs,
1377 };
1378
1379 /* ctrl sysfs entries */
1380 static ssize_t omapfb_show_ctrl_name(struct device *dev,
1381                                      struct device_attribute *attr, char *buf)
1382 {
1383         struct omapfb_device *fbdev = dev_get_drvdata(dev);
1384
1385         return sysfs_emit(buf, "%s\n", fbdev->ctrl->name);
1386 }
1387
1388 static struct device_attribute dev_attr_ctrl_name =
1389         __ATTR(name, 0444, omapfb_show_ctrl_name, NULL);
1390
1391 static struct attribute *ctrl_attrs[] = {
1392         &dev_attr_ctrl_name.attr,
1393         NULL,
1394 };
1395
1396 static const struct attribute_group ctrl_attr_grp = {
1397         .name  = "ctrl",
1398         .attrs = ctrl_attrs,
1399 };
1400
1401 static int omapfb_register_sysfs(struct omapfb_device *fbdev)
1402 {
1403         int r;
1404
1405         if ((r = device_create_file(fbdev->dev, &dev_attr_caps_num)))
1406                 goto fail0;
1407
1408         if ((r = device_create_file(fbdev->dev, &dev_attr_caps_text)))
1409                 goto fail1;
1410
1411         if ((r = sysfs_create_group(&fbdev->dev->kobj, &panel_attr_grp)))
1412                 goto fail2;
1413
1414         if ((r = sysfs_create_group(&fbdev->dev->kobj, &ctrl_attr_grp)))
1415                 goto fail3;
1416
1417         return 0;
1418 fail3:
1419         sysfs_remove_group(&fbdev->dev->kobj, &panel_attr_grp);
1420 fail2:
1421         device_remove_file(fbdev->dev, &dev_attr_caps_text);
1422 fail1:
1423         device_remove_file(fbdev->dev, &dev_attr_caps_num);
1424 fail0:
1425         dev_err(fbdev->dev, "unable to register sysfs interface\n");
1426         return r;
1427 }
1428
1429 static void omapfb_unregister_sysfs(struct omapfb_device *fbdev)
1430 {
1431         sysfs_remove_group(&fbdev->dev->kobj, &ctrl_attr_grp);
1432         sysfs_remove_group(&fbdev->dev->kobj, &panel_attr_grp);
1433         device_remove_file(fbdev->dev, &dev_attr_caps_num);
1434         device_remove_file(fbdev->dev, &dev_attr_caps_text);
1435 }
1436
1437 /*
1438  * ---------------------------------------------------------------------------
1439  * LDM callbacks
1440  * ---------------------------------------------------------------------------
1441  */
1442 /* Initialize system fb_info object and set the default video mode.
1443  * The frame buffer memory already allocated by lcddma_init
1444  */
1445 static int fbinfo_init(struct omapfb_device *fbdev, struct fb_info *info)
1446 {
1447         struct fb_var_screeninfo        *var = &info->var;
1448         struct fb_fix_screeninfo        *fix = &info->fix;
1449         int                             r = 0;
1450
1451         info->fbops = &omapfb_ops;
1452
1453         strscpy(fix->id, MODULE_NAME, sizeof(fix->id));
1454
1455         info->pseudo_palette = fbdev->pseudo_palette;
1456
1457         var->accel_flags  = def_accel ? FB_ACCELF_TEXT : 0;
1458         var->xres = def_vxres;
1459         var->yres = def_vyres;
1460         var->xres_virtual = def_vxres;
1461         var->yres_virtual = def_vyres;
1462         var->rotate       = def_rotate;
1463         var->bits_per_pixel = fbdev->panel->bpp;
1464
1465         set_fb_var(info, var);
1466         set_fb_fix(info, 1);
1467
1468         r = fb_alloc_cmap(&info->cmap, 16, 0);
1469         if (r != 0)
1470                 dev_err(fbdev->dev, "unable to allocate color map memory\n");
1471
1472         return r;
1473 }
1474
1475 /* Release the fb_info object */
1476 static void fbinfo_cleanup(struct omapfb_device *fbdev, struct fb_info *fbi)
1477 {
1478         fb_dealloc_cmap(&fbi->cmap);
1479 }
1480
1481 static void planes_cleanup(struct omapfb_device *fbdev)
1482 {
1483         int i;
1484
1485         for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
1486                 if (fbdev->fb_info[i] == NULL)
1487                         break;
1488                 fbinfo_cleanup(fbdev, fbdev->fb_info[i]);
1489                 framebuffer_release(fbdev->fb_info[i]);
1490         }
1491 }
1492
1493 static int planes_init(struct omapfb_device *fbdev)
1494 {
1495         struct fb_info *fbi;
1496         int i;
1497         int r;
1498
1499         for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
1500                 struct omapfb_plane_struct *plane;
1501                 fbi = framebuffer_alloc(sizeof(struct omapfb_plane_struct),
1502                                         fbdev->dev);
1503                 if (fbi == NULL) {
1504                         planes_cleanup(fbdev);
1505                         return -ENOMEM;
1506                 }
1507                 plane = fbi->par;
1508                 plane->idx = i;
1509                 plane->fbdev = fbdev;
1510                 plane->info.mirror = def_mirror;
1511                 fbdev->fb_info[i] = fbi;
1512
1513                 if ((r = fbinfo_init(fbdev, fbi)) < 0) {
1514                         framebuffer_release(fbi);
1515                         planes_cleanup(fbdev);
1516                         return r;
1517                 }
1518                 plane->info.out_width = fbi->var.xres;
1519                 plane->info.out_height = fbi->var.yres;
1520         }
1521         return 0;
1522 }
1523
1524 /*
1525  * Free driver resources. Can be called to rollback an aborted initialization
1526  * sequence.
1527  */
1528 static void omapfb_free_resources(struct omapfb_device *fbdev, int state)
1529 {
1530         int i;
1531
1532         switch (state) {
1533         case OMAPFB_ACTIVE:
1534                 for (i = 0; i < fbdev->mem_desc.region_cnt; i++)
1535                         unregister_framebuffer(fbdev->fb_info[i]);
1536                 fallthrough;
1537         case 7:
1538                 omapfb_unregister_sysfs(fbdev);
1539                 fallthrough;
1540         case 6:
1541                 if (fbdev->panel->disable)
1542                         fbdev->panel->disable(fbdev->panel);
1543                 fallthrough;
1544         case 5:
1545                 omapfb_set_update_mode(fbdev, OMAPFB_UPDATE_DISABLED);
1546                 fallthrough;
1547         case 4:
1548                 planes_cleanup(fbdev);
1549                 fallthrough;
1550         case 3:
1551                 ctrl_cleanup(fbdev);
1552                 fallthrough;
1553         case 2:
1554                 if (fbdev->panel->cleanup)
1555                         fbdev->panel->cleanup(fbdev->panel);
1556                 fallthrough;
1557         case 1:
1558                 dev_set_drvdata(fbdev->dev, NULL);
1559                 kfree(fbdev);
1560                 break;
1561         case 0:
1562                 /* nothing to free */
1563                 break;
1564         default:
1565                 BUG();
1566         }
1567 }
1568
1569 static int omapfb_find_ctrl(struct omapfb_device *fbdev)
1570 {
1571         struct omapfb_platform_data *conf;
1572         char name[17];
1573         int i;
1574
1575         conf = dev_get_platdata(fbdev->dev);
1576
1577         fbdev->ctrl = NULL;
1578
1579         strscpy(name, conf->lcd.ctrl_name, sizeof(name));
1580
1581         if (strcmp(name, "internal") == 0) {
1582                 fbdev->ctrl = fbdev->int_ctrl;
1583                 return 0;
1584         }
1585
1586         for (i = 0; i < ARRAY_SIZE(ctrls); i++) {
1587                 dev_dbg(fbdev->dev, "ctrl %s\n", ctrls[i]->name);
1588                 if (strcmp(ctrls[i]->name, name) == 0) {
1589                         fbdev->ctrl = ctrls[i];
1590                         break;
1591                 }
1592         }
1593
1594         if (fbdev->ctrl == NULL) {
1595                 dev_dbg(fbdev->dev, "ctrl %s not supported\n", name);
1596                 return -1;
1597         }
1598
1599         return 0;
1600 }
1601
1602 /*
1603  * Called by LDM binding to probe and attach a new device.
1604  * Initialization sequence:
1605  *   1. allocate system omapfb_device structure
1606  *   2. select controller type according to platform configuration
1607  *      init LCD panel
1608  *   3. init LCD controller and LCD DMA
1609  *   4. init system fb_info structure for all planes
1610  *   5. setup video mode for first plane and enable it
1611  *   6. enable LCD panel
1612  *   7. register sysfs attributes
1613  *   OMAPFB_ACTIVE: register system fb_info structure for all planes
1614  */
1615 static int omapfb_do_probe(struct platform_device *pdev,
1616                                 struct lcd_panel *panel)
1617 {
1618         struct omapfb_device    *fbdev = NULL;
1619         int                     init_state;
1620         unsigned long           phz, hhz, vhz;
1621         unsigned long           vram;
1622         int                     i;
1623         int                     r = 0;
1624
1625         init_state = 0;
1626
1627         if (pdev->num_resources != 2) {
1628                 dev_err(&pdev->dev, "probed for an unknown device\n");
1629                 r = -ENODEV;
1630                 goto cleanup;
1631         }
1632
1633         if (dev_get_platdata(&pdev->dev) == NULL) {
1634                 dev_err(&pdev->dev, "missing platform data\n");
1635                 r = -ENOENT;
1636                 goto cleanup;
1637         }
1638
1639         fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
1640         if (fbdev == NULL) {
1641                 dev_err(&pdev->dev,
1642                         "unable to allocate memory for device info\n");
1643                 r = -ENOMEM;
1644                 goto cleanup;
1645         }
1646         fbdev->int_irq = platform_get_irq(pdev, 0);
1647         if (fbdev->int_irq < 0) {
1648                 r = ENXIO;
1649                 goto cleanup;
1650         }
1651
1652         fbdev->ext_irq = platform_get_irq(pdev, 1);
1653         if (fbdev->ext_irq < 0) {
1654                 r = ENXIO;
1655                 goto cleanup;
1656         }
1657
1658         init_state++;
1659
1660         fbdev->dev = &pdev->dev;
1661         fbdev->panel = panel;
1662         fbdev->dssdev = &omapdss_device;
1663         platform_set_drvdata(pdev, fbdev);
1664
1665         mutex_init(&fbdev->rqueue_mutex);
1666
1667         fbdev->int_ctrl = &omap1_int_ctrl;
1668 #ifdef CONFIG_FB_OMAP_LCDC_EXTERNAL
1669         fbdev->ext_if = &omap1_ext_if;
1670 #endif
1671         if (omapfb_find_ctrl(fbdev) < 0) {
1672                 dev_err(fbdev->dev,
1673                         "LCD controller not found, board not supported\n");
1674                 r = -ENODEV;
1675                 goto cleanup;
1676         }
1677
1678         if (fbdev->panel->init) {
1679                 r = fbdev->panel->init(fbdev->panel, fbdev);
1680                 if (r)
1681                         goto cleanup;
1682         }
1683
1684         pr_info("omapfb: configured for panel %s\n", fbdev->panel->name);
1685
1686         def_vxres = def_vxres ? def_vxres : fbdev->panel->x_res;
1687         def_vyres = def_vyres ? def_vyres : fbdev->panel->y_res;
1688
1689         init_state++;
1690
1691         r = ctrl_init(fbdev);
1692         if (r)
1693                 goto cleanup;
1694         if (fbdev->ctrl->mmap != NULL)
1695                 omapfb_ops.fb_mmap = omapfb_mmap;
1696         init_state++;
1697
1698         r = planes_init(fbdev);
1699         if (r)
1700                 goto cleanup;
1701         init_state++;
1702
1703 #ifdef CONFIG_FB_OMAP_DMA_TUNE
1704         /* Set DMA priority for EMIFF access to highest */
1705         omap_set_dma_priority(0, OMAP_DMA_PORT_EMIFF, 15);
1706 #endif
1707
1708         r = ctrl_change_mode(fbdev->fb_info[0]);
1709         if (r) {
1710                 dev_err(fbdev->dev, "mode setting failed\n");
1711                 goto cleanup;
1712         }
1713
1714         /* GFX plane is enabled by default */
1715         r = fbdev->ctrl->enable_plane(OMAPFB_PLANE_GFX, 1);
1716         if (r)
1717                 goto cleanup;
1718
1719         omapfb_set_update_mode(fbdev, manual_update ?
1720                                    OMAPFB_MANUAL_UPDATE : OMAPFB_AUTO_UPDATE);
1721         init_state++;
1722
1723         if (fbdev->panel->enable) {
1724                 r = fbdev->panel->enable(fbdev->panel);
1725                 if (r)
1726                         goto cleanup;
1727         }
1728         init_state++;
1729
1730         r = omapfb_register_sysfs(fbdev);
1731         if (r)
1732                 goto cleanup;
1733         init_state++;
1734
1735         vram = 0;
1736         for (i = 0; i < fbdev->mem_desc.region_cnt; i++) {
1737                 r = register_framebuffer(fbdev->fb_info[i]);
1738                 if (r != 0) {
1739                         dev_err(fbdev->dev,
1740                                 "registering framebuffer %d failed\n", i);
1741                         goto cleanup;
1742                 }
1743                 vram += fbdev->mem_desc.region[i].size;
1744         }
1745
1746         fbdev->state = OMAPFB_ACTIVE;
1747
1748         panel = fbdev->panel;
1749         phz = panel->pixel_clock * 1000;
1750         hhz = phz * 10 / (panel->hfp + panel->x_res + panel->hbp + panel->hsw);
1751         vhz = hhz / (panel->vfp + panel->y_res + panel->vbp + panel->vsw);
1752
1753         omapfb_dev = fbdev;
1754
1755         pr_info("omapfb: Framebuffer initialized. Total vram %lu planes %d\n",
1756                         vram, fbdev->mem_desc.region_cnt);
1757         pr_info("omapfb: Pixclock %lu kHz hfreq %lu.%lu kHz "
1758                         "vfreq %lu.%lu Hz\n",
1759                         phz / 1000, hhz / 10000, hhz % 10, vhz / 10, vhz % 10);
1760
1761         return 0;
1762
1763 cleanup:
1764         omapfb_free_resources(fbdev, init_state);
1765
1766         return r;
1767 }
1768
1769 static int omapfb_probe(struct platform_device *pdev)
1770 {
1771         int r;
1772
1773         BUG_ON(fbdev_pdev != NULL);
1774
1775         r = platform_device_register(&omapdss_device);
1776         if (r) {
1777                 dev_err(&pdev->dev, "can't register omapdss device\n");
1778                 return r;
1779         }
1780
1781         /* Delay actual initialization until the LCD is registered */
1782         fbdev_pdev = pdev;
1783         if (fbdev_panel != NULL)
1784                 omapfb_do_probe(fbdev_pdev, fbdev_panel);
1785         return 0;
1786 }
1787
1788 void omapfb_register_panel(struct lcd_panel *panel)
1789 {
1790         BUG_ON(fbdev_panel != NULL);
1791
1792         fbdev_panel = panel;
1793         if (fbdev_pdev != NULL)
1794                 omapfb_do_probe(fbdev_pdev, fbdev_panel);
1795 }
1796 EXPORT_SYMBOL_GPL(omapfb_register_panel);
1797
1798 /* Called when the device is being detached from the driver */
1799 static void omapfb_remove(struct platform_device *pdev)
1800 {
1801         struct omapfb_device *fbdev = platform_get_drvdata(pdev);
1802         enum omapfb_state saved_state = fbdev->state;
1803
1804         /* FIXME: wait till completion of pending events */
1805
1806         fbdev->state = OMAPFB_DISABLED;
1807         omapfb_free_resources(fbdev, saved_state);
1808
1809         platform_device_unregister(&omapdss_device);
1810         fbdev->dssdev = NULL;
1811 }
1812
1813 /* PM suspend */
1814 static int omapfb_suspend(struct platform_device *pdev, pm_message_t mesg)
1815 {
1816         struct omapfb_device *fbdev = platform_get_drvdata(pdev);
1817
1818         if (fbdev != NULL)
1819                 omapfb_blank(FB_BLANK_POWERDOWN, fbdev->fb_info[0]);
1820         return 0;
1821 }
1822
1823 /* PM resume */
1824 static int omapfb_resume(struct platform_device *pdev)
1825 {
1826         struct omapfb_device *fbdev = platform_get_drvdata(pdev);
1827
1828         if (fbdev != NULL)
1829                 omapfb_blank(FB_BLANK_UNBLANK, fbdev->fb_info[0]);
1830         return 0;
1831 }
1832
1833 static struct platform_driver omapfb_driver = {
1834         .probe          = omapfb_probe,
1835         .remove_new     = omapfb_remove,
1836         .suspend        = omapfb_suspend,
1837         .resume         = omapfb_resume,
1838         .driver         = {
1839                 .name   = MODULE_NAME,
1840         },
1841 };
1842
1843 #ifndef MODULE
1844
1845 /* Process kernel command line parameters */
1846 static int __init omapfb_setup(char *options)
1847 {
1848         char *this_opt = NULL;
1849         int r = 0;
1850
1851         pr_debug("omapfb: options %s\n", options);
1852
1853         if (!options || !*options)
1854                 return 0;
1855
1856         while (!r && (this_opt = strsep(&options, ",")) != NULL) {
1857                 if (!strncmp(this_opt, "accel", 5))
1858                         def_accel = 1;
1859                 else if (!strncmp(this_opt, "vram:", 5)) {
1860                         char *suffix;
1861                         unsigned long vram;
1862                         vram = (simple_strtoul(this_opt + 5, &suffix, 0));
1863                         switch (suffix[0]) {
1864                         case '\0':
1865                                 break;
1866                         case 'm':
1867                         case 'M':
1868                                 vram *= 1024;
1869                                 fallthrough;
1870                         case 'k':
1871                         case 'K':
1872                                 vram *= 1024;
1873                                 break;
1874                         default:
1875                                 pr_debug("omapfb: invalid vram suffix %c\n",
1876                                          suffix[0]);
1877                                 r = -1;
1878                         }
1879                         def_vram[def_vram_cnt++] = vram;
1880                 }
1881                 else if (!strncmp(this_opt, "vxres:", 6))
1882                         def_vxres = simple_strtoul(this_opt + 6, NULL, 0);
1883                 else if (!strncmp(this_opt, "vyres:", 6))
1884                         def_vyres = simple_strtoul(this_opt + 6, NULL, 0);
1885                 else if (!strncmp(this_opt, "rotate:", 7))
1886                         def_rotate = (simple_strtoul(this_opt + 7, NULL, 0));
1887                 else if (!strncmp(this_opt, "mirror:", 7))
1888                         def_mirror = (simple_strtoul(this_opt + 7, NULL, 0));
1889                 else if (!strncmp(this_opt, "manual_update", 13))
1890                         manual_update = 1;
1891                 else {
1892                         pr_debug("omapfb: invalid option\n");
1893                         r = -1;
1894                 }
1895         }
1896
1897         return r;
1898 }
1899
1900 #endif
1901
1902 /* Register both the driver and the device */
1903 static int __init omapfb_init(void)
1904 {
1905 #ifndef MODULE
1906         char *option;
1907
1908         if (fb_get_options("omapfb", &option))
1909                 return -ENODEV;
1910         omapfb_setup(option);
1911 #endif
1912         /* Register the driver with LDM */
1913         if (platform_driver_register(&omapfb_driver)) {
1914                 pr_debug("failed to register omapfb driver\n");
1915                 return -ENODEV;
1916         }
1917
1918         return 0;
1919 }
1920
1921 static void __exit omapfb_cleanup(void)
1922 {
1923         platform_driver_unregister(&omapfb_driver);
1924 }
1925
1926 module_param_named(accel, def_accel, uint, 0664);
1927 module_param_array_named(vram, def_vram, ulong, &def_vram_cnt, 0664);
1928 module_param_named(vxres, def_vxres, long, 0664);
1929 module_param_named(vyres, def_vyres, long, 0664);
1930 module_param_named(rotate, def_rotate, uint, 0664);
1931 module_param_named(mirror, def_mirror, uint, 0664);
1932 module_param_named(manual_update, manual_update, bool, 0664);
1933
1934 module_init(omapfb_init);
1935 module_exit(omapfb_cleanup);
1936
1937 MODULE_DESCRIPTION("TI OMAP framebuffer driver");
1938 MODULE_AUTHOR("Imre Deak <imre.deak@nokia.com>");
1939 MODULE_LICENSE("GPL");