linux/drivers/video/fbdev/metronomefb.c
<<
>>
Prefs
   1/*
   2 * linux/drivers/video/metronomefb.c -- FB driver for Metronome controller
   3 *
   4 * Copyright (C) 2008, Jaya Kumar
   5 *
   6 * This file is subject to the terms and conditions of the GNU General Public
   7 * License. See the file COPYING in the main directory of this archive for
   8 * more details.
   9 *
  10 * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
  11 *
  12 * This work was made possible by help and equipment support from E-Ink
  13 * Corporation. http://www.eink.com/
  14 *
  15 * This driver is written to be used with the Metronome display controller.
  16 * It is intended to be architecture independent. A board specific driver
  17 * must be used to perform all the physical IO interactions. An example
  18 * is provided as am200epd.c
  19 *
  20 */
  21#include <linux/module.h>
  22#include <linux/kernel.h>
  23#include <linux/errno.h>
  24#include <linux/string.h>
  25#include <linux/mm.h>
  26#include <linux/vmalloc.h>
  27#include <linux/delay.h>
  28#include <linux/interrupt.h>
  29#include <linux/fb.h>
  30#include <linux/init.h>
  31#include <linux/platform_device.h>
  32#include <linux/list.h>
  33#include <linux/firmware.h>
  34#include <linux/dma-mapping.h>
  35#include <linux/uaccess.h>
  36#include <linux/irq.h>
  37
  38#include <video/metronomefb.h>
  39
  40#include <asm/unaligned.h>
  41
  42/* Display specific information */
  43#define DPY_W 832
  44#define DPY_H 622
  45
  46static int user_wfm_size;
  47
  48/* frame differs from image. frame includes non-visible pixels */
  49struct epd_frame {
  50        int fw; /* frame width */
  51        int fh; /* frame height */
  52        u16 config[4];
  53        int wfm_size;
  54};
  55
  56static struct epd_frame epd_frame_table[] = {
  57        {
  58                .fw = 832,
  59                .fh = 622,
  60                .config = {
  61                        15 /* sdlew */
  62                        | 2 << 8 /* sdosz */
  63                        | 0 << 11 /* sdor */
  64                        | 0 << 12 /* sdces */
  65                        | 0 << 15, /* sdcer */
  66                        42 /* gdspl */
  67                        | 1 << 8 /* gdr1 */
  68                        | 1 << 9 /* sdshr */
  69                        | 0 << 15, /* gdspp */
  70                        18 /* gdspw */
  71                        | 0 << 15, /* dispc */
  72                        599 /* vdlc */
  73                        | 0 << 11 /* dsi */
  74                        | 0 << 12, /* dsic */
  75                },
  76                .wfm_size = 47001,
  77        },
  78        {
  79                .fw = 1088,
  80                .fh = 791,
  81                .config = {
  82                        0x0104,
  83                        0x031f,
  84                        0x0088,
  85                        0x02ff,
  86                },
  87                .wfm_size = 46770,
  88        },
  89        {
  90                .fw = 1200,
  91                .fh = 842,
  92                .config = {
  93                        0x0101,
  94                        0x030e,
  95                        0x0012,
  96                        0x0280,
  97                },
  98                .wfm_size = 46770,
  99        },
 100};
 101
 102static struct fb_fix_screeninfo metronomefb_fix = {
 103        .id =           "metronomefb",
 104        .type =         FB_TYPE_PACKED_PIXELS,
 105        .visual =       FB_VISUAL_STATIC_PSEUDOCOLOR,
 106        .xpanstep =     0,
 107        .ypanstep =     0,
 108        .ywrapstep =    0,
 109        .line_length =  DPY_W,
 110        .accel =        FB_ACCEL_NONE,
 111};
 112
 113static struct fb_var_screeninfo metronomefb_var = {
 114        .xres           = DPY_W,
 115        .yres           = DPY_H,
 116        .xres_virtual   = DPY_W,
 117        .yres_virtual   = DPY_H,
 118        .bits_per_pixel = 8,
 119        .grayscale      = 1,
 120        .nonstd         = 1,
 121        .red =          { 4, 3, 0 },
 122        .green =        { 0, 0, 0 },
 123        .blue =         { 0, 0, 0 },
 124        .transp =       { 0, 0, 0 },
 125};
 126
 127/* the waveform structure that is coming from userspace firmware */
 128struct waveform_hdr {
 129        u8 stuff[32];
 130
 131        u8 wmta[3];
 132        u8 fvsn;
 133
 134        u8 luts;
 135        u8 mc;
 136        u8 trc;
 137        u8 stuff3;
 138
 139        u8 endb;
 140        u8 swtb;
 141        u8 stuff2a[2];
 142
 143        u8 stuff2b[3];
 144        u8 wfm_cs;
 145} __attribute__ ((packed));
 146
 147/* main metronomefb functions */
 148static u8 calc_cksum(int start, int end, u8 *mem)
 149{
 150        u8 tmp = 0;
 151        int i;
 152
 153        for (i = start; i < end; i++)
 154                tmp += mem[i];
 155
 156        return tmp;
 157}
 158
 159static u16 calc_img_cksum(u16 *start, int length)
 160{
 161        u16 tmp = 0;
 162
 163        while (length--)
 164                tmp += *start++;
 165
 166        return tmp;
 167}
 168
 169/* here we decode the incoming waveform file and populate metromem */
 170static int load_waveform(u8 *mem, size_t size, int m, int t,
 171                         struct metronomefb_par *par)
 172{
 173        int tta;
 174        int wmta;
 175        int trn = 0;
 176        int i;
 177        unsigned char v;
 178        u8 cksum;
 179        int cksum_idx;
 180        int wfm_idx, owfm_idx;
 181        int mem_idx = 0;
 182        struct waveform_hdr *wfm_hdr;
 183        u8 *metromem = par->metromem_wfm;
 184        struct device *dev = par->info->dev;
 185
 186        if (user_wfm_size)
 187                epd_frame_table[par->dt].wfm_size = user_wfm_size;
 188
 189        if (size != epd_frame_table[par->dt].wfm_size) {
 190                dev_err(dev, "Error: unexpected size %zd != %d\n", size,
 191                                        epd_frame_table[par->dt].wfm_size);
 192                return -EINVAL;
 193        }
 194
 195        wfm_hdr = (struct waveform_hdr *) mem;
 196
 197        if (wfm_hdr->fvsn != 1) {
 198                dev_err(dev, "Error: bad fvsn %x\n", wfm_hdr->fvsn);
 199                return -EINVAL;
 200        }
 201        if (wfm_hdr->luts != 0) {
 202                dev_err(dev, "Error: bad luts %x\n", wfm_hdr->luts);
 203                return -EINVAL;
 204        }
 205        cksum = calc_cksum(32, 47, mem);
 206        if (cksum != wfm_hdr->wfm_cs) {
 207                dev_err(dev, "Error: bad cksum %x != %x\n", cksum,
 208                                        wfm_hdr->wfm_cs);
 209                return -EINVAL;
 210        }
 211        wfm_hdr->mc += 1;
 212        wfm_hdr->trc += 1;
 213        for (i = 0; i < 5; i++) {
 214                if (*(wfm_hdr->stuff2a + i) != 0) {
 215                        dev_err(dev, "Error: unexpected value in padding\n");
 216                        return -EINVAL;
 217                }
 218        }
 219
 220        /* calculating trn. trn is something used to index into
 221        the waveform. presumably selecting the right one for the
 222        desired temperature. it works out the offset of the first
 223        v that exceeds the specified temperature */
 224        if ((sizeof(*wfm_hdr) + wfm_hdr->trc) > size)
 225                return -EINVAL;
 226
 227        for (i = sizeof(*wfm_hdr); i <= sizeof(*wfm_hdr) + wfm_hdr->trc; i++) {
 228                if (mem[i] > t) {
 229                        trn = i - sizeof(*wfm_hdr) - 1;
 230                        break;
 231                }
 232        }
 233
 234        /* check temperature range table checksum */
 235        cksum_idx = sizeof(*wfm_hdr) + wfm_hdr->trc + 1;
 236        if (cksum_idx > size)
 237                return -EINVAL;
 238        cksum = calc_cksum(sizeof(*wfm_hdr), cksum_idx, mem);
 239        if (cksum != mem[cksum_idx]) {
 240                dev_err(dev, "Error: bad temperature range table cksum"
 241                                " %x != %x\n", cksum, mem[cksum_idx]);
 242                return -EINVAL;
 243        }
 244
 245        /* check waveform mode table address checksum */
 246        wmta = get_unaligned_le32(wfm_hdr->wmta) & 0x00FFFFFF;
 247        cksum_idx = wmta + m*4 + 3;
 248        if (cksum_idx > size)
 249                return -EINVAL;
 250        cksum = calc_cksum(cksum_idx - 3, cksum_idx, mem);
 251        if (cksum != mem[cksum_idx]) {
 252                dev_err(dev, "Error: bad mode table address cksum"
 253                                " %x != %x\n", cksum, mem[cksum_idx]);
 254                return -EINVAL;
 255        }
 256
 257        /* check waveform temperature table address checksum */
 258        tta = get_unaligned_le32(mem + wmta + m * 4) & 0x00FFFFFF;
 259        cksum_idx = tta + trn*4 + 3;
 260        if (cksum_idx > size)
 261                return -EINVAL;
 262        cksum = calc_cksum(cksum_idx - 3, cksum_idx, mem);
 263        if (cksum != mem[cksum_idx]) {
 264                dev_err(dev, "Error: bad temperature table address cksum"
 265                        " %x != %x\n", cksum, mem[cksum_idx]);
 266                return -EINVAL;
 267        }
 268
 269        /* here we do the real work of putting the waveform into the
 270        metromem buffer. this does runlength decoding of the waveform */
 271        wfm_idx = get_unaligned_le32(mem + tta + trn * 4) & 0x00FFFFFF;
 272        owfm_idx = wfm_idx;
 273        if (wfm_idx > size)
 274                return -EINVAL;
 275        while (wfm_idx < size) {
 276                unsigned char rl;
 277                v = mem[wfm_idx++];
 278                if (v == wfm_hdr->swtb) {
 279                        while (((v = mem[wfm_idx++]) != wfm_hdr->swtb) &&
 280                                wfm_idx < size)
 281                                metromem[mem_idx++] = v;
 282
 283                        continue;
 284                }
 285
 286                if (v == wfm_hdr->endb)
 287                        break;
 288
 289                rl = mem[wfm_idx++];
 290                for (i = 0; i <= rl; i++)
 291                        metromem[mem_idx++] = v;
 292        }
 293
 294        cksum_idx = wfm_idx;
 295        if (cksum_idx > size)
 296                return -EINVAL;
 297        cksum = calc_cksum(owfm_idx, cksum_idx, mem);
 298        if (cksum != mem[cksum_idx]) {
 299                dev_err(dev, "Error: bad waveform data cksum"
 300                                " %x != %x\n", cksum, mem[cksum_idx]);
 301                return -EINVAL;
 302        }
 303        par->frame_count = (mem_idx/64);
 304
 305        return 0;
 306}
 307
 308static int metronome_display_cmd(struct metronomefb_par *par)
 309{
 310        int i;
 311        u16 cs;
 312        u16 opcode;
 313        static u8 borderval;
 314
 315        /* setup display command
 316        we can't immediately set the opcode since the controller
 317        will try parse the command before we've set it all up
 318        so we just set cs here and set the opcode at the end */
 319
 320        if (par->metromem_cmd->opcode == 0xCC40)
 321                opcode = cs = 0xCC41;
 322        else
 323                opcode = cs = 0xCC40;
 324
 325        /* set the args ( 2 bytes ) for display */
 326        i = 0;
 327        par->metromem_cmd->args[i] =    1 << 3 /* border update */
 328                                        | ((borderval++ % 4) & 0x0F) << 4
 329                                        | (par->frame_count - 1) << 8;
 330        cs += par->metromem_cmd->args[i++];
 331
 332        /* the rest are 0 */
 333        memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
 334
 335        par->metromem_cmd->csum = cs;
 336        par->metromem_cmd->opcode = opcode; /* display cmd */
 337
 338        return par->board->met_wait_event_intr(par);
 339}
 340
 341static int metronome_powerup_cmd(struct metronomefb_par *par)
 342{
 343        int i;
 344        u16 cs;
 345
 346        /* setup power up command */
 347        par->metromem_cmd->opcode = 0x1234; /* pwr up pseudo cmd */
 348        cs = par->metromem_cmd->opcode;
 349
 350        /* set pwr1,2,3 to 1024 */
 351        for (i = 0; i < 3; i++) {
 352                par->metromem_cmd->args[i] = 1024;
 353                cs += par->metromem_cmd->args[i];
 354        }
 355
 356        /* the rest are 0 */
 357        memset(&par->metromem_cmd->args[i], 0,
 358               (ARRAY_SIZE(par->metromem_cmd->args) - i) * 2);
 359
 360        par->metromem_cmd->csum = cs;
 361
 362        msleep(1);
 363        par->board->set_rst(par, 1);
 364
 365        msleep(1);
 366        par->board->set_stdby(par, 1);
 367
 368        return par->board->met_wait_event(par);
 369}
 370
 371static int metronome_config_cmd(struct metronomefb_par *par)
 372{
 373        /* setup config command
 374        we can't immediately set the opcode since the controller
 375        will try parse the command before we've set it all up */
 376
 377        memcpy(par->metromem_cmd->args, epd_frame_table[par->dt].config,
 378                sizeof(epd_frame_table[par->dt].config));
 379        /* the rest are 0 */
 380        memset(&par->metromem_cmd->args[4], 0,
 381               (ARRAY_SIZE(par->metromem_cmd->args) - 4) * 2);
 382
 383        par->metromem_cmd->csum = 0xCC10;
 384        par->metromem_cmd->csum += calc_img_cksum(par->metromem_cmd->args, 4);
 385        par->metromem_cmd->opcode = 0xCC10; /* config cmd */
 386
 387        return par->board->met_wait_event(par);
 388}
 389
 390static int metronome_init_cmd(struct metronomefb_par *par)
 391{
 392        int i;
 393        u16 cs;
 394
 395        /* setup init command
 396        we can't immediately set the opcode since the controller
 397        will try parse the command before we've set it all up
 398        so we just set cs here and set the opcode at the end */
 399
 400        cs = 0xCC20;
 401
 402        /* set the args ( 2 bytes ) for init */
 403        i = 0;
 404        par->metromem_cmd->args[i] = 0;
 405        cs += par->metromem_cmd->args[i++];
 406
 407        /* the rest are 0 */
 408        memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
 409
 410        par->metromem_cmd->csum = cs;
 411        par->metromem_cmd->opcode = 0xCC20; /* init cmd */
 412
 413        return par->board->met_wait_event(par);
 414}
 415
 416static int metronome_init_regs(struct metronomefb_par *par)
 417{
 418        int res;
 419
 420        res = par->board->setup_io(par);
 421        if (res)
 422                return res;
 423
 424        res = metronome_powerup_cmd(par);
 425        if (res)
 426                return res;
 427
 428        res = metronome_config_cmd(par);
 429        if (res)
 430                return res;
 431
 432        res = metronome_init_cmd(par);
 433
 434        return res;
 435}
 436
 437static void metronomefb_dpy_update(struct metronomefb_par *par)
 438{
 439        int fbsize;
 440        u16 cksum;
 441        unsigned char *buf = (unsigned char __force *)par->info->screen_base;
 442
 443        fbsize = par->info->fix.smem_len;
 444        /* copy from vm to metromem */
 445        memcpy(par->metromem_img, buf, fbsize);
 446
 447        cksum = calc_img_cksum((u16 *) par->metromem_img, fbsize/2);
 448        *((u16 *)(par->metromem_img) + fbsize/2) = cksum;
 449        metronome_display_cmd(par);
 450}
 451
 452static u16 metronomefb_dpy_update_page(struct metronomefb_par *par, int index)
 453{
 454        int i;
 455        u16 csum = 0;
 456        u16 *buf = (u16 __force *)(par->info->screen_base + index);
 457        u16 *img = (u16 *)(par->metromem_img + index);
 458
 459        /* swizzle from vm to metromem and recalc cksum at the same time*/
 460        for (i = 0; i < PAGE_SIZE/2; i++) {
 461                *(img + i) = (buf[i] << 5) & 0xE0E0;
 462                csum += *(img + i);
 463        }
 464        return csum;
 465}
 466
 467/* this is called back from the deferred io workqueue */
 468static void metronomefb_dpy_deferred_io(struct fb_info *info,
 469                                struct list_head *pagelist)
 470{
 471        u16 cksum;
 472        struct page *cur;
 473        struct fb_deferred_io *fbdefio = info->fbdefio;
 474        struct metronomefb_par *par = info->par;
 475
 476        /* walk the written page list and swizzle the data */
 477        list_for_each_entry(cur, &fbdefio->pagelist, lru) {
 478                cksum = metronomefb_dpy_update_page(par,
 479                                        (cur->index << PAGE_SHIFT));
 480                par->metromem_img_csum -= par->csum_table[cur->index];
 481                par->csum_table[cur->index] = cksum;
 482                par->metromem_img_csum += cksum;
 483        }
 484
 485        metronome_display_cmd(par);
 486}
 487
 488static void metronomefb_fillrect(struct fb_info *info,
 489                                   const struct fb_fillrect *rect)
 490{
 491        struct metronomefb_par *par = info->par;
 492
 493        sys_fillrect(info, rect);
 494        metronomefb_dpy_update(par);
 495}
 496
 497static void metronomefb_copyarea(struct fb_info *info,
 498                                   const struct fb_copyarea *area)
 499{
 500        struct metronomefb_par *par = info->par;
 501
 502        sys_copyarea(info, area);
 503        metronomefb_dpy_update(par);
 504}
 505
 506static void metronomefb_imageblit(struct fb_info *info,
 507                                const struct fb_image *image)
 508{
 509        struct metronomefb_par *par = info->par;
 510
 511        sys_imageblit(info, image);
 512        metronomefb_dpy_update(par);
 513}
 514
 515/*
 516 * this is the slow path from userspace. they can seek and write to
 517 * the fb. it is based on fb_sys_write
 518 */
 519static ssize_t metronomefb_write(struct fb_info *info, const char __user *buf,
 520                                size_t count, loff_t *ppos)
 521{
 522        struct metronomefb_par *par = info->par;
 523        unsigned long p = *ppos;
 524        void *dst;
 525        int err = 0;
 526        unsigned long total_size;
 527
 528        if (info->state != FBINFO_STATE_RUNNING)
 529                return -EPERM;
 530
 531        total_size = info->fix.smem_len;
 532
 533        if (p > total_size)
 534                return -EFBIG;
 535
 536        if (count > total_size) {
 537                err = -EFBIG;
 538                count = total_size;
 539        }
 540
 541        if (count + p > total_size) {
 542                if (!err)
 543                        err = -ENOSPC;
 544
 545                count = total_size - p;
 546        }
 547
 548        dst = (void __force *)(info->screen_base + p);
 549
 550        if (copy_from_user(dst, buf, count))
 551                err = -EFAULT;
 552
 553        if  (!err)
 554                *ppos += count;
 555
 556        metronomefb_dpy_update(par);
 557
 558        return (err) ? err : count;
 559}
 560
 561static struct fb_ops metronomefb_ops = {
 562        .owner          = THIS_MODULE,
 563        .fb_write       = metronomefb_write,
 564        .fb_fillrect    = metronomefb_fillrect,
 565        .fb_copyarea    = metronomefb_copyarea,
 566        .fb_imageblit   = metronomefb_imageblit,
 567};
 568
 569static struct fb_deferred_io metronomefb_defio = {
 570        .delay          = HZ,
 571        .deferred_io    = metronomefb_dpy_deferred_io,
 572};
 573
 574static int metronomefb_probe(struct platform_device *dev)
 575{
 576        struct fb_info *info;
 577        struct metronome_board *board;
 578        int retval = -ENOMEM;
 579        int videomemorysize;
 580        unsigned char *videomemory;
 581        struct metronomefb_par *par;
 582        const struct firmware *fw_entry;
 583        int i;
 584        int panel_type;
 585        int fw, fh;
 586        int epd_dt_index;
 587
 588        /* pick up board specific routines */
 589        board = dev->dev.platform_data;
 590        if (!board)
 591                return -EINVAL;
 592
 593        /* try to count device specific driver, if can't, platform recalls */
 594        if (!try_module_get(board->owner))
 595                return -ENODEV;
 596
 597        info = framebuffer_alloc(sizeof(struct metronomefb_par), &dev->dev);
 598        if (!info)
 599                goto err;
 600
 601        /* we have two blocks of memory.
 602        info->screen_base which is vm, and is the fb used by apps.
 603        par->metromem which is physically contiguous memory and
 604        contains the display controller commands, waveform,
 605        processed image data and padding. this is the data pulled
 606        by the device's LCD controller and pushed to Metronome.
 607        the metromem memory is allocated by the board driver and
 608        is provided to us */
 609
 610        panel_type = board->get_panel_type();
 611        switch (panel_type) {
 612        case 6:
 613                epd_dt_index = 0;
 614                break;
 615        case 8:
 616                epd_dt_index = 1;
 617                break;
 618        case 97:
 619                epd_dt_index = 2;
 620                break;
 621        default:
 622                dev_err(&dev->dev, "Unexpected panel type. Defaulting to 6\n");
 623                epd_dt_index = 0;
 624                break;
 625        }
 626
 627        fw = epd_frame_table[epd_dt_index].fw;
 628        fh = epd_frame_table[epd_dt_index].fh;
 629
 630        /* we need to add a spare page because our csum caching scheme walks
 631         * to the end of the page */
 632        videomemorysize = PAGE_SIZE + (fw * fh);
 633        videomemory = vzalloc(videomemorysize);
 634        if (!videomemory)
 635                goto err_fb_rel;
 636
 637        info->screen_base = (char __force __iomem *)videomemory;
 638        info->fbops = &metronomefb_ops;
 639
 640        metronomefb_fix.line_length = fw;
 641        metronomefb_var.xres = fw;
 642        metronomefb_var.yres = fh;
 643        metronomefb_var.xres_virtual = fw;
 644        metronomefb_var.yres_virtual = fh;
 645        info->var = metronomefb_var;
 646        info->fix = metronomefb_fix;
 647        info->fix.smem_len = videomemorysize;
 648        par = info->par;
 649        par->info = info;
 650        par->board = board;
 651        par->dt = epd_dt_index;
 652        init_waitqueue_head(&par->waitq);
 653
 654        /* this table caches per page csum values. */
 655        par->csum_table = vmalloc(videomemorysize/PAGE_SIZE);
 656        if (!par->csum_table)
 657                goto err_vfree;
 658
 659        /* the physical framebuffer that we use is setup by
 660         * the platform device driver. It will provide us
 661         * with cmd, wfm and image memory in a contiguous area. */
 662        retval = board->setup_fb(par);
 663        if (retval) {
 664                dev_err(&dev->dev, "Failed to setup fb\n");
 665                goto err_csum_table;
 666        }
 667
 668        /* after this point we should have a framebuffer */
 669        if ((!par->metromem_wfm) ||  (!par->metromem_img) ||
 670                (!par->metromem_dma)) {
 671                dev_err(&dev->dev, "fb access failure\n");
 672                retval = -EINVAL;
 673                goto err_csum_table;
 674        }
 675
 676        info->fix.smem_start = par->metromem_dma;
 677
 678        /* load the waveform in. assume mode 3, temp 31 for now
 679                a) request the waveform file from userspace
 680                b) process waveform and decode into metromem */
 681        retval = request_firmware(&fw_entry, "metronome.wbf", &dev->dev);
 682        if (retval < 0) {
 683                dev_err(&dev->dev, "Failed to get waveform\n");
 684                goto err_csum_table;
 685        }
 686
 687        retval = load_waveform((u8 *) fw_entry->data, fw_entry->size, 3, 31,
 688                                par);
 689        release_firmware(fw_entry);
 690        if (retval < 0) {
 691                dev_err(&dev->dev, "Failed processing waveform\n");
 692                goto err_csum_table;
 693        }
 694
 695        retval = board->setup_irq(info);
 696        if (retval)
 697                goto err_csum_table;
 698
 699        retval = metronome_init_regs(par);
 700        if (retval < 0)
 701                goto err_free_irq;
 702
 703        info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
 704
 705        info->fbdefio = &metronomefb_defio;
 706        fb_deferred_io_init(info);
 707
 708        retval = fb_alloc_cmap(&info->cmap, 8, 0);
 709        if (retval < 0) {
 710                dev_err(&dev->dev, "Failed to allocate colormap\n");
 711                goto err_free_irq;
 712        }
 713
 714        /* set cmap */
 715        for (i = 0; i < 8; i++)
 716                info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/16;
 717        memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*8);
 718        memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*8);
 719
 720        retval = register_framebuffer(info);
 721        if (retval < 0)
 722                goto err_cmap;
 723
 724        platform_set_drvdata(dev, info);
 725
 726        dev_dbg(&dev->dev,
 727                "fb%d: Metronome frame buffer device, using %dK of video"
 728                " memory\n", info->node, videomemorysize >> 10);
 729
 730        return 0;
 731
 732err_cmap:
 733        fb_dealloc_cmap(&info->cmap);
 734err_free_irq:
 735        board->cleanup(par);
 736err_csum_table:
 737        vfree(par->csum_table);
 738err_vfree:
 739        vfree(videomemory);
 740err_fb_rel:
 741        framebuffer_release(info);
 742err:
 743        module_put(board->owner);
 744        return retval;
 745}
 746
 747static int metronomefb_remove(struct platform_device *dev)
 748{
 749        struct fb_info *info = platform_get_drvdata(dev);
 750
 751        if (info) {
 752                struct metronomefb_par *par = info->par;
 753
 754                unregister_framebuffer(info);
 755                fb_deferred_io_cleanup(info);
 756                fb_dealloc_cmap(&info->cmap);
 757                par->board->cleanup(par);
 758                vfree(par->csum_table);
 759                vfree((void __force *)info->screen_base);
 760                module_put(par->board->owner);
 761                dev_dbg(&dev->dev, "calling release\n");
 762                framebuffer_release(info);
 763        }
 764        return 0;
 765}
 766
 767static struct platform_driver metronomefb_driver = {
 768        .probe  = metronomefb_probe,
 769        .remove = metronomefb_remove,
 770        .driver = {
 771                .name   = "metronomefb",
 772        },
 773};
 774module_platform_driver(metronomefb_driver);
 775
 776module_param(user_wfm_size, uint, 0);
 777MODULE_PARM_DESC(user_wfm_size, "Set custom waveform size");
 778
 779MODULE_DESCRIPTION("fbdev driver for Metronome controller");
 780MODULE_AUTHOR("Jaya Kumar");
 781MODULE_LICENSE("GPL");
 782