API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 8th, 2008
319
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 50.63 KB | None | 0 0
raw download clone embed print report
  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");
  1989.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!