drivers/video/omap2/omapfb/omapfb-main.c

   1 /*
   2  * linux/drivers/video/omap2/omapfb-main.c
   3  *
   4  * Copyright (C) 2008 Nokia Corporation
   5  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
   6  *
   7  * Some code and ideas taken from drivers/video/omap/ driver
   8  * by Imre Deak.
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License version 2 as published by
  12  * the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17  * more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along with
  20  * this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/delay.h>
  25 #include <linux/fb.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/vmalloc.h>
  28 #include <linux/device.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/omapfb.h>
  31
  32 #include <mach/display.h>
  33 #include <mach/vram.h>
  34 #include <mach/vrfb.h>
  35
  36 #include "omapfb.h"
  37
  38 #define MODULE_NAME     "omapfb"
  39
  40 static char *def_mode;
  41 static char *def_vram;
  42 static int def_vrfb;
  43 static int def_rotate;
  44 static int def_mirror;
  45
  46 #ifdef DEBUG
  47 unsigned int omapfb_debug;
  48 module_param_named(debug, omapfb_debug, bool, 0644);
  49 static unsigned int omapfb_test_pattern;
  50 module_param_named(test, omapfb_test_pattern, bool, 0644);
  51 #endif
  52
  53 #ifdef DEBUG
  54 static void draw_pixel(struct fb_info *fbi, int x, int y, unsigned color)
  55 {
  56         struct fb_var_screeninfo *var = &fbi->var;
  57         struct fb_fix_screeninfo *fix = &fbi->fix;
  58         void __iomem *addr = fbi->screen_base;
  59         const unsigned bytespp = var->bits_per_pixel >> 3;
  60         const unsigned line_len = fix->line_length / bytespp;
  61
  62         int r = (color >> 16) & 0xff;
  63         int g = (color >> 8) & 0xff;
  64         int b = (color >> 0) & 0xff;
  65
  66         if (var->bits_per_pixel == 16) {
  67                 u16 __iomem *p = (u16 __iomem *)addr;
  68                 p += y * line_len + x;
  69
  70                 r = r * 32 / 256;
  71                 g = g * 64 / 256;
  72                 b = b * 32 / 256;
  73
  74                 __raw_writew((r << 11) | (g << 5) | (b << 0), p);
  75         } else if (var->bits_per_pixel == 24) {
  76                 u8 __iomem *p = (u8 __iomem *)addr;
  77                 p += (y * line_len + x) * 3;
  78
  79                 __raw_writeb(b, p + 0);
  80                 __raw_writeb(g, p + 1);
  81                 __raw_writeb(r, p + 2);
  82         } else if (var->bits_per_pixel == 32) {
  83                 u32 __iomem *p = (u32 __iomem *)addr;
  84                 p += y * line_len + x;
  85                 __raw_writel(color, p);
  86         }
  87 }
  88
  89 static void fill_fb(struct fb_info *fbi)
  90 {
  91         struct fb_var_screeninfo *var = &fbi->var;
  92         const short w = var->xres_virtual;
  93         const short h = var->yres_virtual;
  94         void __iomem *addr = fbi->screen_base;
  95         int y, x;
  96
  97         if (!addr)
  98                 return;
  99
 100         DBG("fill_fb %dx%d, line_len %d bytes\n", w, h, fbi->fix.line_length);
 101
 102         for (y = 0; y < h; y++) {
 103                 for (x = 0; x < w; x++) {
 104                         if (x < 20 && y < 20)
 105                                 draw_pixel(fbi, x, y, 0xffffff);
 106                         else if (x < 20 && (y > 20 && y < h - 20))
 107                                 draw_pixel(fbi, x, y, 0xff);
 108                         else if (y < 20 && (x > 20 && x < w - 20))
 109                                 draw_pixel(fbi, x, y, 0xff00);
 110                         else if (x > w - 20 && (y > 20 && y < h - 20))
 111                                 draw_pixel(fbi, x, y, 0xff0000);
 112                         else if (y > h - 20 && (x > 20 && x < w - 20))
 113                                 draw_pixel(fbi, x, y, 0xffff00);
 114                         else if (x == 20 || x == w - 20 ||
 115                                         y == 20 || y == h - 20)
 116                                 draw_pixel(fbi, x, y, 0xffffff);
 117                         else if (x == y || w - x == h - y)
 118                                 draw_pixel(fbi, x, y, 0xff00ff);
 119                         else if (w - x == y || x == h - y)
 120                                 draw_pixel(fbi, x, y, 0x00ffff);
 121                         else if (x > 20 && y > 20 && x < w - 20 && y < h - 20) {
 122                                 int t = x * 3 / w;
 123                                 unsigned r = 0, g = 0, b = 0;
 124                                 unsigned c;
 125                                 if (var->bits_per_pixel == 16) {
 126                                         if (t == 0)
 127                                                 b = (y % 32) * 256 / 32;
 128                                         else if (t == 1)
 129                                                 g = (y % 64) * 256 / 64;
 130                                         else if (t == 2)
 131                                                 r = (y % 32) * 256 / 32;
 132                                 } else {
 133                                         if (t == 0)
 134                                                 b = (y % 256);
 135                                         else if (t == 1)
 136                                                 g = (y % 256);
 137                                         else if (t == 2)
 138                                                 r = (y % 256);
 139                                 }
 140                                 c = (r << 16) | (g << 8) | (b << 0);
 141                                 draw_pixel(fbi, x, y, c);
 142                         } else {
 143                                 draw_pixel(fbi, x, y, 0);
 144                         }
 145                 }
 146         }
 147 }
 148 #endif
 149
 150 static unsigned omapfb_get_vrfb_offset(struct omapfb_info *ofbi, int rot)
 151 {
 152         struct vrfb *vrfb = &ofbi->region.vrfb;
 153         unsigned offset;
 154
 155         switch (rot) {
 156         case FB_ROTATE_UR:
 157                 offset = 0;
 158                 break;
 159         case FB_ROTATE_CW:
 160                 offset = vrfb->yoffset;
 161                 break;
 162         case FB_ROTATE_UD:
 163                 offset = vrfb->yoffset * OMAP_VRFB_LINE_LEN + vrfb->xoffset;
 164                 break;
 165         case FB_ROTATE_CCW:
 166                 offset = vrfb->xoffset * OMAP_VRFB_LINE_LEN;
 167                 break;
 168         default:
 169                 BUG();
 170         }
 171
 172         offset *= vrfb->bytespp;
 173
 174         return offset;
 175 }
 176
 177 static u32 omapfb_get_region_rot_paddr(struct omapfb_info *ofbi)
 178 {
 179         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 180                 return ofbi->region.vrfb.paddr[ofbi->rotation]
 181                         + omapfb_get_vrfb_offset(ofbi, ofbi->rotation);
 182         } else {
 183                 return ofbi->region.paddr;
 184         }
 185 }
 186
 187 u32 omapfb_get_region_paddr(struct omapfb_info *ofbi)
 188 {
 189         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 190                 return ofbi->region.vrfb.paddr[0];
 191         else
 192                 return ofbi->region.paddr;
 193 }
 194
 195 void __iomem *omapfb_get_region_vaddr(struct omapfb_info *ofbi)
 196 {
 197         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 198                 return ofbi->region.vrfb.vaddr[0];
 199         else
 200                 return ofbi->region.vaddr;
 201 }
 202
 203 static struct omapfb_colormode omapfb_colormodes[] = {
 204         {
 205                 .dssmode = OMAP_DSS_COLOR_UYVY,
 206                 .bits_per_pixel = 16,
 207                 .nonstd = OMAPFB_COLOR_YUV422,
 208         }, {
 209                 .dssmode = OMAP_DSS_COLOR_YUV2,
 210                 .bits_per_pixel = 16,
 211                 .nonstd = OMAPFB_COLOR_YUY422,
 212         }, {
 213                 .dssmode = OMAP_DSS_COLOR_ARGB16,
 214                 .bits_per_pixel = 16,
 215                 .red    = { .length = 4, .offset = 8, .msb_right = 0 },
 216                 .green  = { .length = 4, .offset = 4, .msb_right = 0 },
 217                 .blue   = { .length = 4, .offset = 0, .msb_right = 0 },
 218                 .transp = { .length = 4, .offset = 12, .msb_right = 0 },
 219         }, {
 220                 .dssmode = OMAP_DSS_COLOR_RGB16,
 221                 .bits_per_pixel = 16,
 222                 .red    = { .length = 5, .offset = 11, .msb_right = 0 },
 223                 .green  = { .length = 6, .offset = 5, .msb_right = 0 },
 224                 .blue   = { .length = 5, .offset = 0, .msb_right = 0 },
 225                 .transp = { .length = 0, .offset = 0, .msb_right = 0 },
 226         }, {
 227                 .dssmode = OMAP_DSS_COLOR_RGB24P,
 228                 .bits_per_pixel = 24,
 229                 .red    = { .length = 8, .offset = 16, .msb_right = 0 },
 230                 .green  = { .length = 8, .offset = 8, .msb_right = 0 },
 231                 .blue   = { .length = 8, .offset = 0, .msb_right = 0 },
 232                 .transp = { .length = 0, .offset = 0, .msb_right = 0 },
 233         }, {
 234                 .dssmode = OMAP_DSS_COLOR_RGB24U,
 235                 .bits_per_pixel = 32,
 236                 .red    = { .length = 8, .offset = 16, .msb_right = 0 },
 237                 .green  = { .length = 8, .offset = 8, .msb_right = 0 },
 238                 .blue   = { .length = 8, .offset = 0, .msb_right = 0 },
 239                 .transp = { .length = 0, .offset = 0, .msb_right = 0 },
 240         }, {
 241                 .dssmode = OMAP_DSS_COLOR_ARGB32,
 242                 .bits_per_pixel = 32,
 243                 .red    = { .length = 8, .offset = 16, .msb_right = 0 },
 244                 .green  = { .length = 8, .offset = 8, .msb_right = 0 },
 245                 .blue   = { .length = 8, .offset = 0, .msb_right = 0 },
 246                 .transp = { .length = 8, .offset = 24, .msb_right = 0 },
 247         }, {
 248                 .dssmode = OMAP_DSS_COLOR_RGBA32,
 249                 .bits_per_pixel = 32,
 250                 .red    = { .length = 8, .offset = 24, .msb_right = 0 },
 251                 .green  = { .length = 8, .offset = 16, .msb_right = 0 },
 252                 .blue   = { .length = 8, .offset = 8, .msb_right = 0 },
 253                 .transp = { .length = 8, .offset = 0, .msb_right = 0 },
 254         }, {
 255                 .dssmode = OMAP_DSS_COLOR_RGBX32,
 256                 .bits_per_pixel = 32,
 257                 .red    = { .length = 8, .offset = 24, .msb_right = 0 },
 258                 .green  = { .length = 8, .offset = 16, .msb_right = 0 },
 259                 .blue   = { .length = 8, .offset = 8, .msb_right = 0 },
 260                 .transp = { .length = 0, .offset = 0, .msb_right = 0 },
 261         },
 262 };
 263
 264 static bool cmp_var_to_colormode(struct fb_var_screeninfo *var,
 265                 struct omapfb_colormode *color)
 266 {
 267         bool cmp_component(struct fb_bitfield *f1, struct fb_bitfield *f2)
 268         {
 269                 return f1->length == f2->length &&
 270                         f1->offset == f2->offset &&
 271                         f1->msb_right == f2->msb_right;
 272         }
 273
 274         if (var->bits_per_pixel == 0 ||
 275                         var->red.length == 0 ||
 276                         var->blue.length == 0 ||
 277                         var->green.length == 0)
 278                 return 0;
 279
 280         return var->bits_per_pixel == color->bits_per_pixel &&
 281                 cmp_component(&var->red, &color->red) &&
 282                 cmp_component(&var->green, &color->green) &&
 283                 cmp_component(&var->blue, &color->blue) &&
 284                 cmp_component(&var->transp, &color->transp);
 285 }
 286
 287 static void assign_colormode_to_var(struct fb_var_screeninfo *var,
 288                 struct omapfb_colormode *color)
 289 {
 290         var->bits_per_pixel = color->bits_per_pixel;
 291         var->nonstd = color->nonstd;
 292         var->red = color->red;
 293         var->green = color->green;
 294         var->blue = color->blue;
 295         var->transp = color->transp;
 296 }
 297
 298 static enum omap_color_mode fb_mode_to_dss_mode(struct fb_var_screeninfo *var)
 299 {
 300         enum omap_color_mode dssmode;
 301         int i;
 302
 303         /* first match with nonstd field */
 304         if (var->nonstd) {
 305                 for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 306                         struct omapfb_colormode *mode = &omapfb_colormodes[i];
 307                         if (var->nonstd == mode->nonstd) {
 308                                 assign_colormode_to_var(var, mode);
 309                                 return mode->dssmode;
 310                         }
 311                 }
 312
 313                 return -EINVAL;
 314         }
 315
 316         /* then try exact match of bpp and colors */
 317         for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 318                 struct omapfb_colormode *mode = &omapfb_colormodes[i];
 319                 if (cmp_var_to_colormode(var, mode)) {
 320                         assign_colormode_to_var(var, mode);
 321                         return mode->dssmode;
 322                 }
 323         }
 324
 325         /* match with bpp if user has not filled color fields
 326          * properly */
 327         switch (var->bits_per_pixel) {
 328         case 1:
 329                 dssmode = OMAP_DSS_COLOR_CLUT1;
 330                 break;
 331         case 2:
 332                 dssmode = OMAP_DSS_COLOR_CLUT2;
 333                 break;
 334         case 4:
 335                 dssmode = OMAP_DSS_COLOR_CLUT4;
 336                 break;
 337         case 8:
 338                 dssmode = OMAP_DSS_COLOR_CLUT8;
 339                 break;
 340         case 12:
 341                 dssmode = OMAP_DSS_COLOR_RGB12U;
 342                 break;
 343         case 16:
 344                 dssmode = OMAP_DSS_COLOR_RGB16;
 345                 break;
 346         case 24:
 347                 dssmode = OMAP_DSS_COLOR_RGB24P;
 348                 break;
 349         case 32:
 350                 dssmode = OMAP_DSS_COLOR_RGB24U;
 351                 break;
 352         default:
 353                 return -EINVAL;
 354         }
 355
 356         for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 357                 struct omapfb_colormode *mode = &omapfb_colormodes[i];
 358                 if (dssmode == mode->dssmode) {
 359                         assign_colormode_to_var(var, mode);
 360                         return mode->dssmode;
 361                 }
 362         }
 363
 364         return -EINVAL;
 365 }
 366
 367 static int dss_mode_to_fb_mode(enum omap_color_mode dssmode,
 368                                struct fb_var_screeninfo *var)
 369 {
 370         int i;
 371
 372         for (i = 0; i < ARRAY_SIZE(omapfb_colormodes); ++i) {
 373                 struct omapfb_colormode *mode = &omapfb_colormodes[i];
 374                 if (dssmode == mode->dssmode) {
 375                         assign_colormode_to_var(var, mode);
 376                         return 0;
 377                 }
 378         }
 379         return -ENOENT;
 380 }
 381
 382 void set_fb_fix(struct fb_info *fbi)
 383 {
 384         struct fb_fix_screeninfo *fix = &fbi->fix;
 385         struct fb_var_screeninfo *var = &fbi->var;
 386         struct omapfb_info *ofbi = FB2OFB(fbi);
 387         struct omapfb2_mem_region *rg = &ofbi->region;
 388
 389         DBG("set_fb_fix\n");
 390
 391         /* used by open/write in fbmem.c */
 392         fbi->screen_base = (char __iomem *)omapfb_get_region_vaddr(ofbi);
 393
 394         /* used by mmap in fbmem.c */
 395         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 396                 fix->line_length =
 397                         (OMAP_VRFB_LINE_LEN * var->bits_per_pixel) >> 3;
 398         else
 399                 fix->line_length =
 400                         (var->xres_virtual * var->bits_per_pixel) >> 3;
 401         fix->smem_start = omapfb_get_region_paddr(ofbi);
 402         fix->smem_len = rg->size;
 403
 404         fix->type = FB_TYPE_PACKED_PIXELS;
 405
 406         if (var->nonstd)
 407                 fix->visual = FB_VISUAL_PSEUDOCOLOR;
 408         else {
 409                 switch (var->bits_per_pixel) {
 410                 case 32:
 411                 case 24:
 412                 case 16:
 413                 case 12:
 414                         fix->visual = FB_VISUAL_TRUECOLOR;
 415                         /* 12bpp is stored in 16 bits */
 416                         break;
 417                 case 1:
 418                 case 2:
 419                 case 4:
 420                 case 8:
 421                         fix->visual = FB_VISUAL_PSEUDOCOLOR;
 422                         break;
 423                 }
 424         }
 425
 426         fix->accel = FB_ACCEL_NONE;
 427
 428         fix->xpanstep = 1;
 429         fix->ypanstep = 1;
 430
 431         if (rg->size && ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 432                 enum omap_color_mode mode = 0;
 433                 mode = fb_mode_to_dss_mode(var);
 434
 435                 omap_vrfb_setup(&rg->vrfb, rg->paddr,
 436                                 var->xres_virtual,
 437                                 var->yres_virtual,
 438                                 mode);
 439         }
 440 }
 441
 442 /* check new var and possibly modify it to be ok */
 443 int check_fb_var(struct fb_info *fbi, struct fb_var_screeninfo *var)
 444 {
 445         struct omapfb_info *ofbi = FB2OFB(fbi);
 446         struct omap_display *display = fb2display(fbi);
 447         unsigned long max_frame_size;
 448         unsigned long line_size;
 449         int xres_min, yres_min;
 450         int xres_max, yres_max;
 451         enum omap_color_mode mode = 0;
 452         int i;
 453         int bytespp;
 454
 455         DBG("check_fb_var %d\n", ofbi->id);
 456
 457         if (ofbi->region.size == 0)
 458                 return 0;
 459
 460         mode = fb_mode_to_dss_mode(var);
 461         if (mode < 0) {
 462                 DBG("cannot convert var to omap dss mode\n");
 463                 return -EINVAL;
 464         }
 465
 466         for (i = 0; i < ofbi->num_overlays; ++i) {
 467                 if ((ofbi->overlays[i]->supported_modes & mode) == 0) {
 468                         DBG("invalid mode\n");
 469                         return -EINVAL;
 470                 }
 471         }
 472
 473         if (var->rotate < 0 || var->rotate > 3)
 474                 return -EINVAL;
 475
 476         if (var->rotate != fbi->var.rotate) {
 477                 DBG("rotation changing\n");
 478
 479                 ofbi->rotation = var->rotate;
 480
 481                 if (abs(var->rotate - fbi->var.rotate) != 2) {
 482                         int tmp;
 483                         DBG("rotate changing 90/270 degrees. "
 484                                         "swapping x/y res\n");
 485
 486                         tmp = var->yres;
 487                         var->yres = var->xres;
 488                         var->xres = tmp;
 489
 490                         tmp = var->yres_virtual;
 491                         var->yres_virtual = var->xres_virtual;
 492                         var->xres_virtual = tmp;
 493                 }
 494         }
 495
 496         xres_min = OMAPFB_PLANE_XRES_MIN;
 497         xres_max = 2048;
 498         yres_min = OMAPFB_PLANE_YRES_MIN;
 499         yres_max = 2048;
 500
 501         bytespp = var->bits_per_pixel >> 3;
 502
 503         /* XXX: some applications seem to set virtual res to 0. */
 504         if (var->xres_virtual == 0)
 505                 var->xres_virtual = var->xres;
 506
 507         if (var->yres_virtual == 0)
 508                 var->yres_virtual = var->yres;
 509
 510         if (var->xres_virtual < xres_min || var->yres_virtual < yres_min)
 511                 return -EINVAL;
 512
 513         if (var->xres < xres_min)
 514                 var->xres = xres_min;
 515         if (var->yres < yres_min)
 516                 var->yres = yres_min;
 517         if (var->xres > xres_max)
 518                 var->xres = xres_max;
 519         if (var->yres > yres_max)
 520                 var->yres = yres_max;
 521
 522         if (var->xres > var->xres_virtual)
 523                 var->xres = var->xres_virtual;
 524         if (var->yres > var->yres_virtual)
 525                 var->yres = var->yres_virtual;
 526
 527         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 528                 line_size = OMAP_VRFB_LINE_LEN * bytespp;
 529         else
 530                 line_size = var->xres_virtual * bytespp;
 531
 532         max_frame_size = ofbi->region.size;
 533
 534         DBG("max frame size %lu, line size %lu\n", max_frame_size, line_size);
 535
 536         if (line_size * var->yres_virtual > max_frame_size) {
 537                 DBG("can't fit FB into memory, reducing y\n");
 538                 var->yres_virtual = max_frame_size / line_size;
 539
 540                 if (var->yres_virtual < yres_min)
 541                         var->yres_virtual = yres_min;
 542
 543                 if (var->yres > var->yres_virtual)
 544                         var->yres = var->yres_virtual;
 545         }
 546
 547         if (line_size * var->yres_virtual > max_frame_size) {
 548                 DBG("can't fit FB into memory, reducing x\n");
 549                 if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 550                         return -EINVAL;
 551
 552                 var->xres_virtual = max_frame_size / var->yres_virtual /
 553                         bytespp;
 554
 555                 if (var->xres_virtual < xres_min)
 556                         var->xres_virtual = xres_min;
 557
 558                 if (var->xres > var->xres_virtual)
 559                         var->xres = var->xres_virtual;
 560
 561                 line_size = var->xres_virtual * bytespp;
 562         }
 563
 564         if (line_size * var->yres_virtual > max_frame_size) {
 565                 DBG("cannot fit FB to memory\n");
 566                 return -EINVAL;
 567         }
 568
 569         if (var->xres + var->xoffset > var->xres_virtual)
 570                 var->xoffset = var->xres_virtual - var->xres;
 571         if (var->yres + var->yoffset > var->yres_virtual)
 572                 var->yoffset = var->yres_virtual - var->yres;
 573
 574         DBG("xres = %d, yres = %d, vxres = %d, vyres = %d\n",
 575                         var->xres, var->yres,
 576                         var->xres_virtual, var->yres_virtual);
 577
 578         var->height             = -1;
 579         var->width              = -1;
 580         var->grayscale          = 0;
 581
 582         if (display && display->get_timings) {
 583                 struct omap_video_timings timings;
 584                 display->get_timings(display, &timings);
 585
 586                 /* pixclock in ps, the rest in pixclock */
 587                 var->pixclock = timings.pixel_clock != 0 ?
 588                         KHZ2PICOS(timings.pixel_clock) :
 589                         0;
 590                 var->left_margin = timings.hfp;
 591                 var->right_margin = timings.hbp;
 592                 var->upper_margin = timings.vfp;
 593                 var->lower_margin = timings.vbp;
 594                 var->hsync_len = timings.hsw;
 595                 var->vsync_len = timings.vsw;
 596         } else {
 597                 var->pixclock = 0;
 598                 var->left_margin = 0;
 599                 var->right_margin = 0;
 600                 var->upper_margin = 0;
 601                 var->lower_margin = 0;
 602                 var->hsync_len = 0;
 603                 var->vsync_len = 0;
 604         }
 605
 606         /* TODO: get these from panel->config */
 607         var->vmode              = FB_VMODE_NONINTERLACED;
 608         var->sync               = 0;
 609
 610         return 0;
 611 }
 612
 613 /*
 614  * ---------------------------------------------------------------------------
 615  * fbdev framework callbacks
 616  * ---------------------------------------------------------------------------
 617  */
 618 static int omapfb_open(struct fb_info *fbi, int user)
 619 {
 620         return 0;
 621 }
 622
 623 static int omapfb_release(struct fb_info *fbi, int user)
 624 {
 625         struct omapfb_info *ofbi = FB2OFB(fbi);
 626         struct omapfb2_device *fbdev = ofbi->fbdev;
 627         struct omap_display *display = fb2display(fbi);
 628
 629         DBG("Closing fb with plane index %d\n", ofbi->id);
 630
 631         omapfb_lock(fbdev);
 632 #if 1
 633         if (display && display->get_update_mode && display->update) {
 634                 /* XXX this update should be removed, I think. But it's
 635                  * good for debugging */
 636                 if (display->get_update_mode(display) ==
 637                                 OMAP_DSS_UPDATE_MANUAL) {
 638                         u16 w, h;
 639
 640                         if (display->sync)
 641                                 display->sync(display);
 642
 643                         display->get_resolution(display, &w, &h);
 644                         display->update(display, 0, 0, w, h);
 645                 }
 646         }
 647 #endif
 648
 649         if (display && display->sync)
 650                 display->sync(display);
 651
 652         omapfb_unlock(fbdev);
 653
 654         return 0;
 655 }
 656
 657 /* setup overlay according to the fb */
 658 static int omapfb_setup_overlay(struct fb_info *fbi, struct omap_overlay *ovl,
 659                 u16 posx, u16 posy, u16 outw, u16 outh)
 660 {
 661         int r = 0;
 662         struct omapfb_info *ofbi = FB2OFB(fbi);
 663         struct fb_var_screeninfo *var = &fbi->var;
 664         struct fb_fix_screeninfo *fix = &fbi->fix;
 665         enum omap_color_mode mode = 0;
 666         int offset;
 667         u32 data_start_p;
 668         void __iomem *data_start_v;
 669         struct omap_overlay_info info;
 670         int xres, yres;
 671         int screen_width;
 672         int mirror;
 673
 674         DBG("setup_overlay %d, posx %d, posy %d, outw %d, outh %d\n", ofbi->id,
 675                         posx, posy, outw, outh);
 676
 677         if (ofbi->rotation == FB_ROTATE_CW || ofbi->rotation == FB_ROTATE_CCW) {
 678                 xres = var->yres;
 679                 yres = var->xres;
 680         } else {
 681                 xres = var->xres;
 682                 yres = var->yres;
 683         }
 684
 685         offset = ((var->yoffset * var->xres_virtual +
 686                                 var->xoffset) * var->bits_per_pixel) >> 3;
 687
 688         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
 689                 data_start_p = omapfb_get_region_rot_paddr(ofbi);
 690                 data_start_v = NULL;
 691         } else {
 692                 data_start_p = omapfb_get_region_paddr(ofbi);
 693                 data_start_v = omapfb_get_region_vaddr(ofbi);
 694         }
 695
 696         data_start_p += offset;
 697         data_start_v += offset;
 698
 699         mode = fb_mode_to_dss_mode(var);
 700
 701         if (mode == -EINVAL) {
 702                 DBG("fb_mode_to_dss_mode failed");
 703                 r = -EINVAL;
 704                 goto err;
 705         }
 706
 707         screen_width = fix->line_length / (var->bits_per_pixel >> 3);
 708
 709         ovl->get_overlay_info(ovl, &info);
 710
 711         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
 712                 mirror = 0;
 713         else
 714                 mirror = ofbi->mirror;
 715
 716         info.paddr = data_start_p;
 717         info.vaddr = data_start_v;
 718         info.screen_width = screen_width;
 719         info.width = xres;
 720         info.height = yres;
 721         info.color_mode = mode;
 722         info.rotation_type = ofbi->rotation_type;
 723         info.rotation = ofbi->rotation;
 724         info.mirror = mirror;
 725
 726         info.pos_x = posx;
 727         info.pos_y = posy;
 728         info.out_width = outw;
 729         info.out_height = outh;
 730
 731         r = ovl->set_overlay_info(ovl, &info);
 732         if (r) {
 733                 DBG("ovl->setup_overlay_info failed\n");
 734                 goto err;
 735         }
 736
 737         return 0;
 738
 739 err:
 740         DBG("setup_overlay failed\n");
 741         return r;
 742 }
 743
 744 /* apply var to the overlay */
 745 int omapfb_apply_changes(struct fb_info *fbi, int init)
 746 {
 747         int r = 0;
 748         struct omapfb_info *ofbi = FB2OFB(fbi);
 749         struct fb_var_screeninfo *var = &fbi->var;
 750         struct omap_overlay *ovl;
 751         u16 posx, posy;
 752         u16 outw, outh;
 753         int i;
 754
 755 #ifdef DEBUG
 756         if (omapfb_test_pattern)
 757                 fill_fb(fbi);
 758 #endif
 759
 760         for (i = 0; i < ofbi->num_overlays; i++) {
 761                 ovl = ofbi->overlays[i];
 762
 763                 DBG("apply_changes, fb %d, ovl %d\n", ofbi->id, ovl->id);
 764
 765                 if (ofbi->region.size == 0) {
 766                         /* the fb is not available. disable the overlay */
 767                         omapfb_overlay_enable(ovl, 0);
 768                         if (!init && ovl->manager)
 769                                 ovl->manager->apply(ovl->manager);
 770                         continue;
 771                 }
 772
 773                 if (init || (ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
 774                         if (ofbi->rotation == FB_ROTATE_CW ||
 775                                         ofbi->rotation == FB_ROTATE_CCW) {
 776                                 outw = var->yres;
 777                                 outh = var->xres;
 778                         } else {
 779                                 outw = var->xres;
 780                                 outh = var->yres;
 781                         }
 782                 } else {
 783                         outw = ovl->info.out_width;
 784                         outh = ovl->info.out_height;
 785                 }
 786
 787                 if (init) {
 788                         posx = 0;
 789                         posy = 0;
 790                 } else {
 791                         posx = ovl->info.pos_x;
 792                         posy = ovl->info.pos_y;
 793                 }
 794
 795                 r = omapfb_setup_overlay(fbi, ovl, posx, posy, outw, outh);
 796                 if (r)
 797                         goto err;
 798
 799                 if (!init && ovl->manager)
 800                         ovl->manager->apply(ovl->manager);
 801         }
 802         return 0;
 803 err:
 804         DBG("apply_changes failed\n");
 805         return r;
 806 }
 807
 808 /* checks var and eventually tweaks it to something supported,
 809  * DO NOT MODIFY PAR */
 810 static int omapfb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
 811 {
 812         int r;
 813
 814         DBG("check_var(%d)\n", FB2OFB(fbi)->id);
 815
 816         r = check_fb_var(fbi, var);
 817
 818         return r;
 819 }
 820
 821 /* set the video mode according to info->var */
 822 static int omapfb_set_par(struct fb_info *fbi)
 823 {
 824         int r;
 825
 826         DBG("set_par(%d)\n", FB2OFB(fbi)->id);
 827
 828         set_fb_fix(fbi);
 829         r = omapfb_apply_changes(fbi, 0);
 830
 831         return r;
 832 }
 833
 834 static int omapfb_pan_display(struct fb_var_screeninfo *var,
 835                 struct fb_info *fbi)
 836 {
 837         struct omapfb_info *ofbi = FB2OFB(fbi);
 838         struct omapfb2_device *fbdev = ofbi->fbdev;
 839         int r = 0;
 840
 841         DBG("pan_display(%d)\n", ofbi->id);
 842
 843         omapfb_lock(fbdev);
 844
 845         if (var->xoffset != fbi->var.xoffset ||
 846             var->yoffset != fbi->var.yoffset) {
 847                 struct fb_var_screeninfo new_var;
 848
 849                 new_var = fbi->var;
 850                 new_var.xoffset = var->xoffset;
 851                 new_var.yoffset = var->yoffset;
 852
 853                 r = check_fb_var(fbi, &new_var);
 854
 855                 if (r == 0) {
 856                         fbi->var = new_var;
 857                         set_fb_fix(fbi);
 858                         r = omapfb_apply_changes(fbi, 0);
 859                 }
 860         }
 861
 862         omapfb_unlock(fbdev);
 863
 864         return r;
 865 }
 866
 867 static void mmap_user_open(struct vm_area_struct *vma)
 868 {
 869         struct omapfb_info *ofbi = (struct omapfb_info *)vma->vm_private_data;
 870
 871         atomic_inc(&ofbi->map_count);
 872 }
 873
 874 static void mmap_user_close(struct vm_area_struct *vma)
 875 {
 876         struct omapfb_info *ofbi = (struct omapfb_info *)vma->vm_private_data;
 877
 878         atomic_dec(&ofbi->map_count);
 879 }
 880
 881 static struct vm_operations_struct mmap_user_ops = {
 882         .open = mmap_user_open,
 883         .close = mmap_user_close,
 884 };
 885
 886 static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
 887 {
 888         struct omapfb_info *ofbi = FB2OFB(fbi);
 889         struct fb_fix_screeninfo *fix = &fbi->fix;
 890         unsigned long off;
 891         unsigned long start;
 892         u32 len;
 893
 894         if (vma->vm_end - vma->vm_start == 0)
 895                 return 0;
 896         if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
 897                 return -EINVAL;
 898         off = vma->vm_pgoff << PAGE_SHIFT;
 899
 900         start = omapfb_get_region_paddr(ofbi);
 901         len = fix->smem_len;
 902         if (off >= len)
 903                 return -EINVAL;
 904         if ((vma->vm_end - vma->vm_start + off) > len)
 905                 return -EINVAL;
 906
 907         off += start;
 908
 909         DBG("user mmap region start %lx, len %d, off %lx\n", start, len, off);
 910
 911         vma->vm_pgoff = off >> PAGE_SHIFT;
 912         vma->vm_flags |= VM_IO | VM_RESERVED;
 913         vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 914         vma->vm_ops = &mmap_user_ops;
 915         vma->vm_private_data = ofbi;
 916         if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
 917                              vma->vm_end - vma->vm_start, vma->vm_page_prot))
 918                 return -EAGAIN;
 919         /* vm_ops.open won't be called for mmap itself. */
 920         atomic_inc(&ofbi->map_count);
 921         return 0;
 922 }
 923
 924 /* Store a single color palette entry into a pseudo palette or the hardware
 925  * palette if one is available. For now we support only 16bpp and thus store
 926  * the entry only to the pseudo palette.
 927  */
 928 static int _setcolreg(struct fb_info *fbi, u_int regno, u_int red, u_int green,
 929                 u_int blue, u_int transp, int update_hw_pal)
 930 {
 931         /*struct omapfb_info *ofbi = FB2OFB(fbi);*/
 932         /*struct omapfb2_device *fbdev = ofbi->fbdev;*/
 933         struct fb_var_screeninfo *var = &fbi->var;
 934         int r = 0;
 935
 936         enum omapfb_color_format mode = OMAPFB_COLOR_RGB24U; /* XXX */
 937
 938         /*switch (plane->color_mode) {*/
 939         switch (mode) {
 940         case OMAPFB_COLOR_YUV422:
 941         case OMAPFB_COLOR_YUV420:
 942         case OMAPFB_COLOR_YUY422:
 943                 r = -EINVAL;
 944                 break;
 945         case OMAPFB_COLOR_CLUT_8BPP:
 946         case OMAPFB_COLOR_CLUT_4BPP:
 947         case OMAPFB_COLOR_CLUT_2BPP:
 948         case OMAPFB_COLOR_CLUT_1BPP:
 949                 /*
 950                    if (fbdev->ctrl->setcolreg)
 951                    r = fbdev->ctrl->setcolreg(regno, red, green, blue,
 952                    transp, update_hw_pal);
 953                    */
 954                 /* Fallthrough */
 955                 r = -EINVAL;
 956                 break;
 957         case OMAPFB_COLOR_RGB565:
 958         case OMAPFB_COLOR_RGB444:
 959         case OMAPFB_COLOR_RGB24P:
 960         case OMAPFB_COLOR_RGB24U:
 961                 if (r != 0)
 962                         break;
 963
 964                 if (regno < 0) {
 965                         r = -EINVAL;
 966                         break;
 967                 }
 968
 969                 if (regno < 16) {
 970                         u16 pal;
 971                         pal = ((red >> (16 - var->red.length)) <<
 972                                         var->red.offset) |
 973                                 ((green >> (16 - var->green.length)) <<
 974                                  var->green.offset) |
 975                                 (blue >> (16 - var->blue.length));
 976                         ((u32 *)(fbi->pseudo_palette))[regno] = pal;
 977                 }
 978                 break;
 979         default:
 980                 BUG();
 981         }
 982         return r;
 983 }
 984
 985 static int omapfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 986                 u_int transp, struct fb_info *info)
 987 {
 988         DBG("setcolreg\n");
 989
 990         return _setcolreg(info, regno, red, green, blue, transp, 1);
 991 }
 992
 993 static int omapfb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
 994 {
 995         int count, index, r;
 996         u16 *red, *green, *blue, *transp;
 997         u16 trans = 0xffff;
 998
 999         DBG("setcmap\n");
1000
1001         red     = cmap->red;
1002         green   = cmap->green;
1003         blue    = cmap->blue;
1004         transp  = cmap->transp;
1005         index   = cmap->start;
1006
1007         for (count = 0; count < cmap->len; count++) {
1008                 if (transp)
1009                         trans = *transp++;
1010                 r = _setcolreg(info, index++, *red++, *green++, *blue++, trans,
1011                                 count == cmap->len - 1);
1012                 if (r != 0)
1013                         return r;
1014         }
1015
1016         return 0;
1017 }
1018
1019 static int omapfb_blank(int blank, struct fb_info *fbi)
1020 {
1021         struct omapfb_info *ofbi = FB2OFB(fbi);
1022         struct omapfb2_device *fbdev = ofbi->fbdev;
1023         struct omap_display *display = fb2display(fbi);
1024         int do_update = 0;
1025         int r = 0;
1026
1027         omapfb_lock(fbdev);
1028
1029         switch (blank) {
1030         case FB_BLANK_UNBLANK:
1031                 if (display->state != OMAP_DSS_DISPLAY_SUSPENDED)
1032                         goto exit;
1033
1034                 if (display->resume)
1035                         r = display->resume(display);
1036
1037                 if (r == 0 && display->get_update_mode &&
1038                                 display->get_update_mode(display) ==
1039                                 OMAP_DSS_UPDATE_MANUAL)
1040                         do_update = 1;
1041
1042                 break;
1043
1044         case FB_BLANK_NORMAL:
1045                 /* FB_BLANK_NORMAL could be implemented.
1046                  * Needs DSS additions. */
1047         case FB_BLANK_VSYNC_SUSPEND:
1048         case FB_BLANK_HSYNC_SUSPEND:
1049         case FB_BLANK_POWERDOWN:
1050                 if (display->state != OMAP_DSS_DISPLAY_ACTIVE)
1051                         goto exit;
1052
1053                 if (display->suspend)
1054                         r = display->suspend(display);
1055
1056                 break;
1057
1058         default:
1059                 r = -EINVAL;
1060         }
1061
1062 exit:
1063         omapfb_unlock(fbdev);
1064
1065         if (r == 0 && do_update && display->update) {
1066                 u16 w, h;
1067                 display->get_resolution(display, &w, &h);
1068
1069                 r = display->update(display, 0, 0, w, h);
1070         }
1071
1072         return r;
1073 }
1074
1075 #if 0
1076 /* XXX fb_read and fb_write are needed for VRFB */
1077 ssize_t omapfb_write(struct fb_info *info, const char __user *buf,
1078                 size_t count, loff_t *ppos)
1079 {
1080         DBG("omapfb_write %d, %lu\n", count, (unsigned long)*ppos);
1081         // XXX needed for VRFB
1082         return count;
1083 }
1084 #endif
1085
1086 static struct fb_ops omapfb_ops = {
1087         .owner          = THIS_MODULE,
1088         .fb_open        = omapfb_open,
1089         .fb_release     = omapfb_release,
1090         .fb_fillrect    = cfb_fillrect,
1091         .fb_copyarea    = cfb_copyarea,
1092         .fb_imageblit   = cfb_imageblit,
1093         .fb_blank       = omapfb_blank,
1094         .fb_ioctl       = omapfb_ioctl,
1095         .fb_check_var   = omapfb_check_var,
1096         .fb_set_par     = omapfb_set_par,
1097         .fb_pan_display = omapfb_pan_display,
1098         .fb_mmap        = omapfb_mmap,
1099         .fb_setcolreg   = omapfb_setcolreg,
1100         .fb_setcmap     = omapfb_setcmap,
1101         //.fb_write     = omapfb_write,
1102 };
1103
1104 static void omapfb_free_fbmem(struct fb_info *fbi)
1105 {
1106         struct omapfb_info *ofbi = FB2OFB(fbi);
1107         struct omapfb2_device *fbdev = ofbi->fbdev;
1108         struct omapfb2_mem_region *rg;
1109
1110         rg = &ofbi->region;
1111
1112         if (rg->paddr)
1113                 if (omap_vram_free(rg->paddr, rg->size))
1114                         dev_err(fbdev->dev, "VRAM FREE failed\n");
1115
1116         if (rg->vaddr)
1117                 iounmap(rg->vaddr);
1118
1119         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
1120                 /* unmap the 0 angle rotation */
1121                 if (rg->vrfb.vaddr[0]) {
1122                         iounmap(rg->vrfb.vaddr[0]);
1123                         omap_vrfb_release_ctx(&rg->vrfb);
1124                 }
1125         }
1126
1127         rg->vaddr = NULL;
1128         rg->paddr = 0;
1129         rg->alloc = 0;
1130         rg->size = 0;
1131 }
1132
1133 static int omapfb_free_all_fbmem(struct omapfb2_device *fbdev)
1134 {
1135         int i;
1136
1137         DBG("free all fbmem\n");
1138
1139         for (i = 0; i < fbdev->num_fbs; i++) {
1140                 struct fb_info *fbi = fbdev->fbs[i];
1141                 omapfb_free_fbmem(fbi);
1142                 memset(&fbi->fix, 0, sizeof(fbi->fix));
1143                 memset(&fbi->var, 0, sizeof(fbi->var));
1144         }
1145
1146         return 0;
1147 }
1148
1149 static int omapfb_alloc_fbmem(struct fb_info *fbi, unsigned long size,
1150                 unsigned long paddr)
1151 {
1152         struct omapfb_info *ofbi = FB2OFB(fbi);
1153         struct omapfb2_device *fbdev = ofbi->fbdev;
1154         struct omapfb2_mem_region *rg;
1155         void __iomem *vaddr;
1156         int r;
1157         int clear = 0;
1158
1159         rg = &ofbi->region;
1160         memset(rg, 0, sizeof(*rg));
1161
1162         size = PAGE_ALIGN(size);
1163
1164         if (!paddr) {
1165                 DBG("allocating %lu bytes for fb %d\n", size, ofbi->id);
1166                 r = omap_vram_alloc(OMAPFB_MEMTYPE_SDRAM, size, &paddr);
1167                 clear = 1;
1168         } else {
1169                 DBG("reserving %lu bytes at %lx for fb %d\n", size, paddr,
1170                                 ofbi->id);
1171                 r = omap_vram_reserve(paddr, size);
1172         }
1173
1174         if (r) {
1175                 dev_err(fbdev->dev, "failed to allocate framebuffer\n");
1176                 return -ENOMEM;
1177         }
1178
1179         if (ofbi->rotation_type != OMAP_DSS_ROT_VRFB) {
1180                 vaddr = ioremap_wc(paddr, size);
1181
1182                 if (!vaddr) {
1183                         dev_err(fbdev->dev, "failed to ioremap framebuffer\n");
1184                         omap_vram_free(paddr, size);
1185                         return -ENOMEM;
1186                 }
1187
1188                 DBG("allocated VRAM paddr %lx, vaddr %p\n", paddr, vaddr);
1189
1190                 if (clear)
1191                         memset_io(vaddr, 0, size);
1192         } else {
1193                 void __iomem *va;
1194
1195                 r = omap_vrfb_request_ctx(&rg->vrfb);
1196                 if (r) {
1197                         dev_err(fbdev->dev, "vrfb create ctx failed\n");
1198                         return r;
1199                 }
1200
1201                 /* only ioremap the 0 angle view */
1202                 va = ioremap_wc(rg->vrfb.paddr[0], size);
1203
1204                 if(!va) {
1205                         printk(KERN_ERR "vrfb: ioremap failed\n");
1206                         omap_vrfb_release_ctx(&rg->vrfb);
1207                         return -ENOMEM;
1208                 }
1209
1210                 DBG("ioremapped vrfb area 0 to %p\n", va);
1211
1212                 rg->vrfb.vaddr[0] = va;
1213
1214                 vaddr = NULL;
1215
1216                 if (clear)
1217                         memset_io(va, 0, size);
1218         }
1219
1220         rg->paddr = paddr;
1221         rg->vaddr = vaddr;
1222         rg->size = size;
1223         rg->alloc = 1;
1224
1225         return 0;
1226 }
1227
1228 /* allocate fbmem using display resolution as reference */
1229 static int omapfb_alloc_fbmem_display(struct fb_info *fbi, unsigned long size,
1230                 unsigned long paddr)
1231 {
1232         struct omapfb_info *ofbi = FB2OFB(fbi);
1233         struct omap_display *display;
1234         int bytespp;
1235
1236         display =  fb2display(fbi);
1237
1238         if (!display)
1239                 return 0;
1240
1241         switch (display->get_recommended_bpp(display)) {
1242         case 16:
1243                 bytespp = 2;
1244                 break;
1245         case 24:
1246                 bytespp = 4;
1247                 break;
1248         default:
1249                 bytespp = 4;
1250                 break;
1251         }
1252
1253         if (!size) {
1254                 u16 w, h;
1255
1256                 display->get_resolution(display, &w, &h);
1257
1258                 if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
1259 #ifdef DEBUG
1260                         int oldw = w, oldh = h;
1261 #endif
1262
1263                         omap_vrfb_adjust_size(&w, &h, bytespp);
1264
1265                         /* Because we change the resolution of the 0 degree view,
1266                          * we need to alloc max(w, h) for height */
1267                         h = max(w, h);
1268                         w = OMAP_VRFB_LINE_LEN;
1269
1270                         DBG("adjusting fb mem size for VRFB, %dx%d -> %dx%d\n",
1271                                         oldw, oldh, w, h);
1272                 }
1273
1274                 size = w * h * bytespp;
1275         }
1276
1277         return omapfb_alloc_fbmem(fbi, size, paddr);
1278 }
1279
1280 static enum omap_color_mode fb_format_to_dss_mode(enum omapfb_color_format format)
1281 {
1282         enum omap_color_mode mode;
1283
1284         switch (format) {
1285         case OMAPFB_COLOR_RGB565:
1286                 mode = OMAP_DSS_COLOR_RGB16;
1287                 break;
1288         case OMAPFB_COLOR_YUV422:
1289                 mode = OMAP_DSS_COLOR_YUV2;
1290                 break;
1291         case OMAPFB_COLOR_CLUT_8BPP:
1292                 mode = OMAP_DSS_COLOR_CLUT8;
1293                 break;
1294         case OMAPFB_COLOR_CLUT_4BPP:
1295                 mode = OMAP_DSS_COLOR_CLUT4;
1296                 break;
1297         case OMAPFB_COLOR_CLUT_2BPP:
1298                 mode = OMAP_DSS_COLOR_CLUT2;
1299                 break;
1300         case OMAPFB_COLOR_CLUT_1BPP:
1301                 mode = OMAP_DSS_COLOR_CLUT1;
1302                 break;
1303         case OMAPFB_COLOR_RGB444:
1304                 mode = OMAP_DSS_COLOR_RGB12U;
1305                 break;
1306         case OMAPFB_COLOR_YUY422:
1307                 mode = OMAP_DSS_COLOR_UYVY;
1308                 break;
1309         case OMAPFB_COLOR_ARGB16:
1310                 mode = OMAP_DSS_COLOR_ARGB16;
1311                 break;
1312         case OMAPFB_COLOR_RGB24U:
1313                 mode = OMAP_DSS_COLOR_RGB24U;
1314                 break;
1315         case OMAPFB_COLOR_RGB24P:
1316                 mode = OMAP_DSS_COLOR_RGB24P;
1317                 break;
1318         case OMAPFB_COLOR_ARGB32:
1319                 mode = OMAP_DSS_COLOR_ARGB32;
1320                 break;
1321         case OMAPFB_COLOR_RGBA32:
1322                 mode = OMAP_DSS_COLOR_RGBA32;
1323                 break;
1324         case OMAPFB_COLOR_RGBX32:
1325                 mode = OMAP_DSS_COLOR_RGBX32;
1326                 break;
1327         default:
1328                 mode = -EINVAL;
1329         }
1330
1331         return mode;
1332 }
1333
1334 static int omapfb_parse_vram_param(const char *param, int max_entries,
1335                 unsigned long *sizes, unsigned long *paddrs)
1336 {
1337         int fbnum;
1338         unsigned long size;
1339         unsigned long paddr = 0;
1340         char *p, *start;
1341
1342         start = (char *)param;
1343
1344         while (1) {
1345                 p = start;
1346
1347                 fbnum = simple_strtoul(p, &p, 10);
1348
1349                 if (p == param)
1350                         return -EINVAL;
1351
1352                 if (*p != ':')
1353                         return -EINVAL;
1354
1355                 if (fbnum >= max_entries)
1356                         return -EINVAL;
1357
1358                 size = memparse(p + 1, &p);
1359
1360                 if (!size)
1361                         return -EINVAL;
1362
1363                 paddr = 0;
1364
1365                 if (*p == '@') {
1366                         paddr = simple_strtoul(p + 1, &p, 16);
1367
1368                         if (!paddr)
1369                                 return -EINVAL;
1370
1371                 }
1372
1373                 paddrs[fbnum] = paddr;
1374                 sizes[fbnum] = size;
1375
1376                 if (*p == 0)
1377                         break;
1378
1379                 if (*p != ',')
1380                         return -EINVAL;
1381
1382                 ++p;
1383
1384                 start = p;
1385         }
1386
1387         return 0;
1388 }
1389
1390 static int omapfb_allocate_all_fbs(struct omapfb2_device *fbdev)
1391 {
1392         int i, r;
1393         unsigned long vram_sizes[10];
1394         unsigned long vram_paddrs[10];
1395
1396         memset(&vram_sizes, 0, sizeof(vram_sizes));
1397         memset(&vram_paddrs, 0, sizeof(vram_paddrs));
1398
1399         if (def_vram && omapfb_parse_vram_param(def_vram, 10,
1400                                 vram_sizes, vram_paddrs)) {
1401                 dev_err(fbdev->dev, "failed to parse vram parameter\n");
1402
1403                 memset(&vram_sizes, 0, sizeof(vram_sizes));
1404                 memset(&vram_paddrs, 0, sizeof(vram_paddrs));
1405         }
1406
1407         if (fbdev->dev->platform_data) {
1408                 struct omapfb_platform_data *opd;
1409                 opd = fbdev->dev->platform_data;
1410                 for (i = 0; i < opd->mem_desc.region_cnt; ++i) {
1411                         if (!vram_sizes[i]) {
1412                                 unsigned long size;
1413                                 unsigned long paddr;
1414
1415                                 size = opd->mem_desc.region[i].size;
1416                                 paddr = opd->mem_desc.region[i].paddr;
1417
1418                                 vram_sizes[i] = size;
1419                                 vram_paddrs[i] = paddr;
1420                         }
1421                 }
1422         }
1423
1424         for (i = 0; i < fbdev->num_fbs; i++) {
1425                 /* allocate memory automatically only for fb0, or if
1426                  * excplicitly defined with vram or plat data option */
1427                 if (i == 0 || vram_sizes[i] != 0) {
1428                         r = omapfb_alloc_fbmem_display(fbdev->fbs[i],
1429                                         vram_sizes[i], vram_paddrs[i]);
1430
1431                         if (r)
1432                                 return r;
1433                 }
1434         }
1435
1436         for (i = 0; i < fbdev->num_fbs; i++) {
1437                 struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);
1438                 struct omapfb2_mem_region *rg;
1439                 rg = &ofbi->region;
1440
1441                 DBG("region%d phys %08x virt %p size=%lu\n",
1442                                 i,
1443                                 rg->paddr,
1444                                 rg->vaddr,
1445                                 rg->size);
1446         }
1447
1448         return 0;
1449 }
1450
1451 int omapfb_realloc_fbmem(struct fb_info *fbi, unsigned long size, int type)
1452 {
1453         struct omapfb_info *ofbi = FB2OFB(fbi);
1454         struct omapfb2_device *fbdev = ofbi->fbdev;
1455         struct omap_display *display = fb2display(fbi);
1456         struct omapfb2_mem_region *rg = &ofbi->region;
1457         unsigned long old_size = rg->size;
1458         unsigned long old_paddr = rg->paddr;
1459         int old_type = rg->type;
1460         int r;
1461
1462         if (type > OMAPFB_MEMTYPE_MAX)
1463                 return -EINVAL;
1464
1465         size = PAGE_ALIGN(size);
1466
1467         if (old_size == size && old_type == type)
1468                 return 0;
1469
1470         if (display && display->sync)
1471                         display->sync(display);
1472
1473         omapfb_free_fbmem(fbi);
1474
1475         if (size == 0) {
1476                 memset(&fbi->fix, 0, sizeof(fbi->fix));
1477                 memset(&fbi->var, 0, sizeof(fbi->var));
1478                 return 0;
1479         }
1480
1481         r = omapfb_alloc_fbmem(fbi, size, 0);
1482
1483         if (r) {
1484                 if (old_size)
1485                         omapfb_alloc_fbmem(fbi, old_size, old_paddr);
1486
1487                 if (rg->size == 0) {
1488                         memset(&fbi->fix, 0, sizeof(fbi->fix));
1489                         memset(&fbi->var, 0, sizeof(fbi->var));
1490                 }
1491
1492                 return r;
1493         }
1494
1495         if (old_size == size)
1496                 return 0;
1497
1498         if (old_size == 0) {
1499                 DBG("initializing fb %d\n", ofbi->id);
1500                 r = omapfb_fb_init(fbdev, fbi);
1501                 if (r) {
1502                         DBG("omapfb_fb_init failed\n");
1503                         goto err;
1504                 }
1505                 r = omapfb_apply_changes(fbi, 1);
1506                 if (r) {
1507                         DBG("omapfb_apply_changes failed\n");
1508                         goto err;
1509                 }
1510         } else {
1511                 struct fb_var_screeninfo new_var;
1512                 memcpy(&new_var, &fbi->var, sizeof(new_var));
1513                 r = check_fb_var(fbi, &new_var);
1514                 if (r)
1515                         goto err;
1516                 memcpy(&fbi->var, &new_var, sizeof(fbi->var));
1517                 set_fb_fix(fbi);
1518         }
1519
1520         return 0;
1521 err:
1522         omapfb_free_fbmem(fbi);
1523         memset(&fbi->fix, 0, sizeof(fbi->fix));
1524         memset(&fbi->var, 0, sizeof(fbi->var));
1525         return r;
1526 }
1527
1528 /* initialize fb_info, var, fix to something sane based on the display */
1529 int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi)
1530 {
1531         struct fb_var_screeninfo *var = &fbi->var;
1532         struct fb_fix_screeninfo *fix = &fbi->fix;
1533         struct omap_display *display = fb2display(fbi);
1534         struct omapfb_info *ofbi = FB2OFB(fbi);
1535         int r = 0;
1536
1537         fbi->fbops = &omapfb_ops;
1538         fbi->flags = FBINFO_FLAG_DEFAULT;
1539         fbi->pseudo_palette = fbdev->pseudo_palette;
1540
1541         strncpy(fix->id, MODULE_NAME, sizeof(fix->id));
1542
1543         if (ofbi->region.size == 0) {
1544                 memset(&fbi->fix, 0, sizeof(fbi->fix));
1545                 memset(&fbi->var, 0, sizeof(fbi->var));
1546                 return 0;
1547         }
1548
1549         var->nonstd = 0;
1550         var->bits_per_pixel = 0;
1551
1552         var->rotate = ofbi->rotation;
1553
1554         /*
1555          * Check if there is a default color format set in the board file,
1556          * and use this format instead the default deducted from the
1557          * display bpp.
1558          */
1559         if (fbdev->dev->platform_data) {
1560                 struct omapfb_platform_data *opd;
1561                 int id = ofbi->id;
1562
1563                 opd = fbdev->dev->platform_data;
1564                 if (opd->mem_desc.region[id].format_used) {
1565                         enum omap_color_mode mode;
1566                         enum omapfb_color_format format;
1567
1568                         format = opd->mem_desc.region[id].format;
1569                         mode = fb_format_to_dss_mode(format);
1570                         if (mode < 0) {
1571                                 r = mode;
1572                                 goto err;
1573                         }
1574                         r = dss_mode_to_fb_mode(mode, var);
1575                         if (r < 0)
1576                                 goto err;
1577                 }
1578         }
1579
1580         if (display) {
1581                 u16 w, h;
1582                 display->get_resolution(display, &w, &h);
1583
1584                 if (ofbi->rotation == FB_ROTATE_CW ||
1585                                 ofbi->rotation == FB_ROTATE_CCW) {
1586                         var->xres = h;
1587                         var->yres = w;
1588                 } else {
1589                         var->xres = w;
1590                         var->yres = h;
1591                 }
1592
1593                 var->xres_virtual = var->xres;
1594                 var->yres_virtual = var->yres;
1595
1596                 if (!var->bits_per_pixel) {
1597                         switch (display->get_recommended_bpp(display)) {
1598                                 case 16:
1599                                         var->bits_per_pixel = 16;
1600                                         break;
1601                                 case 24:
1602                                         var->bits_per_pixel = 32;
1603                                         break;
1604                                 default:
1605                                         dev_err(fbdev->dev, "illegal display bpp\n");
1606                                         return -EINVAL;
1607                         }
1608                 }
1609         } else {
1610                 /* if there's no display, let's just guess some basic values */
1611                 var->xres = 320;
1612                 var->yres = 240;
1613                 var->xres_virtual = var->xres;
1614                 var->yres_virtual = var->yres;
1615                 if (!var->bits_per_pixel)
1616                         var->bits_per_pixel = 16;
1617         }
1618
1619         r = check_fb_var(fbi, var);
1620         if (r)
1621                 goto err;
1622
1623         set_fb_fix(fbi);
1624
1625         r = fb_alloc_cmap(&fbi->cmap, 256, 0);
1626         if (r)
1627                 dev_err(fbdev->dev, "unable to allocate color map memory\n");
1628
1629 err:
1630         return r;
1631 }
1632
1633 static void fbinfo_cleanup(struct omapfb2_device *fbdev, struct fb_info *fbi)
1634 {
1635         fb_dealloc_cmap(&fbi->cmap);
1636 }
1637
1638
1639 static void omapfb_free_resources(struct omapfb2_device *fbdev)
1640 {
1641         int i;
1642
1643         DBG("free_resources\n");
1644
1645         if (fbdev == NULL)
1646                 return;
1647
1648         for (i = 0; i < fbdev->num_fbs; i++)
1649                 unregister_framebuffer(fbdev->fbs[i]);
1650
1651         /* free the reserved fbmem */
1652         omapfb_free_all_fbmem(fbdev);
1653
1654         for (i = 0; i < fbdev->num_fbs; i++) {
1655                 fbinfo_cleanup(fbdev, fbdev->fbs[i]);
1656                 framebuffer_release(fbdev->fbs[i]);
1657         }
1658
1659         for (i = 0; i < fbdev->num_displays; i++) {
1660                 if (fbdev->displays[i]->state != OMAP_DSS_DISPLAY_DISABLED)
1661                         fbdev->displays[i]->disable(fbdev->displays[i]);
1662
1663                 omap_dss_put_display(fbdev->displays[i]);
1664         }
1665
1666         dev_set_drvdata(fbdev->dev, NULL);
1667         kfree(fbdev);
1668 }
1669
1670 static int omapfb_create_framebuffers(struct omapfb2_device *fbdev)
1671 {
1672         int r, i;
1673
1674         fbdev->num_fbs = 0;
1675
1676         DBG("create %d framebuffers\n", CONFIG_FB_OMAP2_NUM_FBS);
1677
1678         /* allocate fb_infos */
1679         for (i = 0; i < CONFIG_FB_OMAP2_NUM_FBS; i++) {
1680                 struct fb_info *fbi;
1681                 struct omapfb_info *ofbi;
1682
1683                 fbi = framebuffer_alloc(sizeof(struct omapfb_info),
1684                                 fbdev->dev);
1685
1686                 if (fbi == NULL) {
1687                         dev_err(fbdev->dev,
1688                                 "unable to allocate memory for plane info\n");
1689                         return -ENOMEM;
1690                 }
1691
1692                 fbdev->fbs[i] = fbi;
1693
1694                 ofbi = FB2OFB(fbi);
1695                 ofbi->fbdev = fbdev;
1696                 ofbi->id = i;
1697
1698                 /* assign these early, so that fb alloc can use them */
1699                 ofbi->rotation_type = def_vrfb ? OMAP_DSS_ROT_VRFB :
1700                         OMAP_DSS_ROT_DMA;
1701                 ofbi->rotation = def_rotate;
1702                 ofbi->mirror = def_mirror;
1703
1704                 fbdev->num_fbs++;
1705         }
1706
1707         DBG("fb_infos allocated\n");
1708
1709         /* assign overlays for the fbs */
1710         for (i = 0; i < min(fbdev->num_fbs, fbdev->num_overlays); i++) {
1711                 struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);
1712
1713                 ofbi->overlays[0] = fbdev->overlays[i];
1714                 ofbi->num_overlays = 1;
1715         }
1716
1717         /* allocate fb memories */
1718         r = omapfb_allocate_all_fbs(fbdev);
1719         if (r) {
1720                 dev_err(fbdev->dev, "failed to allocate fbmem\n");
1721                 return r;
1722         }
1723
1724         DBG("fbmems allocated\n");
1725
1726         /* setup fb_infos */
1727         for (i = 0; i < fbdev->num_fbs; i++) {
1728                 r = omapfb_fb_init(fbdev, fbdev->fbs[i]);
1729                 if (r) {
1730                         dev_err(fbdev->dev, "failed to setup fb_info\n");
1731                         return r;
1732                 }
1733         }
1734
1735         DBG("fb_infos initialized\n");
1736
1737         for (i = 0; i < fbdev->num_fbs; i++) {
1738                 r = register_framebuffer(fbdev->fbs[i]);
1739                 if (r != 0) {
1740                         dev_err(fbdev->dev,
1741                                 "registering framebuffer %d failed\n", i);
1742                         return r;
1743                 }
1744         }
1745
1746         DBG("framebuffers registered\n");
1747
1748         for (i = 0; i < fbdev->num_fbs; i++) {
1749                 r = omapfb_apply_changes(fbdev->fbs[i], 1);
1750                 if (r) {
1751                         dev_err(fbdev->dev, "failed to change mode\n");
1752                         return r;
1753                 }
1754         }
1755
1756         DBG("create sysfs for fbs\n");
1757         r = omapfb_create_sysfs(fbdev);
1758         if (r) {
1759                 dev_err(fbdev->dev, "failed to create sysfs entries\n");
1760                 return r;
1761         }
1762
1763         /* Enable fb0 */
1764         if (fbdev->num_fbs > 0) {
1765                 struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[0]);
1766
1767                 if (ofbi->num_overlays > 0 ) {
1768                         struct omap_overlay *ovl = ofbi->overlays[0];
1769
1770                         r = omapfb_overlay_enable(ovl, 1);
1771
1772                         if (r) {
1773                                 dev_err(fbdev->dev,
1774                                                 "failed to enable overlay\n");
1775                                 return r;
1776                         }
1777                 }
1778         }
1779
1780         DBG("create_framebuffers done\n");
1781
1782         return 0;
1783 }
1784
1785 int omapfb_mode_to_timings(const char *mode_str,
1786                 struct omap_video_timings *timings, u8 *bpp)
1787 {
1788         struct fb_info fbi;
1789         struct fb_var_screeninfo var;
1790         struct fb_ops fbops;
1791         int r;
1792
1793 #ifdef CONFIG_OMAP2_DSS_VENC
1794         if (strcmp(mode_str, "pal") == 0) {
1795                 *timings = omap_dss_pal_timings;
1796                 *bpp = 0;
1797                 return 0;
1798         } else if (strcmp(mode_str, "ntsc") == 0) {
1799                 *timings = omap_dss_ntsc_timings;
1800                 *bpp = 0;
1801                 return 0;
1802         }
1803 #endif
1804
1805         /* this is quite a hack, but I wanted to use the modedb and for
1806          * that we need fb_info and var, so we create dummy ones */
1807
1808         memset(&fbi, 0, sizeof(fbi));
1809         memset(&var, 0, sizeof(var));
1810         memset(&fbops, 0, sizeof(fbops));
1811         fbi.fbops = &fbops;
1812
1813         r = fb_find_mode(&var, &fbi, mode_str, NULL, 0, NULL, 24);
1814
1815         if (r != 0) {
1816                 timings->pixel_clock = PICOS2KHZ(var.pixclock);
1817                 timings->hfp = var.left_margin;
1818                 timings->hbp = var.right_margin;
1819                 timings->vfp = var.upper_margin;
1820                 timings->vbp = var.lower_margin;
1821                 timings->hsw = var.hsync_len;
1822                 timings->vsw = var.vsync_len;
1823                 timings->x_res = var.xres;
1824                 timings->y_res = var.yres;
1825
1826                 switch (var.bits_per_pixel) {
1827                 case 16:
1828                         *bpp = 16;
1829                         break;
1830                 case 24:
1831                 case 32:
1832                 default:
1833                         *bpp = 24;
1834                         break;
1835                 }
1836
1837                 return 0;
1838         } else {
1839                 return -EINVAL;
1840         }
1841 }
1842
1843 static int omapfb_set_def_mode(struct omap_display *display, char *mode_str)
1844 {
1845         int r;
1846         u8 bpp;
1847         struct omap_video_timings timings;
1848
1849         r = omapfb_mode_to_timings(mode_str, &timings, &bpp);
1850         if (r)
1851                 return r;
1852
1853         display->panel->recommended_bpp = bpp;
1854
1855         if (!display->check_timings || !display->set_timings)
1856                 return -EINVAL;
1857
1858         r = display->check_timings(display, &timings);
1859         if (r)
1860                 return r;
1861
1862         display->set_timings(display, &timings);
1863
1864         return 0;
1865 }
1866
1867 static int omapfb_parse_def_modes(struct omapfb2_device *fbdev)
1868 {
1869         char *str, *options, *this_opt;
1870         int r = 0;
1871
1872         str = kmalloc(strlen(def_mode) + 1, GFP_KERNEL);
1873         strcpy(str, def_mode);
1874         options = str;
1875
1876         while (!r && (this_opt = strsep(&options, ",")) != NULL) {
1877                 char *p, *display_str, *mode_str;
1878                 struct omap_display *display;
1879                 int i;
1880
1881                 p = strchr(this_opt, ':');
1882                 if (!p) {
1883                         r = -EINVAL;
1884                         break;
1885                 }
1886
1887                 *p = 0;
1888                 display_str = this_opt;
1889                 mode_str = p + 1;
1890
1891                 display = NULL;
1892                 for (i = 0; i < fbdev->num_displays; ++i) {
1893                         if (strcmp(fbdev->displays[i]->name,
1894                                                 display_str) == 0) {
1895                                 display = fbdev->displays[i];
1896                                 break;
1897                         }
1898                 }
1899
1900                 if (!display) {
1901                         r = -EINVAL;
1902                         break;
1903                 }
1904
1905                 r = omapfb_set_def_mode(display, mode_str);
1906                 if (r)
1907                         break;
1908         }
1909
1910         kfree(str);
1911
1912         return r;
1913 }
1914
1915 static int omapfb_probe(struct platform_device *pdev)
1916 {
1917         struct omapfb2_device *fbdev = NULL;
1918         int r = 0;
1919         int i, t;
1920         struct omap_overlay *ovl;
1921         struct omap_display *def_display;
1922
1923         DBG("omapfb_probe\n");
1924
1925         if (pdev->num_resources != 0) {
1926                 dev_err(&pdev->dev, "probed for an unknown device\n");
1927                 r = -ENODEV;
1928                 goto err0;
1929         }
1930
1931         fbdev = kzalloc(sizeof(struct omapfb2_device), GFP_KERNEL);
1932         if (fbdev == NULL) {
1933                 r = -ENOMEM;
1934                 goto err0;
1935         }
1936
1937         mutex_init(&fbdev->mtx);
1938
1939         fbdev->dev = &pdev->dev;
1940         platform_set_drvdata(pdev, fbdev);
1941
1942         fbdev->num_displays = 0;
1943         t = omap_dss_get_num_displays();
1944         for (i = 0; i < t; i++) {
1945                 struct omap_display *display;
1946                 display = omap_dss_get_display(i);
1947                 if (!display) {
1948                         dev_err(&pdev->dev, "can't get display %d\n", i);
1949                         r = -EINVAL;
1950                         goto cleanup;
1951                 }
1952
1953                 fbdev->displays[fbdev->num_displays++] = display;
1954         }
1955
1956         if (fbdev->num_displays == 0) {
1957                 dev_err(&pdev->dev, "no displays\n");
1958                 r = -EINVAL;
1959                 goto cleanup;
1960         }
1961
1962         fbdev->num_overlays = omap_dss_get_num_overlays();
1963         for (i = 0; i < fbdev->num_overlays; i++)
1964                 fbdev->overlays[i] = omap_dss_get_overlay(i);
1965
1966         fbdev->num_managers = omap_dss_get_num_overlay_managers();
1967         for (i = 0; i < fbdev->num_managers; i++)
1968                 fbdev->managers[i] = omap_dss_get_overlay_manager(i);
1969
1970
1971         /* gfx overlay should be the default one. find a display
1972          * connected to that, and use it as default display */
1973         ovl = omap_dss_get_overlay(0);
1974         if (ovl->manager && ovl->manager->display) {
1975                 def_display = ovl->manager->display;
1976         } else {
1977                 dev_err(&pdev->dev, "cannot find default display\n");
1978                 r = -EINVAL;
1979                 goto cleanup;
1980         }
1981
1982         if (def_mode && strlen(def_mode) > 0) {
1983                 if (omapfb_parse_def_modes(fbdev))
1984                         dev_err(&pdev->dev, "cannot parse default modes\n");
1985         }
1986
1987         r = omapfb_create_framebuffers(fbdev);
1988         if (r)
1989                 goto cleanup;
1990
1991         for (i = 0; i < fbdev->num_managers; i++) {
1992                 struct omap_overlay_manager *mgr;
1993                 mgr = fbdev->managers[i];
1994                 r = mgr->apply(mgr);
1995                 if (r) {
1996                         dev_err(fbdev->dev, "failed to apply dispc config\n");
1997                         goto cleanup;
1998                 }
1999         }
2000
2001         DBG("mgr->apply'ed\n");
2002
2003         r = def_display->enable(def_display);
2004         if (r) {
2005                 dev_err(fbdev->dev, "Failed to enable display '%s'\n",
2006                                 def_display->name);
2007                 goto cleanup;
2008         }
2009
2010         /* set the update mode */
2011         if (def_display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
2012 #ifdef CONFIG_FB_OMAP2_FORCE_AUTO_UPDATE
2013                 if (def_display->set_update_mode)
2014                         def_display->set_update_mode(def_display,
2015                                         OMAP_DSS_UPDATE_AUTO);
2016                 if (def_display->enable_te)
2017                         def_display->enable_te(def_display, 1);
2018 #else
2019                 if (def_display->set_update_mode)
2020                         def_display->set_update_mode(def_display,
2021                                         OMAP_DSS_UPDATE_MANUAL);
2022                 if (def_display->enable_te)
2023                         def_display->enable_te(def_display, 0);
2024 #endif
2025         } else {
2026                 if (def_display->set_update_mode)
2027                         def_display->set_update_mode(def_display,
2028                                         OMAP_DSS_UPDATE_AUTO);
2029         }
2030
2031         for (i = 0; i < fbdev->num_displays; i++) {
2032                 struct omap_display *display = fbdev->displays[i];
2033                 u16 w, h;
2034
2035                 if (!display->get_update_mode || !display->update)
2036                         continue;
2037
2038                 if (display->get_update_mode(display) ==
2039                                 OMAP_DSS_UPDATE_MANUAL) {
2040
2041                         display->get_resolution(display, &w, &h);
2042                         display->update(display, 0, 0, w, h);
2043                 }
2044         }
2045
2046         DBG("display->updated\n");
2047
2048         return 0;
2049
2050 cleanup:
2051         omapfb_free_resources(fbdev);
2052 err0:
2053         dev_err(&pdev->dev, "failed to setup omapfb\n");
2054         return r;
2055 }
2056
2057 static int omapfb_remove(struct platform_device *pdev)
2058 {
2059         struct omapfb2_device *fbdev = platform_get_drvdata(pdev);
2060
2061         /* FIXME: wait till completion of pending events */
2062
2063         omapfb_remove_sysfs(fbdev);
2064
2065         omapfb_free_resources(fbdev);
2066
2067         return 0;
2068 }
2069
2070 static struct platform_driver omapfb_driver = {
2071         .probe          = omapfb_probe,
2072         .remove         = omapfb_remove,
2073         .driver         = {
2074                 .name   = "omapfb",
2075                 .owner  = THIS_MODULE,
2076         },
2077 };
2078
2079 static int __init omapfb_init(void)
2080 {
2081         DBG("omapfb_init\n");
2082
2083         if (platform_driver_register(&omapfb_driver)) {
2084                 printk(KERN_ERR "failed to register omapfb driver\n");
2085                 return -ENODEV;
2086         }
2087
2088         return 0;
2089 }
2090
2091 static void __exit omapfb_exit(void)
2092 {
2093         DBG("omapfb_exit\n");
2094         platform_driver_unregister(&omapfb_driver);
2095 }
2096
2097 module_param_named(mode, def_mode, charp, 0);
2098 module_param_named(vram, def_vram, charp, 0);
2099 module_param_named(rotate, def_rotate, int, 0);
2100 module_param_named(vrfb, def_vrfb, bool, 0);
2101 module_param_named(mirror, def_mirror, bool, 0);
2102
2103 /* late_initcall to let panel/ctrl drivers loaded first.
2104  * I guess better option would be a more dynamic approach,
2105  * so that omapfb reacts to new panels when they are loaded */
2106 late_initcall(omapfb_init);
2107 /*module_init(omapfb_init);*/
2108 module_exit(omapfb_exit);
2109
2110 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
2111 MODULE_DESCRIPTION("OMAP2/3 Framebuffer");
2112 MODULE_LICENSE("GPL v2");