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 = {
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 = {
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 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 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 
371 static 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 
390 static 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 
416 static 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 
437 static 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 
452 static 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 */
468 static 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 
488 static 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 
497 static 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 
506 static 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  */
519 static 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 
561 static const 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 
569 static struct fb_deferred_io metronomefb_defio = {
570 	.delay		= HZ,
571 	.deferred_io	= metronomefb_dpy_deferred_io,
572 };
573 
574 static 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 
732 err_cmap:
733 	fb_dealloc_cmap(&info->cmap);
734 err_free_irq:
735 	board->cleanup(par);
736 err_csum_table:
737 	vfree(par->csum_table);
738 err_vfree:
739 	vfree(videomemory);
740 err_fb_rel:
741 	framebuffer_release(info);
742 err:
743 	module_put(board->owner);
744 	return retval;
745 }
746 
747 static 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 
767 static struct platform_driver metronomefb_driver = {
768 	.probe	= metronomefb_probe,
769 	.remove = metronomefb_remove,
770 	.driver	= {
771 		.name	= "metronomefb",
772 	},
773 };
774 module_platform_driver(metronomefb_driver);
775 
776 module_param(user_wfm_size, uint, 0);
777 MODULE_PARM_DESC(user_wfm_size, "Set custom waveform size");
778 
779 MODULE_DESCRIPTION("fbdev driver for Metronome controller");
780 MODULE_AUTHOR("Jaya Kumar");
781 MODULE_LICENSE("GPL");
782