git.oblomov.eu Git - linux-2.6/blob - drivers/video/leo.c

   1 /* leo.c: LEO frame buffer driver
   2  *
   3  * Copyright (C) 2003 David S. Miller (davem@redhat.com)
   4  * Copyright (C) 1996-1999 Jakub Jelinek (jj@ultra.linux.cz)
   5  * Copyright (C) 1997 Michal Rehacek (Michal.Rehacek@st.mff.cuni.cz)
   6  *
   7  * Driver layout based loosely on tgafb.c, see that file for credits.
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/errno.h>
  13 #include <linux/string.h>
  14 #include <linux/slab.h>
  15 #include <linux/delay.h>
  16 #include <linux/init.h>
  17 #include <linux/fb.h>
  18 #include <linux/mm.h>
  19
  20 #include <asm/io.h>
  21 #include <asm/sbus.h>
  22 #include <asm/oplib.h>
  23 #include <asm/fbio.h>
  24
  25 #include "sbuslib.h"
  26
  27 /*
  28  * Local functions.
  29  */
  30
  31 static int leo_setcolreg(unsigned, unsigned, unsigned, unsigned,
  32                          unsigned, struct fb_info *);
  33 static int leo_blank(int, struct fb_info *);
  34
  35 static int leo_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
  36 static int leo_ioctl(struct inode *, struct file *, unsigned int,
  37                      unsigned long, struct fb_info *);
  38 static int leo_pan_display(struct fb_var_screeninfo *, struct fb_info *);
  39
  40 /*
  41  *  Frame buffer operations
  42  */
  43
  44 static struct fb_ops leo_ops = {
  45         .owner                  = THIS_MODULE,
  46         .fb_setcolreg           = leo_setcolreg,
  47         .fb_blank               = leo_blank,
  48         .fb_pan_display         = leo_pan_display,
  49         .fb_fillrect            = cfb_fillrect,
  50         .fb_copyarea            = cfb_copyarea,
  51         .fb_imageblit           = cfb_imageblit,
  52         .fb_mmap                = leo_mmap,
  53         .fb_ioctl               = leo_ioctl,
  54 #ifdef CONFIG_COMPAT
  55         .fb_compat_ioctl        = sbusfb_compat_ioctl,
  56 #endif
  57 };
  58
  59 #define LEO_OFF_LC_SS0_KRN      0x00200000UL
  60 #define LEO_OFF_LC_SS0_USR      0x00201000UL
  61 #define LEO_OFF_LC_SS1_KRN      0x01200000UL
  62 #define LEO_OFF_LC_SS1_USR      0x01201000UL
  63 #define LEO_OFF_LD_SS0          0x00400000UL
  64 #define LEO_OFF_LD_SS1          0x01400000UL
  65 #define LEO_OFF_LD_GBL          0x00401000UL
  66 #define LEO_OFF_LX_KRN          0x00600000UL
  67 #define LEO_OFF_LX_CURSOR       0x00601000UL
  68 #define LEO_OFF_SS0             0x00800000UL
  69 #define LEO_OFF_SS1             0x01800000UL
  70 #define LEO_OFF_UNK             0x00602000UL
  71 #define LEO_OFF_UNK2            0x00000000UL
  72
  73 #define LEO_CUR_ENABLE          0x00000080
  74 #define LEO_CUR_UPDATE          0x00000030
  75 #define LEO_CUR_PROGRESS        0x00000006
  76 #define LEO_CUR_UPDATECMAP      0x00000003
  77
  78 #define LEO_CUR_TYPE_MASK       0x00000000
  79 #define LEO_CUR_TYPE_IMAGE      0x00000020
  80 #define LEO_CUR_TYPE_CMAP       0x00000050
  81
  82 struct leo_cursor {
  83         u8              xxx0[16];
  84         volatile u32    cur_type;
  85         volatile u32    cur_misc;
  86         volatile u32    cur_cursxy;
  87         volatile u32    cur_data;
  88 };
  89
  90 #define LEO_KRN_TYPE_CLUT0      0x00001000
  91 #define LEO_KRN_TYPE_CLUT1      0x00001001
  92 #define LEO_KRN_TYPE_CLUT2      0x00001002
  93 #define LEO_KRN_TYPE_WID        0x00001003
  94 #define LEO_KRN_TYPE_UNK        0x00001006
  95 #define LEO_KRN_TYPE_VIDEO      0x00002003
  96 #define LEO_KRN_TYPE_CLUTDATA   0x00004000
  97 #define LEO_KRN_CSR_ENABLE      0x00000008
  98 #define LEO_KRN_CSR_PROGRESS    0x00000004
  99 #define LEO_KRN_CSR_UNK         0x00000002
 100 #define LEO_KRN_CSR_UNK2        0x00000001
 101
 102 struct leo_lx_krn {
 103         volatile u32    krn_type;
 104         volatile u32    krn_csr;
 105         volatile u32    krn_value;
 106 };
 107
 108 struct leo_lc_ss0_krn {
 109         volatile u32    misc;
 110         u8              xxx0[0x800-4];
 111         volatile u32    rev;
 112 };
 113
 114 struct leo_lc_ss0_usr {
 115         volatile u32    csr;
 116         volatile u32    addrspace;
 117         volatile u32    fontmsk;
 118         volatile u32    fontt;
 119         volatile u32    extent;
 120         volatile u32    src;
 121         u32             dst;
 122         volatile u32    copy;
 123         volatile u32    fill;
 124 };
 125
 126 struct leo_lc_ss1_krn {
 127         u8      unknown;
 128 };
 129
 130 struct leo_lc_ss1_usr {
 131         u8      unknown;
 132 };
 133
 134 struct leo_ld {
 135         u8              xxx0[0xe00];
 136         volatile u32    csr;
 137         volatile u32    wid;
 138         volatile u32    wmask;
 139         volatile u32    widclip;
 140         volatile u32    vclipmin;
 141         volatile u32    vclipmax;
 142         volatile u32    pickmin;        /* SS1 only */
 143         volatile u32    pickmax;        /* SS1 only */
 144         volatile u32    fg;
 145         volatile u32    bg;
 146         volatile u32    src;            /* Copy/Scroll (SS0 only) */
 147         volatile u32    dst;            /* Copy/Scroll/Fill (SS0 only) */
 148         volatile u32    extent;         /* Copy/Scroll/Fill size (SS0 only) */
 149         u32             xxx1[3];
 150         volatile u32    setsem;         /* SS1 only */
 151         volatile u32    clrsem;         /* SS1 only */
 152         volatile u32    clrpick;        /* SS1 only */
 153         volatile u32    clrdat;         /* SS1 only */
 154         volatile u32    alpha;          /* SS1 only */
 155         u8              xxx2[0x2c];
 156         volatile u32    winbg;
 157         volatile u32    planemask;
 158         volatile u32    rop;
 159         volatile u32    z;
 160         volatile u32    dczf;           /* SS1 only */
 161         volatile u32    dczb;           /* SS1 only */
 162         volatile u32    dcs;            /* SS1 only */
 163         volatile u32    dczs;           /* SS1 only */
 164         volatile u32    pickfb;         /* SS1 only */
 165         volatile u32    pickbb;         /* SS1 only */
 166         volatile u32    dcfc;           /* SS1 only */
 167         volatile u32    forcecol;       /* SS1 only */
 168         volatile u32    door[8];        /* SS1 only */
 169         volatile u32    pick[5];        /* SS1 only */
 170 };
 171
 172 #define LEO_SS1_MISC_ENABLE     0x00000001
 173 #define LEO_SS1_MISC_STEREO     0x00000002
 174 struct leo_ld_ss1 {
 175         u8              xxx0[0xef4];
 176         volatile u32    ss1_misc;
 177 };
 178
 179 struct leo_ld_gbl {
 180         u8      unknown;
 181 };
 182
 183 struct leo_par {
 184         spinlock_t              lock;
 185         struct leo_lx_krn       __iomem *lx_krn;
 186         struct leo_lc_ss0_usr   __iomem *lc_ss0_usr;
 187         struct leo_ld_ss0       __iomem *ld_ss0;
 188         struct leo_ld_ss1       __iomem *ld_ss1;
 189         struct leo_cursor       __iomem *cursor;
 190         u32                     extent;
 191         u32                     clut_data[256];
 192
 193         u32                     flags;
 194 #define LEO_FLAG_BLANKED        0x00000001
 195
 196         unsigned long           physbase;
 197         unsigned long           fbsize;
 198
 199         struct sbus_dev         *sdev;
 200 };
 201
 202 static void leo_wait(struct leo_lx_krn __iomem *lx_krn)
 203 {
 204         int i;
 205
 206         for (i = 0;
 207              (sbus_readl(&lx_krn->krn_csr) & LEO_KRN_CSR_PROGRESS) && i < 300000;
 208              i++)
 209                 udelay (1); /* Busy wait at most 0.3 sec */
 210         return;
 211 }
 212
 213 /**
 214  *      leo_setcolreg - Optional function. Sets a color register.
 215  *      @regno: boolean, 0 copy local, 1 get_user() function
 216  *      @red: frame buffer colormap structure
 217  *      @green: The green value which can be up to 16 bits wide
 218  *      @blue:  The blue value which can be up to 16 bits wide.
 219  *      @transp: If supported the alpha value which can be up to 16 bits wide.
 220  *      @info: frame buffer info structure
 221  */
 222 static int leo_setcolreg(unsigned regno,
 223                          unsigned red, unsigned green, unsigned blue,
 224                          unsigned transp, struct fb_info *info)
 225 {
 226         struct leo_par *par = (struct leo_par *) info->par;
 227         struct leo_lx_krn __iomem *lx_krn = par->lx_krn;
 228         unsigned long flags;
 229         u32 val;
 230         int i;
 231
 232         if (regno >= 256)
 233                 return 1;
 234
 235         red >>= 8;
 236         green >>= 8;
 237         blue >>= 8;
 238
 239         par->clut_data[regno] = red | (green << 8) | (blue << 16);
 240
 241         spin_lock_irqsave(&par->lock, flags);
 242
 243         leo_wait(lx_krn);
 244
 245         sbus_writel(LEO_KRN_TYPE_CLUTDATA, &lx_krn->krn_type);
 246         for (i = 0; i < 256; i++)
 247                 sbus_writel(par->clut_data[i], &lx_krn->krn_value);
 248         sbus_writel(LEO_KRN_TYPE_CLUT0, &lx_krn->krn_type);
 249
 250         val = sbus_readl(&lx_krn->krn_csr);
 251         val |= (LEO_KRN_CSR_UNK | LEO_KRN_CSR_UNK2);
 252         sbus_writel(val, &lx_krn->krn_csr);
 253
 254         spin_unlock_irqrestore(&par->lock, flags);
 255
 256         return 0;
 257 }
 258
 259 /**
 260  *      leo_blank - Optional function.  Blanks the display.
 261  *      @blank_mode: the blank mode we want.
 262  *      @info: frame buffer structure that represents a single frame buffer
 263  */
 264 static int leo_blank(int blank, struct fb_info *info)
 265 {
 266         struct leo_par *par = (struct leo_par *) info->par;
 267         struct leo_lx_krn __iomem *lx_krn = par->lx_krn;
 268         unsigned long flags;
 269         u32 val;
 270
 271         spin_lock_irqsave(&par->lock, flags);
 272
 273         switch (blank) {
 274         case FB_BLANK_UNBLANK: /* Unblanking */
 275                 val = sbus_readl(&lx_krn->krn_csr);
 276                 val |= LEO_KRN_CSR_ENABLE;
 277                 sbus_writel(val, &lx_krn->krn_csr);
 278                 par->flags &= ~LEO_FLAG_BLANKED;
 279                 break;
 280
 281         case FB_BLANK_NORMAL: /* Normal blanking */
 282         case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */
 283         case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */
 284         case FB_BLANK_POWERDOWN: /* Poweroff */
 285                 val = sbus_readl(&lx_krn->krn_csr);
 286                 val &= ~LEO_KRN_CSR_ENABLE;
 287                 sbus_writel(val, &lx_krn->krn_csr);
 288                 par->flags |= LEO_FLAG_BLANKED;
 289                 break;
 290         }
 291
 292         spin_unlock_irqrestore(&par->lock, flags);
 293
 294         return 0;
 295 }
 296
 297 static struct sbus_mmap_map leo_mmap_map[] = {
 298         {
 299                 .voff   = LEO_SS0_MAP,
 300                 .poff   = LEO_OFF_SS0,
 301                 .size   = 0x800000
 302         },
 303         {
 304                 .voff   = LEO_LC_SS0_USR_MAP,
 305                 .poff   = LEO_OFF_LC_SS0_USR,
 306                 .size   = 0x1000
 307         },
 308         {
 309                 .voff   = LEO_LD_SS0_MAP,
 310                 .poff   = LEO_OFF_LD_SS0,
 311                 .size   = 0x1000
 312         },
 313         {
 314                 .voff   = LEO_LX_CURSOR_MAP,
 315                 .poff   = LEO_OFF_LX_CURSOR,
 316                 .size   = 0x1000
 317         },
 318         {
 319                 .voff   = LEO_SS1_MAP,
 320                 .poff   = LEO_OFF_SS1,
 321                 .size   = 0x800000
 322         },
 323         {
 324                 .voff   = LEO_LC_SS1_USR_MAP,
 325                 .poff   = LEO_OFF_LC_SS1_USR,
 326                 .size   = 0x1000
 327         },
 328         {
 329                 .voff   = LEO_LD_SS1_MAP,
 330                 .poff   = LEO_OFF_LD_SS1,
 331                 .size   = 0x1000
 332         },
 333         {
 334                 .voff   = LEO_UNK_MAP,
 335                 .poff   = LEO_OFF_UNK,
 336                 .size   = 0x1000
 337         },
 338         {
 339                 .voff   = LEO_LX_KRN_MAP,
 340                 .poff   = LEO_OFF_LX_KRN,
 341                 .size   = 0x1000
 342         },
 343         {
 344                 .voff   = LEO_LC_SS0_KRN_MAP,
 345                 .poff   = LEO_OFF_LC_SS0_KRN,
 346                 .size   = 0x1000
 347         },
 348         {
 349                 .voff   = LEO_LC_SS1_KRN_MAP,
 350                 .poff   = LEO_OFF_LC_SS1_KRN,
 351                 .size   = 0x1000
 352         },
 353         {
 354                 .voff   = LEO_LD_GBL_MAP,
 355                 .poff   = LEO_OFF_LD_GBL,
 356                 .size   = 0x1000
 357         },
 358         {
 359                 .voff   = LEO_UNK2_MAP,
 360                 .poff   = LEO_OFF_UNK2,
 361                 .size   = 0x100000
 362         },
 363         { .size = 0 }
 364 };
 365
 366 static int leo_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
 367 {
 368         struct leo_par *par = (struct leo_par *)info->par;
 369
 370         return sbusfb_mmap_helper(leo_mmap_map,
 371                                   par->physbase, par->fbsize,
 372                                   par->sdev->reg_addrs[0].which_io,
 373                                   vma);
 374 }
 375
 376 static int leo_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 377                      unsigned long arg, struct fb_info *info)
 378 {
 379         struct leo_par *par = (struct leo_par *) info->par;
 380
 381         return sbusfb_ioctl_helper(cmd, arg, info,
 382                                    FBTYPE_SUNLEO, 32, par->fbsize);
 383 }
 384
 385 /*
 386  *  Initialisation
 387  */
 388
 389 static void
 390 leo_init_fix(struct fb_info *info)
 391 {
 392         struct leo_par *par = (struct leo_par *)info->par;
 393
 394         strlcpy(info->fix.id, par->sdev->prom_name, sizeof(info->fix.id));
 395
 396         info->fix.type = FB_TYPE_PACKED_PIXELS;
 397         info->fix.visual = FB_VISUAL_TRUECOLOR;
 398
 399         info->fix.line_length = 8192;
 400
 401         info->fix.accel = FB_ACCEL_SUN_LEO;
 402 }
 403
 404 static void leo_wid_put(struct fb_info *info, struct fb_wid_list *wl)
 405 {
 406         struct leo_par *par = (struct leo_par *) info->par;
 407         struct leo_lx_krn __iomem *lx_krn = par->lx_krn;
 408         struct fb_wid_item *wi;
 409         unsigned long flags;
 410         u32 val;
 411         int i, j;
 412
 413         spin_lock_irqsave(&par->lock, flags);
 414
 415         leo_wait(lx_krn);
 416
 417         for (i = 0, wi = wl->wl_list; i < wl->wl_count; i++, wi++) {
 418                 switch(wi->wi_type) {
 419                 case FB_WID_DBL_8:
 420                         j = (wi->wi_index & 0xf) + 0x40;
 421                         break;
 422
 423                 case FB_WID_DBL_24:
 424                         j = wi->wi_index & 0x3f;
 425                         break;
 426
 427                 default:
 428                         continue;
 429                 };
 430                 sbus_writel(0x5800 + j, &lx_krn->krn_type);
 431                 sbus_writel(wi->wi_values[0], &lx_krn->krn_value);
 432         }
 433         sbus_writel(LEO_KRN_TYPE_WID, &lx_krn->krn_type);
 434
 435         val = sbus_readl(&lx_krn->krn_csr);
 436         val |= (LEO_KRN_CSR_UNK | LEO_KRN_CSR_UNK2);
 437         sbus_writel(val, &lx_krn->krn_csr);
 438
 439         spin_unlock_irqrestore(&par->lock, flags);
 440 }
 441
 442 static void leo_init_wids(struct fb_info *info)
 443 {
 444         struct fb_wid_item wi;
 445         struct fb_wid_list wl;
 446
 447         wl.wl_count = 1;
 448         wl.wl_list = &wi;
 449         wi.wi_type = FB_WID_DBL_8;
 450         wi.wi_index = 0;
 451         wi.wi_values [0] = 0x2c0;
 452         leo_wid_put(info, &wl);
 453         wi.wi_index = 1;
 454         wi.wi_values [0] = 0x30;
 455         leo_wid_put(info, &wl);
 456         wi.wi_index = 2;
 457         wi.wi_values [0] = 0x20;
 458         leo_wid_put(info, &wl);
 459         wi.wi_type = FB_WID_DBL_24;
 460         wi.wi_index = 1;
 461         wi.wi_values [0] = 0x30;
 462         leo_wid_put(info, &wl);
 463
 464 }
 465
 466 static void leo_switch_from_graph(struct fb_info *info)
 467 {
 468         struct leo_par *par = (struct leo_par *) info->par;
 469         struct leo_ld __iomem *ss = (struct leo_ld __iomem *) par->ld_ss0;
 470         unsigned long flags;
 471         u32 val;
 472
 473         spin_lock_irqsave(&par->lock, flags);
 474
 475         par->extent = ((info->var.xres - 1) |
 476                        ((info->var.yres - 1) << 16));
 477
 478         sbus_writel(0xffffffff, &ss->wid);
 479         sbus_writel(0xffff, &ss->wmask);
 480         sbus_writel(0, &ss->vclipmin);
 481         sbus_writel(par->extent, &ss->vclipmax);
 482         sbus_writel(0, &ss->fg);
 483         sbus_writel(0xff000000, &ss->planemask);
 484         sbus_writel(0x310850, &ss->rop);
 485         sbus_writel(0, &ss->widclip);
 486         sbus_writel((info->var.xres-1) | ((info->var.yres-1) << 11),
 487                     &par->lc_ss0_usr->extent);
 488         sbus_writel(4, &par->lc_ss0_usr->addrspace);
 489         sbus_writel(0x80000000, &par->lc_ss0_usr->fill);
 490         sbus_writel(0, &par->lc_ss0_usr->fontt);
 491         do {
 492                 val = sbus_readl(&par->lc_ss0_usr->csr);
 493         } while (val & 0x20000000);
 494
 495         spin_unlock_irqrestore(&par->lock, flags);
 496 }
 497
 498 static int leo_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 499 {
 500         /* We just use this to catch switches out of
 501          * graphics mode.
 502          */
 503         leo_switch_from_graph(info);
 504
 505         if (var->xoffset || var->yoffset || var->vmode)
 506                 return -EINVAL;
 507         return 0;
 508 }
 509
 510 static void leo_init_hw(struct fb_info *info)
 511 {
 512         struct leo_par *par = (struct leo_par *) info->par;
 513         u32 val;
 514
 515         val = sbus_readl(&par->ld_ss1->ss1_misc);
 516         val |= LEO_SS1_MISC_ENABLE;
 517         sbus_writel(val, &par->ld_ss1->ss1_misc);
 518
 519         leo_switch_from_graph(info);
 520 }
 521
 522 static void leo_fixup_var_rgb(struct fb_var_screeninfo *var)
 523 {
 524         var->red.offset = 0;
 525         var->red.length = 8;
 526         var->green.offset = 8;
 527         var->green.length = 8;
 528         var->blue.offset = 16;
 529         var->blue.length = 8;
 530         var->transp.offset = 0;
 531         var->transp.length = 0;
 532 }
 533
 534 struct all_info {
 535         struct fb_info info;
 536         struct leo_par par;
 537         struct list_head list;
 538 };
 539 static LIST_HEAD(leo_list);
 540
 541 static void leo_init_one(struct sbus_dev *sdev)
 542 {
 543         struct all_info *all;
 544         int linebytes;
 545
 546         all = kmalloc(sizeof(*all), GFP_KERNEL);
 547         if (!all) {
 548                 printk(KERN_ERR "leo: Cannot allocate memory.\n");
 549                 return;
 550         }
 551         memset(all, 0, sizeof(*all));
 552
 553         INIT_LIST_HEAD(&all->list);
 554
 555         spin_lock_init(&all->par.lock);
 556         all->par.sdev = sdev;
 557
 558         all->par.physbase = sdev->reg_addrs[0].phys_addr;
 559
 560         sbusfb_fill_var(&all->info.var, sdev->prom_node, 32);
 561         leo_fixup_var_rgb(&all->info.var);
 562
 563         linebytes = prom_getintdefault(sdev->prom_node, "linebytes",
 564                                        all->info.var.xres);
 565         all->par.fbsize = PAGE_ALIGN(linebytes * all->info.var.yres);
 566
 567 #ifdef CONFIG_SPARC32
 568         all->info.screen_base = (char __iomem *)
 569                 prom_getintdefault(sdev->prom_node, "address", 0);
 570 #endif
 571         if (!all->info.screen_base)
 572                 all->info.screen_base =
 573                         sbus_ioremap(&sdev->resource[0], LEO_OFF_SS0,
 574                                      0x800000, "leo ram");
 575
 576         all->par.lc_ss0_usr =
 577                 sbus_ioremap(&sdev->resource[0], LEO_OFF_LC_SS0_USR,
 578                              0x1000, "leolc ss0usr");
 579         all->par.ld_ss0 =
 580                 sbus_ioremap(&sdev->resource[0], LEO_OFF_LD_SS0,
 581                              0x1000, "leold ss0");
 582         all->par.ld_ss1 =
 583                 sbus_ioremap(&sdev->resource[0], LEO_OFF_LD_SS1,
 584                              0x1000, "leold ss1");
 585         all->par.lx_krn =
 586                 sbus_ioremap(&sdev->resource[0], LEO_OFF_LX_KRN,
 587                              0x1000, "leolx krn");
 588         all->par.cursor =
 589                 sbus_ioremap(&sdev->resource[0], LEO_OFF_LX_CURSOR,
 590                              sizeof(struct leo_cursor), "leolx cursor");
 591
 592         all->info.flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
 593         all->info.fbops = &leo_ops;
 594         all->info.par = &all->par;
 595
 596         leo_init_wids(&all->info);
 597         leo_init_hw(&all->info);
 598
 599         leo_blank(0, &all->info);
 600
 601         if (fb_alloc_cmap(&all->info.cmap, 256, 0)) {
 602                 printk(KERN_ERR "leo: Could not allocate color map.\n");
 603                 kfree(all);
 604                 return;
 605         }
 606
 607         leo_init_fix(&all->info);
 608
 609         if (register_framebuffer(&all->info) < 0) {
 610                 printk(KERN_ERR "leo: Could not register framebuffer.\n");
 611                 fb_dealloc_cmap(&all->info.cmap);
 612                 kfree(all);
 613                 return;
 614         }
 615
 616         list_add(&all->list, &leo_list);
 617
 618         printk("leo: %s at %lx:%lx\n",
 619                sdev->prom_name,
 620                (long) sdev->reg_addrs[0].which_io,
 621                (long) sdev->reg_addrs[0].phys_addr);
 622 }
 623
 624 int __init leo_init(void)
 625 {
 626         struct sbus_bus *sbus;
 627         struct sbus_dev *sdev;
 628
 629         if (fb_get_options("leofb", NULL))
 630                 return -ENODEV;
 631
 632         for_all_sbusdev(sdev, sbus) {
 633                 if (!strcmp(sdev->prom_name, "leo"))
 634                         leo_init_one(sdev);
 635         }
 636
 637         return 0;
 638 }
 639
 640 void __exit leo_exit(void)
 641 {
 642         struct list_head *pos, *tmp;
 643
 644         list_for_each_safe(pos, tmp, &leo_list) {
 645                 struct all_info *all = list_entry(pos, typeof(*all), list);
 646
 647                 unregister_framebuffer(&all->info);
 648                 fb_dealloc_cmap(&all->info.cmap);
 649                 kfree(all);
 650         }
 651 }
 652
 653 int __init
 654 leo_setup(char *arg)
 655 {
 656         /* No cmdline options yet... */
 657         return 0;
 658 }
 659
 660 module_init(leo_init);
 661 #ifdef MODULE
 662 module_exit(leo_exit);
 663 #endif
 664
 665 MODULE_DESCRIPTION("framebuffer driver for LEO chipsets");
 666 MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
 667 MODULE_LICENSE("GPL");