2.6.x-SGI_VW-fbdev-lkml.patch

   1 --- linus-2.6/drivers/video/sgivwfb.c   2004-02-18 20:59:08.000000000 -0800
   2 +++ fbdev-2.6/drivers/video/sgivwfb.c   2004-02-19 16:11:44.000000000 -0800
   3 @@ -22,7 +22,7 @@
   4  #include <asm/mtrr.h>
   5
   6  #define INCLUDE_TIMING_TABLE_DATA
   7 -#define DBE_REG_BASE default_par.regs
   8 +#define DBE_REG_BASE par->regs
   9  #include <video/sgivw.h>
  10
  11  struct sgivw_par {
  12 @@ -44,9 +44,6 @@
  13  extern unsigned long sgivwfb_mem_phys;
  14  extern unsigned long sgivwfb_mem_size;
  15
  16 -static struct sgivw_par default_par;
  17 -static u32 pseudo_palette[17];
  18 -static struct fb_info fb_info;
  19  static int ypan = 0;
  20  static int ywrap = 0;
  21
  22 @@ -162,7 +159,7 @@
  23   *              console.
  24   */
  25
  26 -static void dbe_TurnOffDma(void)
  27 +static void dbe_TurnOffDma(struct sgivw_par *par)
  28  {
  29         unsigned int readVal;
  30         int i;
  31 @@ -367,7 +364,7 @@
  32  /*
  33   *  Setup flatpanel related registers.
  34   */
  35 -static void sgivwfb_setup_flatpanel(struct dbe_timing_info *currentTiming)
  36 +static void sgivwfb_setup_flatpanel(struct sgivw_par *par, struct dbe_timing_info *currentTiming)
  37  {
  38         int fp_wid, fp_hgt, fp_vbs, fp_vbe;
  39         u32 outputVal = 0;
  40 @@ -429,7 +426,7 @@
  41         /* Turn on dotclock PLL */
  42         DBE_SETREG(ctrlstat, 0x20000000);
  43
  44 -       dbe_TurnOffDma();
  45 +       dbe_TurnOffDma(par);
  46
  47         /* dbe_CalculateScreenParams(); */
  48         maxPixelsPerTileX = 512 / bytesPerPixel;
  49 @@ -453,7 +450,7 @@
  50                 DBE_SETREG(vt_xy, 0x00000000);
  51                 udelay(1);
  52         } else
  53 -               dbe_TurnOffDma();
  54 +               dbe_TurnOffDma(par);
  55
  56         /* dbe_Initdbe(); */
  57         for (i = 0; i < 256; i++) {
  58 @@ -567,7 +564,7 @@
  59         DBE_SETREG(vt_hcmap, outputVal);
  60
  61         if (flatpanel_id != -1)
  62 -               sgivwfb_setup_flatpanel(currentTiming);
  63 +               sgivwfb_setup_flatpanel(par, currentTiming);
  64
  65         outputVal = 0;
  66         temp = currentTiming->vblank_start - currentTiming->vblank_end - 1;
  67 @@ -752,16 +749,30 @@
  68  /*
  69   *  Initialisation
  70   */
  71 -int __init sgivwfb_init(void)
  72 +static void sgivwfb_release(struct device *device)
  73 +{
  74 +}
  75 +
  76 +static int __init sgivwfb_probe(struct device *device)
  77  {
  78 +       struct platform_device *dev = to_platform_device(device);
  79 +       struct sgivw_par *par;
  80 +       struct fb_info *info;
  81         char *monitor;
  82
  83 +       info = framebuffer_alloc(sizeof(struct sgivw_par) + sizeof(u32) * 256, &dev->dev);
  84 +       if (!info)
  85 +               return -ENOMEM;
  86 +       par = info->par;
  87 +
  88         if (!request_mem_region(DBE_REG_PHYS, DBE_REG_SIZE, "sgivwfb")) {
  89                 printk(KERN_ERR "sgivwfb: couldn't reserve mmio region\n");
  90 +               framebuffer_release(info);
  91                 return -EBUSY;
  92         }
  93 -       default_par.regs = (struct asregs *) ioremap_nocache(DBE_REG_PHYS, DBE_REG_SIZE);
  94 -       if (!default_par.regs) {
  95 +
  96 +       par->regs = (struct asregs *) ioremap_nocache(DBE_REG_PHYS, DBE_REG_SIZE);
  97 +       if (!par->regs) {
  98                 printk(KERN_ERR "sgivwfb: couldn't ioremap registers\n");
  99                 goto fail_ioremap_regs;
 100         }
 101 @@ -773,66 +784,110 @@
 102         sgivwfb_fix.ywrapstep = ywrap;
 103         sgivwfb_fix.ypanstep = ypan;
 104
 105 -       fb_info.fix = sgivwfb_fix;
 106 +       info->fix = sgivwfb_fix;
 107
 108         switch (flatpanel_id) {
 109                 case FLATPANEL_SGI_1600SW:
 110 -                       fb_info.var = sgivwfb_var1600sw;
 111 +                       info->var = sgivwfb_var1600sw;
 112                         monitor = "SGI 1600SW flatpanel";
 113                         break;
 114                 default:
 115 -                       fb_info.var = sgivwfb_var;
 116 +                       info->var = sgivwfb_var;
 117                         monitor = "CRT";
 118         }
 119
 120         printk(KERN_INFO "sgivwfb: %s monitor selected\n", monitor);
 121
 122 -       fb_info.fbops = &sgivwfb_ops;
 123 -       fb_info.pseudo_palette = pseudo_palette;
 124 -       fb_info.par = &default_par;
 125 -       fb_info.flags = FBINFO_FLAG_DEFAULT;
 126 +       info->fbops = &sgivwfb_ops;
 127 +       info->pseudo_palette = (void *) (par + 1);
 128 +       info->flags = FBINFO_FLAG_DEFAULT;
 129
 130 -       fb_info.screen_base = ioremap_nocache((unsigned long) sgivwfb_mem_phys, sgivwfb_mem_size);
 131 -       if (!fb_info.screen_base) {
 132 +       info->screen_base = ioremap_nocache((unsigned long) sgivwfb_mem_phys, sgivwfb_mem_size);
 133 +       if (!info->screen_base) {
 134                 printk(KERN_ERR "sgivwfb: couldn't ioremap screen_base\n");
 135                 goto fail_ioremap_fbmem;
 136         }
 137
 138 -       fb_alloc_cmap(&fb_info.cmap, 256, 0);
 139 +       if (fb_alloc_cmap(&info->cmap, 256, 0) < 0)
 140 +               goto fail_color_map;
 141
 142 -       if (register_framebuffer(&fb_info) < 0) {
 143 +       if (register_framebuffer(info) < 0) {
 144                 printk(KERN_ERR "sgivwfb: couldn't register framebuffer\n");
 145                 goto fail_register_framebuffer;
 146         }
 147
 148 +       dev_set_drvdata(&dev->dev, info);
 149 +
 150         printk(KERN_INFO "fb%d: SGI DBE frame buffer device, using %ldK of video memory at %#lx\n",
 151 -               fb_info.node, sgivwfb_mem_size >> 10, sgivwfb_mem_phys);
 152 +               info->node, sgivwfb_mem_size >> 10, sgivwfb_mem_phys);
 153         return 0;
 154 -
 155 +
 156  fail_register_framebuffer:
 157 -       iounmap((char *) fb_info.screen_base);
 158 +       fb_dealloc_cmap(&info->cmap);
 159 +fail_color_map:
 160 +       iounmap((char *) info->screen_base);
 161  fail_ioremap_fbmem:
 162 -       iounmap(default_par.regs);
 163 +       iounmap(par->regs);
 164  fail_ioremap_regs:
 165         release_mem_region(DBE_REG_PHYS, DBE_REG_SIZE);
 166 +       framebuffer_release(info);
 167         return -ENXIO;
 168  }
 169
 170 -#ifdef MODULE
 171 -MODULE_LICENSE("GPL");
 172 +static int sgivwfb_remove(struct device *device)
 173 +{
 174 +       struct fb_info *info = dev_get_drvdata(device);
 175 +
 176 +       if (info) {
 177 +               struct sgivw_par *par = info->par;
 178 +
 179 +               unregister_framebuffer(info);
 180 +               dbe_TurnOffDma(par);
 181 +               iounmap(par->regs);
 182 +               iounmap(info->screen_base);
 183 +               release_mem_region(DBE_REG_PHYS, DBE_REG_SIZE);
 184 +       }
 185 +       return 0;
 186 +}
 187 +
 188 +static struct device_driver sgivwfb_driver = {
 189 +       .name   = "sgivwfb",
 190 +       .bus    = &platform_bus_type,
 191 +       .probe  = sgivwfb_probe,
 192 +       .remove = sgivwfb_remove,
 193 +};
 194 +
 195 +static struct platform_device sgivwfb_device = {
 196 +       .name   = "sgivwfb",
 197 +       .id     = 0,
 198 +       .dev    = {
 199 +               .release = sgivwfb_release,
 200 +       }
 201 +};
 202
 203 -int init_module(void)
 204 +int __init sgivwfb_init(void)
 205  {
 206 -       return sgivwfb_init();
 207 +       int ret;
 208 +
 209 +       ret = driver_register(&sgivwfb_driver);
 210 +       if (!ret) {
 211 +               ret = platform_device_register(&sgivwfb_device);
 212 +               if (ret)
 213 +                       driver_unregister(&sgivwfb_driver);
 214 +       }
 215 +       return ret;
 216  }
 217
 218 -void cleanup_module(void)
 219 +#ifdef MODULE
 220 +MODULE_LICENSE("GPL");
 221 +
 222 +static void __exit sgivwfb_exit(void)
 223  {
 224 -       unregister_framebuffer(&fb_info);
 225 -       dbe_TurnOffDma();
 226 -       iounmap(regs);
 227 -       iounmap(&fb_info.screen_base);
 228 -       release_mem_region(DBE_REG_PHYS, DBE_REG_SIZE);
 229 +       platform_device_unregister(&sgivwfb_device);
 230 +       driver_unregister(&sgivwfb_driver);
 231  }
 232
 233 +module_init(sgivwfb_init);
 234 +module_exit(sgivwfb_exit);
 235 +
 236  #endif                         /* MODULE */