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