include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...

[net-next-2.6.git] / drivers / video / omap2 / omapfb / omapfb-main.c

diff --git a/drivers/video/omap2/omapfb/omapfb-main.c b/drivers/video/omap2/omapfb/omapfb-main.c
index d17caef6915a96006c97c04f9e9768f88515ca2a..4b4506da96da360ad706f0fbc59716dd8013cd8d 100644 (file)
--- a/drivers/video/omap2/omapfb/omapfb-main.c
+++ b/drivers/video/omap2/omapfb/omapfb-main.c
@@ -22,6 +22,7 @@
 
 #include <linux/module.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/fb.h>
 #include <linux/dma-mapping.h>
 #include <linux/vmalloc.h>
@@ -54,6 +55,8 @@ module_param_named(test, omapfb_test_pattern, bool, 0644);
 #endif
 
 static int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi);
+static int omapfb_get_recommended_bpp(struct omapfb2_device *fbdev,
+               struct omap_dss_device *dssdev);
 
 #ifdef DEBUG
 static void draw_pixel(struct fb_info *fbi, int x, int y, unsigned color)
@@ -152,9 +155,9 @@ static void fill_fb(struct fb_info *fbi)
 }
 #endif
 
-static unsigned omapfb_get_vrfb_offset(struct omapfb_info *ofbi, int rot)
+static unsigned omapfb_get_vrfb_offset(const struct omapfb_info *ofbi, int rot)
 {
-       struct vrfb *vrfb = &ofbi->region.vrfb;
+       const struct vrfb *vrfb = &ofbi->region.vrfb;
        unsigned offset;
 
        switch (rot) {
@@ -179,7 +182,7 @@ static unsigned omapfb_get_vrfb_offset(struct omapfb_info *ofbi, int rot)
        return offset;
 }
 
-static u32 omapfb_get_region_rot_paddr(struct omapfb_info *ofbi, int rot)
+static u32 omapfb_get_region_rot_paddr(const struct omapfb_info *ofbi, int rot)
 {
        if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
                return ofbi->region.vrfb.paddr[rot]
@@ -189,7 +192,7 @@ static u32 omapfb_get_region_rot_paddr(struct omapfb_info *ofbi, int rot)
        }
 }
 
-static u32 omapfb_get_region_paddr(struct omapfb_info *ofbi)
+static u32 omapfb_get_region_paddr(const struct omapfb_info *ofbi)
 {
        if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
                return ofbi->region.vrfb.paddr[0];
@@ -197,7 +200,7 @@ static u32 omapfb_get_region_paddr(struct omapfb_info *ofbi)
                return ofbi->region.paddr;
 }
 
-static void __iomem *omapfb_get_region_vaddr(struct omapfb_info *ofbi)
+static void __iomem *omapfb_get_region_vaddr(const struct omapfb_info *ofbi)
 {
        if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
                return ofbi->region.vrfb.vaddr[0];
@@ -703,9 +706,9 @@ int check_fb_var(struct fb_info *fbi, struct fb_var_screeninfo *var)
        var->width              = -1;
        var->grayscale          = 0;
 
-       if (display && display->get_timings) {
+       if (display && display->driver->get_timings) {
                struct omap_video_timings timings;
-               display->get_timings(display, &timings);
+               display->driver->get_timings(display, &timings);
 
                /* pixclock in ps, the rest in pixclock */
                var->pixclock = timings.pixel_clock != 0 ?
@@ -778,8 +781,8 @@ static int omapfb_release(struct fb_info *fbi, int user)
        return 0;
 }
 
-static unsigned calc_rotation_offset_dma(struct fb_var_screeninfo *var,
-               struct fb_fix_screeninfo *fix, int rotation)
+static unsigned calc_rotation_offset_dma(const struct fb_var_screeninfo *var,
+               const struct fb_fix_screeninfo *fix, int rotation)
 {
        unsigned offset;
 
@@ -789,8 +792,8 @@ static unsigned calc_rotation_offset_dma(struct fb_var_screeninfo *var,
        return offset;
 }
 
-static unsigned calc_rotation_offset_vrfb(struct fb_var_screeninfo *var,
-               struct fb_fix_screeninfo *fix, int rotation)
+static unsigned calc_rotation_offset_vrfb(const struct fb_var_screeninfo *var,
+               const struct fb_fix_screeninfo *fix, int rotation)
 {
        unsigned offset;
 
@@ -1221,11 +1224,11 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
                if (display->state != OMAP_DSS_DISPLAY_SUSPENDED)
                        goto exit;
 
-               if (display->resume)
-                       r = display->resume(display);
+               if (display->driver->resume)
+                       r = display->driver->resume(display);
 
-               if (r == 0 && display->get_update_mode &&
-                               display->get_update_mode(display) ==
+               if (r == 0 && display->driver->get_update_mode &&
+                               display->driver->get_update_mode(display) ==
                                OMAP_DSS_UPDATE_MANUAL)
                        do_update = 1;
 
@@ -1240,8 +1243,8 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
                if (display->state != OMAP_DSS_DISPLAY_ACTIVE)
                        goto exit;
 
-               if (display->suspend)
-                       r = display->suspend(display);
+               if (display->driver->suspend)
+                       r = display->driver->suspend(display);
 
                break;
 
@@ -1252,11 +1255,11 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
 exit:
        omapfb_unlock(fbdev);
 
-       if (r == 0 && do_update && display->update) {
+       if (r == 0 && do_update && display->driver->update) {
                u16 w, h;
-               display->get_resolution(display, &w, &h);
+               display->driver->get_resolution(display, &w, &h);
 
-               r = display->update(display, 0, 0, w, h);
+               r = display->driver->update(display, 0, 0, w, h);
        }
 
        return r;
@@ -1404,6 +1407,7 @@ static int omapfb_alloc_fbmem_display(struct fb_info *fbi, unsigned long size,
                unsigned long paddr)
 {
        struct omapfb_info *ofbi = FB2OFB(fbi);
+       struct omapfb2_device *fbdev = ofbi->fbdev;
        struct omap_dss_device *display;
        int bytespp;
 
@@ -1412,7 +1416,7 @@ static int omapfb_alloc_fbmem_display(struct fb_info *fbi, unsigned long size,
        if (!display)
                return 0;
 
-       switch (display->get_recommended_bpp(display)) {
+       switch (omapfb_get_recommended_bpp(fbdev, display)) {
        case 16:
                bytespp = 2;
                break;
@@ -1427,7 +1431,7 @@ static int omapfb_alloc_fbmem_display(struct fb_info *fbi, unsigned long size,
        if (!size) {
                u16 w, h;
 
-               display->get_resolution(display, &w, &h);
+               display->driver->get_resolution(display, &w, &h);
 
                if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB) {
                        size = max(omap_vrfb_min_phys_size(w, h, bytespp),
@@ -1636,8 +1640,8 @@ int omapfb_realloc_fbmem(struct fb_info *fbi, unsigned long size, int type)
        if (old_size == size && old_type == type)
                return 0;
 
-       if (display && display->sync)
-                       display->sync(display);
+       if (display && display->driver->sync)
+                       display->driver->sync(display);
 
        omapfb_free_fbmem(fbi);
 
@@ -1745,7 +1749,7 @@ static int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi)
                u16 w, h;
                int rotation = (var->rotate + ofbi->rotation[0]) % 4;
 
-               display->get_resolution(display, &w, &h);
+               display->driver->get_resolution(display, &w, &h);
 
                if (rotation == FB_ROTATE_CW ||
                                rotation == FB_ROTATE_CCW) {
@@ -1760,7 +1764,7 @@ static int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi)
                var->yres_virtual = var->yres;
 
                if (!var->bits_per_pixel) {
-                       switch (display->get_recommended_bpp(display)) {
+                       switch (omapfb_get_recommended_bpp(fbdev, display)) {
                        case 16:
                                var->bits_per_pixel = 16;
                                break;
@@ -1828,7 +1832,7 @@ static void omapfb_free_resources(struct omapfb2_device *fbdev)
 
        for (i = 0; i < fbdev->num_displays; i++) {
                if (fbdev->displays[i]->state != OMAP_DSS_DISPLAY_DISABLED)
-                       fbdev->displays[i]->disable(fbdev->displays[i]);
+                       fbdev->displays[i]->driver->disable(fbdev->displays[i]);
 
                omap_dss_put_device(fbdev->displays[i]);
        }
@@ -2011,7 +2015,8 @@ static int omapfb_mode_to_timings(const char *mode_str,
        }
 }
 
-static int omapfb_set_def_mode(struct omap_dss_device *display, char *mode_str)
+static int omapfb_set_def_mode(struct omapfb2_device *fbdev,
+               struct omap_dss_device *display, char *mode_str)
 {
        int r;
        u8 bpp;
@@ -2021,20 +2026,37 @@ static int omapfb_set_def_mode(struct omap_dss_device *display, char *mode_str)
        if (r)
                return r;
 
-       display->panel.recommended_bpp = bpp;
+       fbdev->bpp_overrides[fbdev->num_bpp_overrides].dssdev = display;
+       fbdev->bpp_overrides[fbdev->num_bpp_overrides].bpp = bpp;
+       ++fbdev->num_bpp_overrides;
 
-       if (!display->check_timings || !display->set_timings)
+       if (!display->driver->check_timings || !display->driver->set_timings)
                return -EINVAL;
 
-       r = display->check_timings(display, &timings);
+       r = display->driver->check_timings(display, &timings);
        if (r)
                return r;
 
-       display->set_timings(display, &timings);
+       display->driver->set_timings(display, &timings);
 
        return 0;
 }
 
+static int omapfb_get_recommended_bpp(struct omapfb2_device *fbdev,
+               struct omap_dss_device *dssdev)
+{
+       int i;
+
+       BUG_ON(dssdev->driver->get_recommended_bpp == NULL);
+
+       for (i = 0; i < fbdev->num_bpp_overrides; ++i) {
+               if (dssdev == fbdev->bpp_overrides[i].dssdev)
+                       return fbdev->bpp_overrides[i].bpp;
+       }
+
+       return dssdev->driver->get_recommended_bpp(dssdev);
+}
+
 static int omapfb_parse_def_modes(struct omapfb2_device *fbdev)
 {
        char *str, *options, *this_opt;
@@ -2073,7 +2095,7 @@ static int omapfb_parse_def_modes(struct omapfb2_device *fbdev)
                        break;
                }
 
-               r = omapfb_set_def_mode(display, mode_str);
+               r = omapfb_set_def_mode(fbdev, display, mode_str);
                if (r)
                        break;
        }
@@ -2111,18 +2133,23 @@ static int omapfb_probe(struct platform_device *pdev)
        fbdev->dev = &pdev->dev;
        platform_set_drvdata(pdev, fbdev);
 
+       r = 0;
        fbdev->num_displays = 0;
        dssdev = NULL;
        for_each_dss_dev(dssdev) {
                omap_dss_get_device(dssdev);
+
                if (!dssdev->driver) {
                        dev_err(&pdev->dev, "no driver for display\n");
-                       r = -EINVAL;
-                       goto cleanup;
+                       r = -ENODEV;
                }
+
                fbdev->displays[fbdev->num_displays++] = dssdev;
        }
 
+       if (r)
+               goto cleanup;
+
        if (fbdev->num_displays == 0) {
                dev_err(&pdev->dev, "no displays\n");
                r = -EINVAL;
@@ -2167,35 +2194,28 @@ static int omapfb_probe(struct platform_device *pdev)
        }
 
        if (def_display) {
-#ifndef CONFIG_FB_OMAP2_FORCE_AUTO_UPDATE
-               u16 w, h;
-#endif
-               r = def_display->enable(def_display);
-               if (r)
+               struct omap_dss_driver *dssdrv = def_display->driver;
+
+               r = def_display->driver->enable(def_display);
+               if (r) {
                        dev_warn(fbdev->dev, "Failed to enable display '%s'\n",
                                        def_display->name);
+                       goto cleanup;
+               }
 
-               /* set the update mode */
                if (def_display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
-#ifdef CONFIG_FB_OMAP2_FORCE_AUTO_UPDATE
-                       if (def_display->enable_te)
-                               def_display->enable_te(def_display, 1);
-                       if (def_display->set_update_mode)
-                               def_display->set_update_mode(def_display,
-                                               OMAP_DSS_UPDATE_AUTO);
-#else /* MANUAL_UPDATE */
-                       if (def_display->enable_te)
-                               def_display->enable_te(def_display, 0);
-                       if (def_display->set_update_mode)
-                               def_display->set_update_mode(def_display,
+                       u16 w, h;
+                       if (dssdrv->enable_te)
+                               dssdrv->enable_te(def_display, 1);
+                       if (dssdrv->set_update_mode)
+                               dssdrv->set_update_mode(def_display,
                                                OMAP_DSS_UPDATE_MANUAL);
 
-                       def_display->get_resolution(def_display, &w, &h);
-                       def_display->update(def_display, 0, 0, w, h);
-#endif
+                       dssdrv->get_resolution(def_display, &w, &h);
+                       def_display->driver->update(def_display, 0, 0, w, h);
                } else {
-                       if (def_display->set_update_mode)
-                               def_display->set_update_mode(def_display,
+                       if (dssdrv->set_update_mode)
+                               dssdrv->set_update_mode(def_display,
                                                OMAP_DSS_UPDATE_AUTO);
                }
        }