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