57dc1a0065c2d38948e87568f01f198ecf675fe1
[linux-2.6.git] / drivers / video / broadsheetfb.c
1 /*
2  * broadsheetfb.c -- FB driver for E-Ink Broadsheet 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 driver is written to be used with the Broadsheet display controller.
13  *
14  * It is intended to be architecture independent. A board specific driver
15  * must be used to perform all the physical IO interactions.
16  *
17  */
18
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/string.h>
23 #include <linux/mm.h>
24 #include <linux/slab.h>
25 #include <linux/vmalloc.h>
26 #include <linux/delay.h>
27 #include <linux/interrupt.h>
28 #include <linux/fb.h>
29 #include <linux/init.h>
30 #include <linux/platform_device.h>
31 #include <linux/list.h>
32 #include <linux/uaccess.h>
33
34 #include <video/broadsheetfb.h>
35
36 /* track panel specific parameters */
37 struct panel_info {
38         int w;
39         int h;
40         u16 sdcfg;
41         u16 gdcfg;
42         u16 lutfmt;
43         u16 fsynclen;
44         u16 fendfbegin;
45         u16 lsynclen;
46         u16 lendlbegin;
47         u16 pixclk;
48 };
49
50 /* table of panel specific parameters to be indexed into by the board drivers */
51 static struct panel_info panel_table[] = {
52         {       /* standard 6" on TFT backplane */
53                 .w = 800,
54                 .h = 600,
55                 .sdcfg = (100 | (1 << 8) | (1 << 9)),
56                 .gdcfg = 2,
57                 .lutfmt = (4 | (1 << 7)),
58                 .fsynclen = 4,
59                 .fendfbegin = (10 << 8) | 4,
60                 .lsynclen = 10,
61                 .lendlbegin = (100 << 8) | 4,
62                 .pixclk = 6,
63         },
64         {       /* custom 3.7" flexible on PET or steel */
65                 .w = 320,
66                 .h = 240,
67                 .sdcfg = (67 | (0 << 8) | (0 << 9) | (0 << 10) | (0 << 12)),
68                 .gdcfg = 3,
69                 .lutfmt = (4 | (1 << 7)),
70                 .fsynclen = 0,
71                 .fendfbegin = (80 << 8) | 4,
72                 .lsynclen = 10,
73                 .lendlbegin = (80 << 8) | 20,
74                 .pixclk = 14,
75         },
76         {       /* standard 9.7" on TFT backplane */
77                 .w = 1200,
78                 .h = 825,
79                 .sdcfg = (100 | (1 << 8) | (1 << 9) | (0 << 10) | (0 << 12)),
80                 .gdcfg = 2,
81                 .lutfmt = (4 | (1 << 7)),
82                 .fsynclen = 0,
83                 .fendfbegin = (4 << 8) | 4,
84                 .lsynclen = 4,
85                 .lendlbegin = (60 << 8) | 10,
86                 .pixclk = 3,
87         },
88 };
89
90 #define DPY_W 800
91 #define DPY_H 600
92
93 static struct fb_fix_screeninfo broadsheetfb_fix __devinitdata = {
94         .id =           "broadsheetfb",
95         .type =         FB_TYPE_PACKED_PIXELS,
96         .visual =       FB_VISUAL_STATIC_PSEUDOCOLOR,
97         .xpanstep =     0,
98         .ypanstep =     0,
99         .ywrapstep =    0,
100         .line_length =  DPY_W,
101         .accel =        FB_ACCEL_NONE,
102 };
103
104 static struct fb_var_screeninfo broadsheetfb_var __devinitdata = {
105         .xres           = DPY_W,
106         .yres           = DPY_H,
107         .xres_virtual   = DPY_W,
108         .yres_virtual   = DPY_H,
109         .bits_per_pixel = 8,
110         .grayscale      = 1,
111         .red =          { 0, 4, 0 },
112         .green =        { 0, 4, 0 },
113         .blue =         { 0, 4, 0 },
114         .transp =       { 0, 0, 0 },
115 };
116
117 /* main broadsheetfb functions */
118 static void broadsheet_gpio_issue_data(struct broadsheetfb_par *par, u16 data)
119 {
120         par->board->set_ctl(par, BS_WR, 0);
121         par->board->set_hdb(par, data);
122         par->board->set_ctl(par, BS_WR, 1);
123 }
124
125 static void broadsheet_gpio_issue_cmd(struct broadsheetfb_par *par, u16 data)
126 {
127         par->board->set_ctl(par, BS_DC, 0);
128         broadsheet_gpio_issue_data(par, data);
129 }
130
131 static void broadsheet_gpio_send_command(struct broadsheetfb_par *par, u16 data)
132 {
133         par->board->wait_for_rdy(par);
134
135         par->board->set_ctl(par, BS_CS, 0);
136         broadsheet_gpio_issue_cmd(par, data);
137         par->board->set_ctl(par, BS_DC, 1);
138         par->board->set_ctl(par, BS_CS, 1);
139 }
140
141 static void broadsheet_gpio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
142                                         int argc, u16 *argv)
143 {
144         int i;
145
146         par->board->wait_for_rdy(par);
147
148         par->board->set_ctl(par, BS_CS, 0);
149         broadsheet_gpio_issue_cmd(par, cmd);
150         par->board->set_ctl(par, BS_DC, 1);
151
152         for (i = 0; i < argc; i++)
153                 broadsheet_gpio_issue_data(par, argv[i]);
154         par->board->set_ctl(par, BS_CS, 1);
155 }
156
157 static void broadsheet_mmio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
158                                     int argc, u16 *argv)
159 {
160         int i;
161
162         par->board->mmio_write(par, BS_MMIO_CMD, cmd);
163
164         for (i = 0; i < argc; i++)
165                 par->board->mmio_write(par, BS_MMIO_DATA, argv[i]);
166 }
167
168 static void broadsheet_send_command(struct broadsheetfb_par *par, u16 data)
169 {
170         if (par->board->mmio_write)
171                 par->board->mmio_write(par, BS_MMIO_CMD, data);
172         else
173                 broadsheet_gpio_send_command(par, data);
174 }
175
176 static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
177                                     int argc, u16 *argv)
178 {
179         if (par->board->mmio_write)
180                 broadsheet_mmio_send_cmdargs(par, cmd, argc, argv);
181         else
182                 broadsheet_gpio_send_cmdargs(par, cmd, argc, argv);
183 }
184
185 static void broadsheet_gpio_burst_write(struct broadsheetfb_par *par, int size,
186                                         u16 *data)
187 {
188         int i;
189         u16 tmp;
190
191         par->board->set_ctl(par, BS_CS, 0);
192         par->board->set_ctl(par, BS_DC, 1);
193
194         for (i = 0; i < size; i++) {
195                 par->board->set_ctl(par, BS_WR, 0);
196                 tmp = (data[i] & 0x0F) << 4;
197                 tmp |= (data[i] & 0x0F00) << 4;
198                 par->board->set_hdb(par, tmp);
199                 par->board->set_ctl(par, BS_WR, 1);
200         }
201
202         par->board->set_ctl(par, BS_CS, 1);
203 }
204
205 static void broadsheet_mmio_burst_write(struct broadsheetfb_par *par, int size,
206                                    u16 *data)
207 {
208         int i;
209         u16 tmp;
210
211         for (i = 0; i < size; i++) {
212                 tmp = (data[i] & 0x0F) << 4;
213                 tmp |= (data[i] & 0x0F00) << 4;
214                 par->board->mmio_write(par, BS_MMIO_DATA, tmp);
215         }
216
217 }
218
219 static void broadsheet_burst_write(struct broadsheetfb_par *par, int size,
220                                    u16 *data)
221 {
222         if (par->board->mmio_write)
223                 broadsheet_mmio_burst_write(par, size, data);
224         else
225                 broadsheet_gpio_burst_write(par, size, data);
226 }
227
228 static u16 broadsheet_gpio_get_data(struct broadsheetfb_par *par)
229 {
230         u16 res;
231         /* wait for ready to go hi. (lo is busy) */
232         par->board->wait_for_rdy(par);
233
234         /* cs lo, dc lo for cmd, we lo for each data, db as usual */
235         par->board->set_ctl(par, BS_DC, 1);
236         par->board->set_ctl(par, BS_CS, 0);
237         par->board->set_ctl(par, BS_WR, 0);
238
239         res = par->board->get_hdb(par);
240
241         /* strobe wr */
242         par->board->set_ctl(par, BS_WR, 1);
243         par->board->set_ctl(par, BS_CS, 1);
244
245         return res;
246 }
247
248
249 static u16 broadsheet_get_data(struct broadsheetfb_par *par)
250 {
251         if (par->board->mmio_read)
252                 return par->board->mmio_read(par);
253         else
254                 return broadsheet_gpio_get_data(par);
255 }
256
257 static void broadsheet_gpio_write_reg(struct broadsheetfb_par *par, u16 reg,
258                                         u16 data)
259 {
260         /* wait for ready to go hi. (lo is busy) */
261         par->board->wait_for_rdy(par);
262
263         /* cs lo, dc lo for cmd, we lo for each data, db as usual */
264         par->board->set_ctl(par, BS_CS, 0);
265
266         broadsheet_gpio_issue_cmd(par, BS_CMD_WR_REG);
267
268         par->board->set_ctl(par, BS_DC, 1);
269
270         broadsheet_gpio_issue_data(par, reg);
271         broadsheet_gpio_issue_data(par, data);
272
273         par->board->set_ctl(par, BS_CS, 1);
274 }
275
276 static void broadsheet_mmio_write_reg(struct broadsheetfb_par *par, u16 reg,
277                                  u16 data)
278 {
279         par->board->mmio_write(par, BS_MMIO_CMD, BS_CMD_WR_REG);
280         par->board->mmio_write(par, BS_MMIO_DATA, reg);
281         par->board->mmio_write(par, BS_MMIO_DATA, data);
282
283 }
284
285 static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg,
286                                         u16 data)
287 {
288         if (par->board->mmio_write)
289                 broadsheet_mmio_write_reg(par, reg, data);
290         else
291                 broadsheet_gpio_write_reg(par, reg, data);
292 }
293
294 static void broadsheet_write_reg32(struct broadsheetfb_par *par, u16 reg,
295                                         u32 data)
296 {
297         broadsheet_write_reg(par, reg, cpu_to_le32(data) & 0xFFFF);
298         broadsheet_write_reg(par, reg + 2, (cpu_to_le32(data) >> 16) & 0xFFFF);
299 }
300
301
302 static u16 broadsheet_read_reg(struct broadsheetfb_par *par, u16 reg)
303 {
304         broadsheet_send_cmdargs(par, BS_CMD_RD_REG, 1, &reg);
305         par->board->wait_for_rdy(par);
306         return broadsheet_get_data(par);
307 }
308
309 static void __devinit broadsheet_init_display(struct broadsheetfb_par *par)
310 {
311         u16 args[5];
312         int xres = par->info->var.xres;
313         int yres = par->info->var.yres;
314
315         args[0] = panel_table[par->panel_index].w;
316         args[1] = panel_table[par->panel_index].h;
317         args[2] = panel_table[par->panel_index].sdcfg;
318         args[3] = panel_table[par->panel_index].gdcfg;
319         args[4] = panel_table[par->panel_index].lutfmt;
320         broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
321
322         /* did the controller really set it? */
323         broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
324
325         args[0] = panel_table[par->panel_index].fsynclen;
326         args[1] = panel_table[par->panel_index].fendfbegin;
327         args[2] = panel_table[par->panel_index].lsynclen;
328         args[3] = panel_table[par->panel_index].lendlbegin;
329         args[4] = panel_table[par->panel_index].pixclk;
330         broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_TMG, 5, args);
331
332         broadsheet_write_reg32(par, 0x310, xres*yres*2);
333
334         /* setup waveform */
335         args[0] = 0x886;
336         args[1] = 0;
337         broadsheet_send_cmdargs(par, BS_CMD_RD_WFM_INFO, 2, args);
338
339         broadsheet_send_command(par, BS_CMD_UPD_GDRV_CLR);
340
341         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
342
343         broadsheet_write_reg(par, 0x330, 0x84);
344
345         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
346
347         args[0] = (0x3 << 4);
348         broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
349
350         args[0] = 0x154;
351         broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
352
353         broadsheet_burst_write(par, (panel_table[par->panel_index].w *
354                                         panel_table[par->panel_index].h)/2,
355                                         (u16 *) par->info->screen_base);
356
357         broadsheet_send_command(par, BS_CMD_LD_IMG_END);
358
359         args[0] = 0x4300;
360         broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
361
362         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
363
364         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
365
366         par->board->wait_for_rdy(par);
367 }
368
369 static void __devinit broadsheet_init(struct broadsheetfb_par *par)
370 {
371         broadsheet_send_command(par, BS_CMD_INIT_SYS_RUN);
372         /* the controller needs a second */
373         msleep(1000);
374         broadsheet_init_display(par);
375 }
376
377 static void broadsheetfb_dpy_update_pages(struct broadsheetfb_par *par,
378                                                 u16 y1, u16 y2)
379 {
380         u16 args[5];
381         unsigned char *buf = (unsigned char *)par->info->screen_base;
382
383         /* y1 must be a multiple of 4 so drop the lower bits */
384         y1 &= 0xFFFC;
385         /* y2 must be a multiple of 4 , but - 1 so up the lower bits */
386         y2 |= 0x0003;
387
388         args[0] = 0x3 << 4;
389         args[1] = 0;
390         args[2] = y1;
391         args[3] = cpu_to_le16(par->info->var.xres);
392         args[4] = y2;
393         broadsheet_send_cmdargs(par, BS_CMD_LD_IMG_AREA, 5, args);
394
395         args[0] = 0x154;
396         broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
397
398         buf += y1 * par->info->var.xres;
399         broadsheet_burst_write(par, ((1 + y2 - y1) * par->info->var.xres)/2,
400                                 (u16 *) buf);
401
402         broadsheet_send_command(par, BS_CMD_LD_IMG_END);
403
404         args[0] = 0x4300;
405         broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
406
407         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
408
409         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
410
411         par->board->wait_for_rdy(par);
412
413 }
414
415 static void broadsheetfb_dpy_update(struct broadsheetfb_par *par)
416 {
417         u16 args[5];
418
419         args[0] = 0x3 << 4;
420         broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
421
422         args[0] = 0x154;
423         broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
424         broadsheet_burst_write(par, (panel_table[par->panel_index].w *
425                                         panel_table[par->panel_index].h)/2,
426                                         (u16 *) par->info->screen_base);
427
428         broadsheet_send_command(par, BS_CMD_LD_IMG_END);
429
430         args[0] = 0x4300;
431         broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
432
433         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
434
435         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
436
437         par->board->wait_for_rdy(par);
438
439 }
440
441 /* this is called back from the deferred io workqueue */
442 static void broadsheetfb_dpy_deferred_io(struct fb_info *info,
443                                 struct list_head *pagelist)
444 {
445         u16 y1 = 0, h = 0;
446         int prev_index = -1;
447         struct page *cur;
448         struct fb_deferred_io *fbdefio = info->fbdefio;
449         int h_inc;
450         u16 yres = info->var.yres;
451         u16 xres = info->var.xres;
452
453         /* height increment is fixed per page */
454         h_inc = DIV_ROUND_UP(PAGE_SIZE , xres);
455
456         /* walk the written page list and swizzle the data */
457         list_for_each_entry(cur, &fbdefio->pagelist, lru) {
458                 if (prev_index < 0) {
459                         /* just starting so assign first page */
460                         y1 = (cur->index << PAGE_SHIFT) / xres;
461                         h = h_inc;
462                 } else if ((prev_index + 1) == cur->index) {
463                         /* this page is consecutive so increase our height */
464                         h += h_inc;
465                 } else {
466                         /* page not consecutive, issue previous update first */
467                         broadsheetfb_dpy_update_pages(info->par, y1, y1 + h);
468                         /* start over with our non consecutive page */
469                         y1 = (cur->index << PAGE_SHIFT) / xres;
470                         h = h_inc;
471                 }
472                 prev_index = cur->index;
473         }
474
475         /* if we still have any pages to update we do so now */
476         if (h >= yres) {
477                 /* its a full screen update, just do it */
478                 broadsheetfb_dpy_update(info->par);
479         } else {
480                 broadsheetfb_dpy_update_pages(info->par, y1,
481                                                 min((u16) (y1 + h), yres));
482         }
483 }
484
485 static void broadsheetfb_fillrect(struct fb_info *info,
486                                    const struct fb_fillrect *rect)
487 {
488         struct broadsheetfb_par *par = info->par;
489
490         sys_fillrect(info, rect);
491
492         broadsheetfb_dpy_update(par);
493 }
494
495 static void broadsheetfb_copyarea(struct fb_info *info,
496                                    const struct fb_copyarea *area)
497 {
498         struct broadsheetfb_par *par = info->par;
499
500         sys_copyarea(info, area);
501
502         broadsheetfb_dpy_update(par);
503 }
504
505 static void broadsheetfb_imageblit(struct fb_info *info,
506                                 const struct fb_image *image)
507 {
508         struct broadsheetfb_par *par = info->par;
509
510         sys_imageblit(info, image);
511
512         broadsheetfb_dpy_update(par);
513 }
514
515 /*
516  * this is the slow path from userspace. they can seek and write to
517  * the fb. it's inefficient to do anything less than a full screen draw
518  */
519 static ssize_t broadsheetfb_write(struct fb_info *info, const char __user *buf,
520                                 size_t count, loff_t *ppos)
521 {
522         struct broadsheetfb_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 *)(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         broadsheetfb_dpy_update(par);
557
558         return (err) ? err : count;
559 }
560
561 static struct fb_ops broadsheetfb_ops = {
562         .owner          = THIS_MODULE,
563         .fb_read        = fb_sys_read,
564         .fb_write       = broadsheetfb_write,
565         .fb_fillrect    = broadsheetfb_fillrect,
566         .fb_copyarea    = broadsheetfb_copyarea,
567         .fb_imageblit   = broadsheetfb_imageblit,
568 };
569
570 static struct fb_deferred_io broadsheetfb_defio = {
571         .delay          = HZ/4,
572         .deferred_io    = broadsheetfb_dpy_deferred_io,
573 };
574
575 static int __devinit broadsheetfb_probe(struct platform_device *dev)
576 {
577         struct fb_info *info;
578         struct broadsheet_board *board;
579         int retval = -ENOMEM;
580         int videomemorysize;
581         unsigned char *videomemory;
582         struct broadsheetfb_par *par;
583         int i;
584         int dpyw, dpyh;
585         int panel_index;
586
587         /* pick up board specific routines */
588         board = dev->dev.platform_data;
589         if (!board)
590                 return -EINVAL;
591
592         /* try to count device specific driver, if can't, platform recalls */
593         if (!try_module_get(board->owner))
594                 return -ENODEV;
595
596         info = framebuffer_alloc(sizeof(struct broadsheetfb_par), &dev->dev);
597         if (!info)
598                 goto err;
599
600         switch (board->get_panel_type()) {
601         case 37:
602                 panel_index = 1;
603                 break;
604         case 97:
605                 panel_index = 2;
606                 break;
607         case 6:
608         default:
609                 panel_index = 0;
610                 break;
611         }
612
613         dpyw = panel_table[panel_index].w;
614         dpyh = panel_table[panel_index].h;
615
616         videomemorysize = roundup((dpyw*dpyh), PAGE_SIZE);
617
618         videomemory = vmalloc(videomemorysize);
619         if (!videomemory)
620                 goto err_fb_rel;
621
622         memset(videomemory, 0, videomemorysize);
623
624         info->screen_base = (char *)videomemory;
625         info->fbops = &broadsheetfb_ops;
626
627         broadsheetfb_var.xres = dpyw;
628         broadsheetfb_var.yres = dpyh;
629         broadsheetfb_var.xres_virtual = dpyw;
630         broadsheetfb_var.yres_virtual = dpyh;
631         info->var = broadsheetfb_var;
632
633         broadsheetfb_fix.line_length = dpyw;
634         info->fix = broadsheetfb_fix;
635         info->fix.smem_len = videomemorysize;
636         par = info->par;
637         par->panel_index = panel_index;
638         par->info = info;
639         par->board = board;
640         par->write_reg = broadsheet_write_reg;
641         par->read_reg = broadsheet_read_reg;
642         init_waitqueue_head(&par->waitq);
643
644         info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
645
646         info->fbdefio = &broadsheetfb_defio;
647         fb_deferred_io_init(info);
648
649         retval = fb_alloc_cmap(&info->cmap, 16, 0);
650         if (retval < 0) {
651                 dev_err(&dev->dev, "Failed to allocate colormap\n");
652                 goto err_vfree;
653         }
654
655         /* set cmap */
656         for (i = 0; i < 16; i++)
657                 info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/32;
658         memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*16);
659         memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*16);
660
661         retval = par->board->setup_irq(info);
662         if (retval < 0)
663                 goto err_cmap;
664
665         /* this inits the dpy */
666         retval = board->init(par);
667         if (retval < 0)
668                 goto err_free_irq;
669
670         broadsheet_init(par);
671
672         retval = register_framebuffer(info);
673         if (retval < 0)
674                 goto err_free_irq;
675         platform_set_drvdata(dev, info);
676
677         printk(KERN_INFO
678                "fb%d: Broadsheet frame buffer, using %dK of video memory\n",
679                info->node, videomemorysize >> 10);
680
681
682         return 0;
683
684 err_free_irq:
685         board->cleanup(par);
686 err_cmap:
687         fb_dealloc_cmap(&info->cmap);
688 err_vfree:
689         vfree(videomemory);
690 err_fb_rel:
691         framebuffer_release(info);
692 err:
693         module_put(board->owner);
694         return retval;
695
696 }
697
698 static int __devexit broadsheetfb_remove(struct platform_device *dev)
699 {
700         struct fb_info *info = platform_get_drvdata(dev);
701
702         if (info) {
703                 struct broadsheetfb_par *par = info->par;
704                 unregister_framebuffer(info);
705                 fb_deferred_io_cleanup(info);
706                 par->board->cleanup(par);
707                 fb_dealloc_cmap(&info->cmap);
708                 vfree((void *)info->screen_base);
709                 module_put(par->board->owner);
710                 framebuffer_release(info);
711         }
712         return 0;
713 }
714
715 static struct platform_driver broadsheetfb_driver = {
716         .probe  = broadsheetfb_probe,
717         .remove = broadsheetfb_remove,
718         .driver = {
719                 .owner  = THIS_MODULE,
720                 .name   = "broadsheetfb",
721         },
722 };
723
724 static int __init broadsheetfb_init(void)
725 {
726         return platform_driver_register(&broadsheetfb_driver);
727 }
728
729 static void __exit broadsheetfb_exit(void)
730 {
731         platform_driver_unregister(&broadsheetfb_driver);
732 }
733
734 module_init(broadsheetfb_init);
735 module_exit(broadsheetfb_exit);
736
737 MODULE_DESCRIPTION("fbdev driver for Broadsheet controller");
738 MODULE_AUTHOR("Jaya Kumar");
739 MODULE_LICENSE("GPL");