Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

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