drivers/video/metronomefb.c

   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
  46 static int user_wfm_size;
  47
  48 /* frame differs from image. frame includes non-visible pixels */
  49 struct epd_frame {
  50         int fw; /* frame width */
  51         int fh; /* frame height */
  52         u16 config[4];
  53         int wfm_size;
  54 };
  55
  56 static 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
 102 static struct fb_fix_screeninfo metronomefb_fix __devinitdata = {
 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
 113 static struct fb_var_screeninfo metronomefb_var __devinitdata = {
 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 */
 128 struct 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 */
 148 static 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
 159 static 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 */
 170 static int __devinit 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
 308 static 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
 341 static int __devinit 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((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
 358
 359         par->metromem_cmd->csum = cs;
 360
 361         msleep(1);
 362         par->board->set_rst(par, 1);
 363
 364         msleep(1);
 365         par->board->set_stdby(par, 1);
 366
 367         return par->board->met_wait_event(par);
 368 }
 369
 370 static int __devinit metronome_config_cmd(struct metronomefb_par *par)
 371 {
 372         /* setup config command
 373         we can't immediately set the opcode since the controller
 374         will try parse the command before we've set it all up */
 375
 376         memcpy(par->metromem_cmd->args, epd_frame_table[par->dt].config,
 377                 sizeof(epd_frame_table[par->dt].config));
 378         /* the rest are 0 */
 379         memset((u8 *) (par->metromem_cmd->args + 4), 0, (32-4)*2);
 380
 381         par->metromem_cmd->csum = 0xCC10;
 382         par->metromem_cmd->csum += calc_img_cksum(par->metromem_cmd->args, 4);
 383         par->metromem_cmd->opcode = 0xCC10; /* config cmd */
 384
 385         return par->board->met_wait_event(par);
 386 }
 387
 388 static int __devinit metronome_init_cmd(struct metronomefb_par *par)
 389 {
 390         int i;
 391         u16 cs;
 392
 393         /* setup init command
 394         we can't immediately set the opcode since the controller
 395         will try parse the command before we've set it all up
 396         so we just set cs here and set the opcode at the end */
 397
 398         cs = 0xCC20;
 399
 400         /* set the args ( 2 bytes ) for init */
 401         i = 0;
 402         par->metromem_cmd->args[i] = 0;
 403         cs += par->metromem_cmd->args[i++];
 404
 405         /* the rest are 0 */
 406         memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
 407
 408         par->metromem_cmd->csum = cs;
 409         par->metromem_cmd->opcode = 0xCC20; /* init cmd */
 410
 411         return par->board->met_wait_event(par);
 412 }
 413
 414 static int __devinit metronome_init_regs(struct metronomefb_par *par)
 415 {
 416         int res;
 417
 418         res = par->board->setup_io(par);
 419         if (res)
 420                 return res;
 421
 422         res = metronome_powerup_cmd(par);
 423         if (res)
 424                 return res;
 425
 426         res = metronome_config_cmd(par);
 427         if (res)
 428                 return res;
 429
 430         res = metronome_init_cmd(par);
 431
 432         return res;
 433 }
 434
 435 static void metronomefb_dpy_update(struct metronomefb_par *par)
 436 {
 437         int fbsize;
 438         u16 cksum;
 439         unsigned char *buf = (unsigned char __force *)par->info->screen_base;
 440
 441         fbsize = par->info->fix.smem_len;
 442         /* copy from vm to metromem */
 443         memcpy(par->metromem_img, buf, fbsize);
 444
 445         cksum = calc_img_cksum((u16 *) par->metromem_img, fbsize/2);
 446         *((u16 *)(par->metromem_img) + fbsize/2) = cksum;
 447         metronome_display_cmd(par);
 448 }
 449
 450 static u16 metronomefb_dpy_update_page(struct metronomefb_par *par, int index)
 451 {
 452         int i;
 453         u16 csum = 0;
 454         u16 *buf = (u16 __force *)(par->info->screen_base + index);
 455         u16 *img = (u16 *)(par->metromem_img + index);
 456
 457         /* swizzle from vm to metromem and recalc cksum at the same time*/
 458         for (i = 0; i < PAGE_SIZE/2; i++) {
 459                 *(img + i) = (buf[i] << 5) & 0xE0E0;
 460                 csum += *(img + i);
 461         }
 462         return csum;
 463 }
 464
 465 /* this is called back from the deferred io workqueue */
 466 static void metronomefb_dpy_deferred_io(struct fb_info *info,
 467                                 struct list_head *pagelist)
 468 {
 469         u16 cksum;
 470         struct page *cur;
 471         struct fb_deferred_io *fbdefio = info->fbdefio;
 472         struct metronomefb_par *par = info->par;
 473
 474         /* walk the written page list and swizzle the data */
 475         list_for_each_entry(cur, &fbdefio->pagelist, lru) {
 476                 cksum = metronomefb_dpy_update_page(par,
 477                                         (cur->index << PAGE_SHIFT));
 478                 par->metromem_img_csum -= par->csum_table[cur->index];
 479                 par->csum_table[cur->index] = cksum;
 480                 par->metromem_img_csum += cksum;
 481         }
 482
 483         metronome_display_cmd(par);
 484 }
 485
 486 static void metronomefb_fillrect(struct fb_info *info,
 487                                    const struct fb_fillrect *rect)
 488 {
 489         struct metronomefb_par *par = info->par;
 490
 491         sys_fillrect(info, rect);
 492         metronomefb_dpy_update(par);
 493 }
 494
 495 static void metronomefb_copyarea(struct fb_info *info,
 496                                    const struct fb_copyarea *area)
 497 {
 498         struct metronomefb_par *par = info->par;
 499
 500         sys_copyarea(info, area);
 501         metronomefb_dpy_update(par);
 502 }
 503
 504 static void metronomefb_imageblit(struct fb_info *info,
 505                                 const struct fb_image *image)
 506 {
 507         struct metronomefb_par *par = info->par;
 508
 509         sys_imageblit(info, image);
 510         metronomefb_dpy_update(par);
 511 }
 512
 513 /*
 514  * this is the slow path from userspace. they can seek and write to
 515  * the fb. it is based on fb_sys_write
 516  */
 517 static ssize_t metronomefb_write(struct fb_info *info, const char __user *buf,
 518                                 size_t count, loff_t *ppos)
 519 {
 520         struct metronomefb_par *par = info->par;
 521         unsigned long p = *ppos;
 522         void *dst;
 523         int err = 0;
 524         unsigned long total_size;
 525
 526         if (info->state != FBINFO_STATE_RUNNING)
 527                 return -EPERM;
 528
 529         total_size = info->fix.smem_len;
 530
 531         if (p > total_size)
 532                 return -EFBIG;
 533
 534         if (count > total_size) {
 535                 err = -EFBIG;
 536                 count = total_size;
 537         }
 538
 539         if (count + p > total_size) {
 540                 if (!err)
 541                         err = -ENOSPC;
 542
 543                 count = total_size - p;
 544         }
 545
 546         dst = (void __force *)(info->screen_base + p);
 547
 548         if (copy_from_user(dst, buf, count))
 549                 err = -EFAULT;
 550
 551         if  (!err)
 552                 *ppos += count;
 553
 554         metronomefb_dpy_update(par);
 555
 556         return (err) ? err : count;
 557 }
 558
 559 static struct fb_ops metronomefb_ops = {
 560         .owner          = THIS_MODULE,
 561         .fb_write       = metronomefb_write,
 562         .fb_fillrect    = metronomefb_fillrect,
 563         .fb_copyarea    = metronomefb_copyarea,
 564         .fb_imageblit   = metronomefb_imageblit,
 565 };
 566
 567 static struct fb_deferred_io metronomefb_defio = {
 568         .delay          = HZ,
 569         .deferred_io    = metronomefb_dpy_deferred_io,
 570 };
 571
 572 static int __devinit metronomefb_probe(struct platform_device *dev)
 573 {
 574         struct fb_info *info;
 575         struct metronome_board *board;
 576         int retval = -ENOMEM;
 577         int videomemorysize;
 578         unsigned char *videomemory;
 579         struct metronomefb_par *par;
 580         const struct firmware *fw_entry;
 581         int i;
 582         int panel_type;
 583         int fw, fh;
 584         int epd_dt_index;
 585
 586         /* pick up board specific routines */
 587         board = dev->dev.platform_data;
 588         if (!board)
 589                 return -EINVAL;
 590
 591         /* try to count device specific driver, if can't, platform recalls */
 592         if (!try_module_get(board->owner))
 593                 return -ENODEV;
 594
 595         info = framebuffer_alloc(sizeof(struct metronomefb_par), &dev->dev);
 596         if (!info)
 597                 goto err;
 598
 599         /* we have two blocks of memory.
 600         info->screen_base which is vm, and is the fb used by apps.
 601         par->metromem which is physically contiguous memory and
 602         contains the display controller commands, waveform,
 603         processed image data and padding. this is the data pulled
 604         by the device's LCD controller and pushed to Metronome.
 605         the metromem memory is allocated by the board driver and
 606         is provided to us */
 607
 608         panel_type = board->get_panel_type();
 609         switch (panel_type) {
 610         case 6:
 611                 epd_dt_index = 0;
 612                 break;
 613         case 8:
 614                 epd_dt_index = 1;
 615                 break;
 616         case 97:
 617                 epd_dt_index = 2;
 618                 break;
 619         default:
 620                 dev_err(&dev->dev, "Unexpected panel type. Defaulting to 6\n");
 621                 epd_dt_index = 0;
 622                 break;
 623         }
 624
 625         fw = epd_frame_table[epd_dt_index].fw;
 626         fh = epd_frame_table[epd_dt_index].fh;
 627
 628         /* we need to add a spare page because our csum caching scheme walks
 629          * to the end of the page */
 630         videomemorysize = PAGE_SIZE + (fw * fh);
 631         videomemory = vmalloc(videomemorysize);
 632         if (!videomemory)
 633                 goto err_fb_rel;
 634
 635         memset(videomemory, 0, videomemorysize);
 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         if (board->setup_irq(info))
 696                 goto err_csum_table;
 697
 698         retval = metronome_init_regs(par);
 699         if (retval < 0)
 700                 goto err_free_irq;
 701
 702         info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
 703
 704         info->fbdefio = &metronomefb_defio;
 705         fb_deferred_io_init(info);
 706
 707         retval = fb_alloc_cmap(&info->cmap, 8, 0);
 708         if (retval < 0) {
 709                 dev_err(&dev->dev, "Failed to allocate colormap\n");
 710                 goto err_free_irq;
 711         }
 712
 713         /* set cmap */
 714         for (i = 0; i < 8; i++)
 715                 info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/16;
 716         memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*8);
 717         memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*8);
 718
 719         retval = register_framebuffer(info);
 720         if (retval < 0)
 721                 goto err_cmap;
 722
 723         platform_set_drvdata(dev, info);
 724
 725         dev_dbg(&dev->dev,
 726                 "fb%d: Metronome frame buffer device, using %dK of video"
 727                 " memory\n", info->node, videomemorysize >> 10);
 728
 729         return 0;
 730
 731 err_cmap:
 732         fb_dealloc_cmap(&info->cmap);
 733 err_free_irq:
 734         board->cleanup(par);
 735 err_csum_table:
 736         vfree(par->csum_table);
 737 err_vfree:
 738         vfree(videomemory);
 739 err_fb_rel:
 740         framebuffer_release(info);
 741 err:
 742         module_put(board->owner);
 743         return retval;
 744 }
 745
 746 static int __devexit metronomefb_remove(struct platform_device *dev)
 747 {
 748         struct fb_info *info = platform_get_drvdata(dev);
 749
 750         if (info) {
 751                 struct metronomefb_par *par = info->par;
 752
 753                 unregister_framebuffer(info);
 754                 fb_deferred_io_cleanup(info);
 755                 fb_dealloc_cmap(&info->cmap);
 756                 par->board->cleanup(par);
 757                 vfree(par->csum_table);
 758                 vfree((void __force *)info->screen_base);
 759                 module_put(par->board->owner);
 760                 dev_dbg(&dev->dev, "calling release\n");
 761                 framebuffer_release(info);
 762         }
 763         return 0;
 764 }
 765
 766 static struct platform_driver metronomefb_driver = {
 767         .probe  = metronomefb_probe,
 768         .remove = metronomefb_remove,
 769         .driver = {
 770                 .owner  = THIS_MODULE,
 771                 .name   = "metronomefb",
 772         },
 773 };
 774
 775 static int __init metronomefb_init(void)
 776 {
 777         return platform_driver_register(&metronomefb_driver);
 778 }
 779
 780 static void __exit metronomefb_exit(void)
 781 {
 782         platform_driver_unregister(&metronomefb_driver);
 783 }
 784
 785 module_param(user_wfm_size, uint, 0);
 786 MODULE_PARM_DESC(user_wfm_size, "Set custom waveform size");
 787
 788 module_init(metronomefb_init);
 789 module_exit(metronomefb_exit);
 790
 791 MODULE_DESCRIPTION("fbdev driver for Metronome controller");
 792 MODULE_AUTHOR("Jaya Kumar");
 793 MODULE_LICENSE("GPL");