Fedora kernel-2.6.17-1.2142_FC4 patched with stable patch-2.6.17.4-vs2.0.2-rc26.diff

[linux-2.6.git] / drivers / video / gbefb.c

diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index 2a02328..5e25b98 100644 (file)
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -11,7 +11,7 @@
 
 #include <linux/config.h>
 #include <linux/delay.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/errno.h>
 #include <linux/fb.h>
@@ -656,12 +656,15 @@ static int gbefb_set_par(struct fb_info *info)
        switch (bytesPerPixel) {
        case 1:
                SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_I8);
+               info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
                break;
        case 2:
                SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_ARGB5);
+               info->fix.visual = FB_VISUAL_TRUECOLOR;
                break;
        case 4:
                SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_RGB8);
+               info->fix.visual = FB_VISUAL_TRUECOLOR;
                break;
        }
        SET_GBE_FIELD(WID, BUF, val, GBE_BMODE_BOTH);
@@ -979,7 +982,7 @@ static int gbefb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
        return 0;
 }
 
-static int gbefb_mmap(struct fb_info *info, struct file *file,
+static int gbefb_mmap(struct fb_info *info,
                        struct vm_area_struct *vma)
 {
        unsigned long size = vma->vm_end - vma->vm_start;
@@ -1000,7 +1003,6 @@ static int gbefb_mmap(struct fb_info *info, struct file *file,
                pgprot_fb(pgprot_val(vma->vm_page_prot));
 
        vma->vm_flags |= VM_IO | VM_RESERVED;
-       vma->vm_file = file;
 
        /* look for the starting tile */
        tile = &gbe_tiles.cpu[offset >> TILE_SHIFT];
@@ -1038,21 +1040,20 @@ static struct fb_ops gbefb_ops = {
        .fb_fillrect    = cfb_fillrect,
        .fb_copyarea    = cfb_copyarea,
        .fb_imageblit   = cfb_imageblit,
-       .fb_cursor      = soft_cursor,
 };
 
 /*
  * sysfs
  */
 
-static ssize_t gbefb_show_memsize(struct device *dev, char *buf)
+static ssize_t gbefb_show_memsize(struct device *dev, struct device_attribute *attr, char *buf)
 {
        return snprintf(buf, PAGE_SIZE, "%d\n", gbe_mem_size);
 }
 
 static DEVICE_ATTR(size, S_IRUGO, gbefb_show_memsize, NULL);
 
-static ssize_t gbefb_show_rev(struct device *device, char *buf)
+static ssize_t gbefb_show_rev(struct device *device, struct device_attribute *attr, char *buf)
 {
        return snprintf(buf, PAGE_SIZE, "%d\n", gbe_revision);
 }
@@ -1106,12 +1107,11 @@ int __init gbefb_setup(char *options)
        return 0;
 }
 
-static int __init gbefb_probe(struct device *dev)
+static int __init gbefb_probe(struct platform_device *p_dev)
 {
        int i, ret = 0;
        struct fb_info *info;
        struct gbefb_par *par;
-       struct platform_device *p_dev = to_platform_device(dev);
 #ifndef MODULE
        char *options = NULL;
 #endif
@@ -1126,7 +1126,7 @@ static int __init gbefb_probe(struct device *dev)
        gbefb_setup(options);
 #endif
 
-       if (!request_mem_region(GBE_BASE, sizeof(struct sgi_gbe), "GBE")) {
+       if (!request_region(GBE_BASE, sizeof(struct sgi_gbe), "GBE")) {
                printk(KERN_ERR "gbefb: couldn't reserve mmio region\n");
                ret = -EBUSY;
                goto out_release_framebuffer;
@@ -1152,12 +1152,24 @@ static int __init gbefb_probe(struct device *dev)
        if (gbe_mem_phys) {
                /* memory was allocated at boot time */
                gbe_mem = ioremap_nocache(gbe_mem_phys, gbe_mem_size);
+               if (!gbe_mem) {
+                       printk(KERN_ERR "gbefb: couldn't map framebuffer\n");
+                       ret = -ENOMEM;
+                       goto out_tiles_free;
+               }
+
                gbe_dma_addr = 0;
        } else {
                /* try to allocate memory with the classical allocator
                 * this has high chance to fail on low memory machines */
                gbe_mem = dma_alloc_coherent(NULL, gbe_mem_size, &gbe_dma_addr,
                                             GFP_KERNEL);
+               if (!gbe_mem) {
+                       printk(KERN_ERR "gbefb: couldn't allocate framebuffer memory\n");
+                       ret = -ENOMEM;
+                       goto out_tiles_free;
+               }
+
                gbe_mem_phys = (unsigned long) gbe_dma_addr;
        }
 
@@ -1165,12 +1177,6 @@ static int __init gbefb_probe(struct device *dev)
        mtrr_add(gbe_mem_phys, gbe_mem_size, MTRR_TYPE_WRCOMB, 1);
 #endif
 
-       if (!gbe_mem) {
-               printk(KERN_ERR "gbefb: couldn't map framebuffer\n");
-               ret = -ENXIO;
-               goto out_tiles_free;
-       }
-
        /* map framebuffer memory into tiles table */
        for (i = 0; i < (gbe_mem_size >> TILE_SHIFT); i++)
                gbe_tiles.cpu[i] = (gbe_mem_phys >> TILE_SHIFT) + i;
@@ -1199,8 +1205,8 @@ static int __init gbefb_probe(struct device *dev)
                goto out_gbe_unmap;
        }
 
-       dev_set_drvdata(&p_dev->dev, info);
-       gbefb_create_sysfs(dev);
+       platform_set_drvdata(p_dev, info);
+       gbefb_create_sysfs(&p_dev->dev);
 
        printk(KERN_INFO "fb%d: %s rev %d @ 0x%08x using %dkB memory\n",
               info->node, info->fix.id, gbe_revision, (unsigned) GBE_BASE,
@@ -1226,10 +1232,9 @@ out_release_framebuffer:
        return ret;
 }
 
-static int __devexit gbefb_remove(struct device* dev)
+static int __devexit gbefb_remove(struct platform_device* p_dev)
 {
-       struct platform_device *p_dev = to_platform_device(dev);
-       struct fb_info *info = dev_get_drvdata(&p_dev->dev);
+       struct fb_info *info = platform_get_drvdata(p_dev);
 
        unregister_framebuffer(info);
        gbe_turn_off();
@@ -1241,37 +1246,44 @@ static int __devexit gbefb_remove(struct device* dev)
                          (void *)gbe_tiles.cpu, gbe_tiles.dma);
        release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
        iounmap(gbe);
-       gbefb_remove_sysfs(dev);
+       gbefb_remove_sysfs(&p_dev->dev);
        framebuffer_release(info);
 
        return 0;
 }
 
-static struct device_driver gbefb_driver = {
-       .name = "gbefb",
-       .bus = &platform_bus_type,
+static struct platform_driver gbefb_driver = {
        .probe = gbefb_probe,
        .remove = __devexit_p(gbefb_remove),
+       .driver = {
+               .name = "gbefb",
+       },
 };
 
-static struct platform_device gbefb_device = {
-       .name = "gbefb",
-};
+static struct platform_device *gbefb_device;
 
 int __init gbefb_init(void)
 {
-       int ret = driver_register(&gbefb_driver);
+       int ret = platform_driver_register(&gbefb_driver);
        if (!ret) {
-               ret = platform_device_register(&gbefb_device);
-               if (ret)
-                       driver_unregister(&gbefb_driver);
+               gbefb_device = platform_device_alloc("gbefb", 0);
+               if (gbefb_device) {
+                       ret = platform_device_add(gbefb_device);
+               } else {
+                       ret = -ENOMEM;
+               }
+               if (ret) {
+                       platform_device_put(gbefb_device);
+                       platform_driver_unregister(&gbefb_driver);
+               }
        }
        return ret;
 }
 
 void __exit gbefb_exit(void)
 {
-        driver_unregister(&gbefb_driver);
+       platform_device_unregister(gbefb_device);
+       platform_driver_unregister(&gbefb_driver);
 }
 
 module_init(gbefb_init);