?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fbdev: metronomefb bugfix
[linux-2.6/verdex.git] / drivers / video / metronomefb.c
blob5602f3e3f91986ad94a6e408b2d7d5727623d8aa
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 was tested with an E-Ink 800x600 Vizplex EPD on a Gumstix Connex board
17 * using the Lyre interface board.
18 *
19 * General notes:
20 * - User must set metronomefb_enable=1 to enable it.
21 * - See Documentation/fb/metronomefb.txt for how metronome works.
22 */
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/string.h>
27 #include <linux/mm.h>
28 #include <linux/slab.h>
29 #include <linux/vmalloc.h>
30 #include <linux/delay.h>
31 #include <linux/interrupt.h>
32 #include <linux/fb.h>
33 #include <linux/init.h>
34 #include <linux/platform_device.h>
35 #include <linux/list.h>
36 #include <linux/firmware.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/uaccess.h>
39 #include <linux/irq.h>
40
41 #include <asm/arch/pxa-regs.h>
42 #include <asm/unaligned.h>
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 struct metromem_desc {
57 u32 mFDADR0;
58 u32 mFSADR0;
59 u32 mFIDR0;
60 u32 mLDCMD0;
61 };
62
63 struct metromem_cmd {
64 u16 opcode;
65 u16 args[((64-2)/2)];
66 u16 csum;
67 };
68
69 struct metronomefb_par {
70 unsigned char *metromem;
71 struct metromem_desc *metromem_desc;
72 struct metromem_cmd *metromem_cmd;
73 unsigned char *metromem_wfm;
74 unsigned char *metromem_img;
75 u16 *metromem_img_csum;
76 u16 *csum_table;
77 int metromemsize;
78 dma_addr_t metromem_dma;
79 dma_addr_t metromem_desc_dma;
80 struct fb_info *info;
81 wait_queue_head_t waitq;
82 u8 frame_count;
83 };
84
85 /* frame differs from image. frame includes non-visible pixels */
86 struct epd_frame {
87 int fw; /* frame width */
88 int fh; /* frame height */
89 };
90
91 static struct epd_frame epd_frame_table[] = {
92 {
93 .fw = 832,
94 .fh = 622
95 },
96 };
97
98 static struct fb_fix_screeninfo metronomefb_fix __devinitdata = {
99 .id = "metronomefb",
100 .type = FB_TYPE_PACKED_PIXELS,
101 .visual = FB_VISUAL_STATIC_PSEUDOCOLOR,
102 .xpanstep = 0,
103 .ypanstep = 0,
104 .ywrapstep = 0,
105 .line_length = DPY_W,
106 .accel = FB_ACCEL_NONE,
107 };
108
109 static struct fb_var_screeninfo metronomefb_var __devinitdata = {
110 .xres = DPY_W,
111 .yres = DPY_H,
112 .xres_virtual = DPY_W,
113 .yres_virtual = DPY_H,
114 .bits_per_pixel = 8,
115 .grayscale = 1,
116 .nonstd = 1,
117 .red = { 4, 3, 0 },
118 .green = { 0, 0, 0 },
119 .blue = { 0, 0, 0 },
120 .transp = { 0, 0, 0 },
121 };
122
123 static unsigned int metronomefb_enable;
124
125 struct waveform_hdr {
126 u8 stuff[32];
127
128 u8 wmta[3];
129 u8 fvsn;
130
131 u8 luts;
132 u8 mc;
133 u8 trc;
134 u8 stuff3;
135
136 u8 endb;
137 u8 swtb;
138 u8 stuff2a[2];
139
140 u8 stuff2b[3];
141 u8 wfm_cs;
142 } __attribute__ ((packed));
143
144 /* main metronomefb functions */
145 static u8 calc_cksum(int start, int end, u8 *mem)
146 {
147 u8 tmp = 0;
148 int i;
149
150 for (i = start; i < end; i++)
151 tmp += mem[i];
152
153 return tmp;
154 }
155
156 static u16 calc_img_cksum(u16 *start, int length)
157 {
158 u16 tmp = 0;
159
160 while (length--)
161 tmp += *start++;
162
163 return tmp;
164 }
165
166 /* here we decode the incoming waveform file and populate metromem */
167 #define EXP_WFORM_SIZE 47001
168 static int load_waveform(u8 *mem, size_t size, u8 *metromem, int m, int t,
169 u8 *frame_count)
170 {
171 int tta;
172 int wmta;
173 int trn = 0;
174 int i;
175 unsigned char v;
176 u8 cksum;
177 int cksum_idx;
178 int wfm_idx, owfm_idx;
179 int mem_idx = 0;
180 struct waveform_hdr *wfm_hdr;
181
182 if (size != EXP_WFORM_SIZE) {
183 printk(KERN_ERR "Error: unexpected size %d != %d\n", size,
184 EXP_WFORM_SIZE);
185 return -EINVAL;
186 }
187
188 wfm_hdr = (struct waveform_hdr *) mem;
189
190 if (wfm_hdr->fvsn != 1) {
191 printk(KERN_ERR "Error: bad fvsn %x\n", wfm_hdr->fvsn);
192 return -EINVAL;
193 }
194 if (wfm_hdr->luts != 0) {
195 printk(KERN_ERR "Error: bad luts %x\n", wfm_hdr->luts);
196 return -EINVAL;
197 }
198 cksum = calc_cksum(32, 47, mem);
199 if (cksum != wfm_hdr->wfm_cs) {
200 printk(KERN_ERR "Error: bad cksum %x != %x\n", cksum,
201 wfm_hdr->wfm_cs);
202 return -EINVAL;
203 }
204 wfm_hdr->mc += 1;
205 wfm_hdr->trc += 1;
206 for (i = 0; i < 5; i++) {
207 if (*(wfm_hdr->stuff2a + i) != 0) {
208 printk(KERN_ERR "Error: unexpected value in padding\n");
209 return -EINVAL;
210 }
211 }
212
213 /* calculating trn. trn is something used to index into
214 the waveform. presumably selecting the right one for the
215 desired temperature. it works out the offset of the first
216 v that exceeds the specified temperature */
217 if ((sizeof(*wfm_hdr) + wfm_hdr->trc) > size)
218 return -EINVAL;
219
220 for (i = sizeof(*wfm_hdr); i <= sizeof(*wfm_hdr) + wfm_hdr->trc; i++) {
221 if (mem[i] > t) {
222 trn = i - sizeof(*wfm_hdr) - 1;
223 break;
224 }
225 }
226
227 /* check temperature range table checksum */
228 cksum_idx = sizeof(*wfm_hdr) + wfm_hdr->trc + 1;
229 if (cksum_idx > size)
230 return -EINVAL;
231 cksum = calc_cksum(sizeof(*wfm_hdr), cksum_idx, mem);
232 if (cksum != mem[cksum_idx]) {
233 printk(KERN_ERR "Error: bad temperature range table cksum"
234 " %x != %x\n", cksum, mem[cksum_idx]);
235 return -EINVAL;
236 }
237
238 /* check waveform mode table address checksum */
239 wmta = le32_to_cpu(get_unaligned((__le32 *) wfm_hdr->wmta));
240 wmta &= 0x00FFFFFF;
241 cksum_idx = wmta + m*4 + 3;
242 if (cksum_idx > size)
243 return -EINVAL;
244 cksum = calc_cksum(cksum_idx - 3, cksum_idx, mem);
245 if (cksum != mem[cksum_idx]) {
246 printk(KERN_ERR "Error: bad mode table address cksum"
247 " %x != %x\n", cksum, mem[cksum_idx]);
248 return -EINVAL;
249 }
250
251 /* check waveform temperature table address checksum */
252 tta = le32_to_cpu(get_unaligned((int *) (mem + wmta + m*4)));
253 tta &= 0x00FFFFFF;
254 cksum_idx = tta + trn*4 + 3;
255 if (cksum_idx > size)
256 return -EINVAL;
257 cksum = calc_cksum(cksum_idx - 3, cksum_idx, mem);
258 if (cksum != mem[cksum_idx]) {
259 printk(KERN_ERR "Error: bad temperature table address cksum"
260 " %x != %x\n", cksum, mem[cksum_idx]);
261 return -EINVAL;
262 }
263
264 /* here we do the real work of putting the waveform into the
265 metromem buffer. this does runlength decoding of the waveform */
266 wfm_idx = le32_to_cpu(get_unaligned((__le32 *) (mem + tta + trn*4)));
267 wfm_idx &= 0x00FFFFFF;
268 owfm_idx = wfm_idx;
269 if (wfm_idx > size)
270 return -EINVAL;
271 while (wfm_idx < size) {
272 unsigned char rl;
273 v = mem[wfm_idx++];
274 if (v == wfm_hdr->swtb) {
275 while (((v = mem[wfm_idx++]) != wfm_hdr->swtb) &&
276 wfm_idx < size)
277 metromem[mem_idx++] = v;
278
279 continue;
280 }
281
282 if (v == wfm_hdr->endb)
283 break;
284
285 rl = mem[wfm_idx++];
286 for (i = 0; i <= rl; i++)
287 metromem[mem_idx++] = v;
288 }
289
290 cksum_idx = wfm_idx;
291 if (cksum_idx > size)
292 return -EINVAL;
293 cksum = calc_cksum(owfm_idx, cksum_idx, mem);
294 if (cksum != mem[cksum_idx]) {
295 printk(KERN_ERR "Error: bad waveform data cksum"
296 " %x != %x\n", cksum, mem[cksum_idx]);
297 return -EINVAL;
298 }
299 *frame_count = (mem_idx/64);
300
301 return 0;
302 }
303
304 /* register offsets for gpio control */
305 #define LED_GPIO_PIN 51
306 #define STDBY_GPIO_PIN 48
307 #define RST_GPIO_PIN 49
308 #define RDY_GPIO_PIN 32
309 #define ERR_GPIO_PIN 17
310 #define PCBPWR_GPIO_PIN 16
311
312 #define AF_SEL_GPIO_N 0x3
313 #define GAFR0_U_OFFSET(pin) ((pin - 16) * 2)
314 #define GAFR1_L_OFFSET(pin) ((pin - 32) * 2)
315 #define GAFR1_U_OFFSET(pin) ((pin - 48) * 2)
316 #define GPDR1_OFFSET(pin) (pin - 32)
317 #define GPCR1_OFFSET(pin) (pin - 32)
318 #define GPSR1_OFFSET(pin) (pin - 32)
319 #define GPCR0_OFFSET(pin) (pin)
320 #define GPSR0_OFFSET(pin) (pin)
321
322 static void metronome_set_gpio_output(int pin, int val)
323 {
324 u8 index;
325
326 index = pin >> 4;
327
328 switch (index) {
329 case 1:
330 if (val)
331 GPSR0 |= (1 << GPSR0_OFFSET(pin));
332 else
333 GPCR0 |= (1 << GPCR0_OFFSET(pin));
334 break;
335 case 2:
336 break;
337 case 3:
338 if (val)
339 GPSR1 |= (1 << GPSR1_OFFSET(pin));
340 else
341 GPCR1 |= (1 << GPCR1_OFFSET(pin));
342 break;
343 default:
344 printk(KERN_ERR "unimplemented\n");
345 }
346 }
347
348 static void __devinit metronome_init_gpio_pin(int pin, int dir)
349 {
350 u8 index;
351 /* dir 0 is output, 1 is input
352 - do 2 things here:
353 - set gpio alternate function to standard gpio
354 - set gpio direction to input or output */
355
356 index = pin >> 4;
357 switch (index) {
358 case 1:
359 GAFR0_U &= ~(AF_SEL_GPIO_N << GAFR0_U_OFFSET(pin));
360
361 if (dir)
362 GPDR0 &= ~(1 << pin);
363 else
364 GPDR0 |= (1 << pin);
365 break;
366 case 2:
367 GAFR1_L &= ~(AF_SEL_GPIO_N << GAFR1_L_OFFSET(pin));
368
369 if (dir)
370 GPDR1 &= ~(1 << GPDR1_OFFSET(pin));
371 else
372 GPDR1 |= (1 << GPDR1_OFFSET(pin));
373 break;
374 case 3:
375 GAFR1_U &= ~(AF_SEL_GPIO_N << GAFR1_U_OFFSET(pin));
376
377 if (dir)
378 GPDR1 &= ~(1 << GPDR1_OFFSET(pin));
379 else
380 GPDR1 |= (1 << GPDR1_OFFSET(pin));
381 break;
382 default:
383 printk(KERN_ERR "unimplemented\n");
384 }
385 }
386
387 static void __devinit metronome_init_gpio_regs(void)
388 {
389 metronome_init_gpio_pin(LED_GPIO_PIN, 0);
390 metronome_set_gpio_output(LED_GPIO_PIN, 0);
391
392 metronome_init_gpio_pin(STDBY_GPIO_PIN, 0);
393 metronome_set_gpio_output(STDBY_GPIO_PIN, 0);
394
395 metronome_init_gpio_pin(RST_GPIO_PIN, 0);
396 metronome_set_gpio_output(RST_GPIO_PIN, 0);
397
398 metronome_init_gpio_pin(RDY_GPIO_PIN, 1);
399
400 metronome_init_gpio_pin(ERR_GPIO_PIN, 1);
401
402 metronome_init_gpio_pin(PCBPWR_GPIO_PIN, 0);
403 metronome_set_gpio_output(PCBPWR_GPIO_PIN, 0);
404 }
405
406 static void metronome_disable_lcd_controller(struct metronomefb_par *par)
407 {
408 LCSR = 0xffffffff; /* Clear LCD Status Register */
409 LCCR0 |= LCCR0_DIS; /* Disable LCD Controller */
410
411 /* we reset and just wait for things to settle */
412 msleep(200);
413 }
414
415 static void metronome_enable_lcd_controller(struct metronomefb_par *par)
416 {
417 LCSR = 0xffffffff;
418 FDADR0 = par->metromem_desc_dma;
419 LCCR0 |= LCCR0_ENB;
420 }
421
422 static void __devinit metronome_init_lcdc_regs(struct metronomefb_par *par)
423 {
424 /* here we do:
425 - disable the lcd controller
426 - setup lcd control registers
427 - setup dma descriptor
428 - reenable lcd controller
429 */
430
431 /* disable the lcd controller */
432 metronome_disable_lcd_controller(par);
433
434 /* setup lcd control registers */
435 LCCR0 = LCCR0_LDM | LCCR0_SFM | LCCR0_IUM | LCCR0_EFM | LCCR0_PAS
436 | LCCR0_QDM | LCCR0_BM | LCCR0_OUM;
437
438 LCCR1 = (epd_frame_table[0].fw/2 - 1) /* pixels per line */
439 | (27 << 10) /* hsync pulse width - 1 */
440 | (33 << 16) /* eol pixel count */
441 | (33 << 24); /* bol pixel count */
442
443 LCCR2 = (epd_frame_table[0].fh - 1) /* lines per panel */
444 | (24 << 10) /* vsync pulse width - 1 */
445 | (2 << 16) /* eof pixel count */
446 | (0 << 24); /* bof pixel count */
447
448 LCCR3 = 2 /* pixel clock divisor */
449 | (24 << 8) /* AC Bias pin freq */
450 | LCCR3_16BPP /* BPP */
451 | LCCR3_PCP; /* PCP falling edge */
452
453 /* setup dma descriptor */
454 par->metromem_desc->mFDADR0 = par->metromem_desc_dma;
455 par->metromem_desc->mFSADR0 = par->metromem_dma;
456 par->metromem_desc->mFIDR0 = 0;
457 par->metromem_desc->mLDCMD0 = epd_frame_table[0].fw
458 * epd_frame_table[0].fh;
459 /* reenable lcd controller */
460 metronome_enable_lcd_controller(par);
461 }
462
463 static int metronome_display_cmd(struct metronomefb_par *par)
464 {
465 int i;
466 u16 cs;
467 u16 opcode;
468 static u8 borderval;
469 u8 *ptr;
470
471 /* setup display command
472 we can't immediately set the opcode since the controller
473 will try parse the command before we've set it all up
474 so we just set cs here and set the opcode at the end */
475
476 ptr = par->metromem;
477
478 if (par->metromem_cmd->opcode == 0xCC40)
479 opcode = cs = 0xCC41;
480 else
481 opcode = cs = 0xCC40;
482
483 /* set the args ( 2 bytes ) for display */
484 i = 0;
485 par->metromem_cmd->args[i] = 1 << 3 /* border update */
486 | ((borderval++ % 4) & 0x0F) << 4
487 | (par->frame_count - 1) << 8;
488 cs += par->metromem_cmd->args[i++];
489
490 /* the rest are 0 */
491 memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
492
493 par->metromem_cmd->csum = cs;
494 par->metromem_cmd->opcode = opcode; /* display cmd */
495
496 i = wait_event_interruptible_timeout(par->waitq, (GPLR1 & 0x01), HZ);
497 return i;
498 }
499
500 static int __devinit metronome_powerup_cmd(struct metronomefb_par *par)
501 {
502 int i;
503 u16 cs;
504
505 /* setup power up command */
506 par->metromem_cmd->opcode = 0x1234; /* pwr up pseudo cmd */
507 cs = par->metromem_cmd->opcode;
508
509 /* set pwr1,2,3 to 1024 */
510 for (i = 0; i < 3; i++) {
511 par->metromem_cmd->args[i] = 1024;
512 cs += par->metromem_cmd->args[i];
513 }
514
515 /* the rest are 0 */
516 memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
517
518 par->metromem_cmd->csum = cs;
519
520 msleep(1);
521 metronome_set_gpio_output(RST_GPIO_PIN, 1);
522
523 msleep(1);
524 metronome_set_gpio_output(STDBY_GPIO_PIN, 1);
525
526 i = wait_event_timeout(par->waitq, (GPLR1 & 0x01), HZ);
527 return i;
528 }
529
530 static int __devinit metronome_config_cmd(struct metronomefb_par *par)
531 {
532 int i;
533 u16 cs;
534
535 /* setup config command
536 we can't immediately set the opcode since the controller
537 will try parse the command before we've set it all up
538 so we just set cs here and set the opcode at the end */
539
540 cs = 0xCC10;
541
542 /* set the 12 args ( 8 bytes ) for config. see spec for meanings */
543 i = 0;
544 par->metromem_cmd->args[i] = 15 /* sdlew */
545 | 2 << 8 /* sdosz */
546 | 0 << 11 /* sdor */
547 | 0 << 12 /* sdces */
548 | 0 << 15; /* sdcer */
549 cs += par->metromem_cmd->args[i++];
550
551 par->metromem_cmd->args[i] = 42 /* gdspl */
552 | 1 << 8 /* gdr1 */
553 | 1 << 9 /* sdshr */
554 | 0 << 15; /* gdspp */
555 cs += par->metromem_cmd->args[i++];
556
557 par->metromem_cmd->args[i] = 18 /* gdspw */
558 | 0 << 15; /* dispc */
559 cs += par->metromem_cmd->args[i++];
560
561 par->metromem_cmd->args[i] = 599 /* vdlc */
562 | 0 << 11 /* dsi */
563 | 0 << 12; /* dsic */
564 cs += par->metromem_cmd->args[i++];
565
566 /* the rest are 0 */
567 memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
568
569 par->metromem_cmd->csum = cs;
570 par->metromem_cmd->opcode = 0xCC10; /* config cmd */
571
572 i = wait_event_timeout(par->waitq, (GPLR1 & 0x01), HZ);
573 return i;
574 }
575
576 static int __devinit metronome_init_cmd(struct metronomefb_par *par)
577 {
578 int i;
579 u16 cs;
580
581 /* setup init command
582 we can't immediately set the opcode since the controller
583 will try parse the command before we've set it all up
584 so we just set cs here and set the opcode at the end */
585
586 cs = 0xCC20;
587
588 /* set the args ( 2 bytes ) for init */
589 i = 0;
590 par->metromem_cmd->args[i] = 0;
591 cs += par->metromem_cmd->args[i++];
592
593 /* the rest are 0 */
594 memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
595
596 par->metromem_cmd->csum = cs;
597 par->metromem_cmd->opcode = 0xCC20; /* init cmd */
598
599 i = wait_event_timeout(par->waitq, (GPLR1 & 0x01), HZ);
600 return i;
601 }
602
603 static int __devinit metronome_init_regs(struct metronomefb_par *par)
604 {
605 int res;
606
607 metronome_init_gpio_regs();
608 metronome_init_lcdc_regs(par);
609
610 res = metronome_powerup_cmd(par);
611 if (res)
612 return res;
613
614 res = metronome_config_cmd(par);
615 if (res)
616 return res;
617
618 res = metronome_init_cmd(par);
619 if (res)
620 return res;
621
622 return res;
623 }
624
625 static void metronomefb_dpy_update(struct metronomefb_par *par)
626 {
627 u16 cksum;
628 unsigned char *buf = (unsigned char __force *)par->info->screen_base;
629
630 /* copy from vm to metromem */
631 memcpy(par->metromem_img, buf, DPY_W*DPY_H);
632
633 cksum = calc_img_cksum((u16 *) par->metromem_img,
634 (epd_frame_table[0].fw * DPY_H)/2);
635 *((u16 *) (par->metromem_img) +
636 (epd_frame_table[0].fw * DPY_H)/2) = cksum;
637 metronome_display_cmd(par);
638 }
639
640 static u16 metronomefb_dpy_update_page(struct metronomefb_par *par, int index)
641 {
642 int i;
643 u16 csum = 0;
644 u16 *buf = (u16 __force *) (par->info->screen_base + index);
645 u16 *img = (u16 *) (par->metromem_img + index);
646
647 /* swizzle from vm to metromem and recalc cksum at the same time*/
648 for (i = 0; i < PAGE_SIZE/2; i++) {
649 *(img + i) = (buf[i] << 5) & 0xE0E0;
650 csum += *(img + i);
651 }
652 return csum;
653 }
654
655 /* this is called back from the deferred io workqueue */
656 static void metronomefb_dpy_deferred_io(struct fb_info *info,
657 struct list_head *pagelist)
658 {
659 u16 cksum;
660 struct page *cur;
661 struct fb_deferred_io *fbdefio = info->fbdefio;
662 struct metronomefb_par *par = info->par;
663
664 /* walk the written page list and swizzle the data */
665 list_for_each_entry(cur, &fbdefio->pagelist, lru) {
666 cksum = metronomefb_dpy_update_page(par,
667 (cur->index << PAGE_SHIFT));
668 par->metromem_img_csum -= par->csum_table[cur->index];
669 par->csum_table[cur->index] = cksum;
670 par->metromem_img_csum += cksum;
671 }
672
673 metronome_display_cmd(par);
674 }
675
676 static void metronomefb_fillrect(struct fb_info *info,
677 const struct fb_fillrect *rect)
678 {
679 struct metronomefb_par *par = info->par;
680
681 sys_fillrect(info, rect);
682 metronomefb_dpy_update(par);
683 }
684
685 static void metronomefb_copyarea(struct fb_info *info,
686 const struct fb_copyarea *area)
687 {
688 struct metronomefb_par *par = info->par;
689
690 sys_copyarea(info, area);
691 metronomefb_dpy_update(par);
692 }
693
694 static void metronomefb_imageblit(struct fb_info *info,
695 const struct fb_image *image)
696 {
697 struct metronomefb_par *par = info->par;
698
699 sys_imageblit(info, image);
700 metronomefb_dpy_update(par);
701 }
702
703 /*
704 * this is the slow path from userspace. they can seek and write to
705 * the fb. it is based on fb_sys_write
706 */
707 static ssize_t metronomefb_write(struct fb_info *info, const char __user *buf,
708 size_t count, loff_t *ppos)
709 {
710 struct metronomefb_par *par = info->par;
711 unsigned long p = *ppos;
712 void *dst;
713 int err = 0;
714 unsigned long total_size;
715
716 if (info->state != FBINFO_STATE_RUNNING)
717 return -EPERM;
718
719 total_size = info->fix.smem_len;
720
721 if (p > total_size)
722 return -EFBIG;
723
724 if (count > total_size) {
725 err = -EFBIG;
726 count = total_size;
727 }
728
729 if (count + p > total_size) {
730 if (!err)
731 err = -ENOSPC;
732
733 count = total_size - p;
734 }
735
736 dst = (void __force *) (info->screen_base + p);
737
738 if (copy_from_user(dst, buf, count))
739 err = -EFAULT;
740
741 if (!err)
742 *ppos += count;
743
744 metronomefb_dpy_update(par);
745
746 return (err) ? err : count;
747 }
748
749 static struct fb_ops metronomefb_ops = {
750 .owner = THIS_MODULE,
751 .fb_write = metronomefb_write,
752 .fb_fillrect = metronomefb_fillrect,
753 .fb_copyarea = metronomefb_copyarea,
754 .fb_imageblit = metronomefb_imageblit,
755 };
756
757 static struct fb_deferred_io metronomefb_defio = {
758 .delay = HZ,
759 .deferred_io = metronomefb_dpy_deferred_io,
760 };
761
762 static irqreturn_t metronome_handle_irq(int irq, void *dev_id)
763 {
764 struct fb_info *info = dev_id;
765 struct metronomefb_par *par = info->par;
766
767 wake_up_interruptible(&par->waitq);
768 return IRQ_HANDLED;
769 }
770
771 static int __devinit metronomefb_probe(struct platform_device *dev)
772 {
773 struct fb_info *info;
774 int retval = -ENOMEM;
775 int videomemorysize;
776 unsigned char *videomemory;
777 struct metronomefb_par *par;
778 const struct firmware *fw_entry;
779 int cmd_size, wfm_size, img_size, padding_size, totalsize;
780 int i;
781
782 /* we have two blocks of memory.
783 info->screen_base which is vm, and is the fb used by apps.
784 par->metromem which is physically contiguous memory and
785 contains the display controller commands, waveform,
786 processed image data and padding. this is the data pulled
787 by the pxa255's LCD controller and pushed to Metronome */
788
789 videomemorysize = (DPY_W*DPY_H);
790 videomemory = vmalloc(videomemorysize);
791 if (!videomemory)
792 return retval;
793
794 memset(videomemory, 0, videomemorysize);
795
796 info = framebuffer_alloc(sizeof(struct metronomefb_par), &dev->dev);
797 if (!info)
798 goto err_vfree;
799
800 info->screen_base = (char __iomem *) videomemory;
801 info->fbops = &metronomefb_ops;
802
803 info->var = metronomefb_var;
804 info->fix = metronomefb_fix;
805 info->fix.smem_len = videomemorysize;
806 par = info->par;
807 par->info = info;
808 init_waitqueue_head(&par->waitq);
809
810 /* this table caches per page csum values. */
811 par->csum_table = vmalloc(videomemorysize/PAGE_SIZE);
812 if (!par->csum_table)
813 goto err_csum_table;
814
815 /* the metromem buffer is divided as follows:
816 command | CRC | padding
817 16kb waveform data | CRC | padding
818 image data | CRC
819 and an extra 256 bytes for dma descriptors
820 eg: IW=832 IH=622 WS=128
821 */
822
823 cmd_size = 1 * epd_frame_table[0].fw;
824 wfm_size = ((16*1024 + 2 + epd_frame_table[0].fw - 1)
825 / epd_frame_table[0].fw) * epd_frame_table[0].fw;
826 img_size = epd_frame_table[0].fh * epd_frame_table[0].fw;
827 padding_size = 4 * epd_frame_table[0].fw;
828 totalsize = cmd_size + wfm_size + img_size + padding_size;
829 par->metromemsize = PAGE_ALIGN(totalsize + 256);
830 DPRINTK("desired memory size = %d\n", par->metromemsize);
831 dev->dev.coherent_dma_mask = 0xffffffffull;
832 par->metromem = dma_alloc_writecombine(&dev->dev, par->metromemsize,
833 &par->metromem_dma, GFP_KERNEL);
834 if (!par->metromem) {
835 printk(KERN_ERR
836 "metronomefb: unable to allocate dma buffer\n");
837 goto err_vfree;
838 }
839
840 info->fix.smem_start = par->metromem_dma;
841 par->metromem_cmd = (struct metromem_cmd *) par->metromem;
842 par->metromem_wfm = par->metromem + cmd_size;
843 par->metromem_img = par->metromem + cmd_size + wfm_size;
844 par->metromem_img_csum = (u16 *) (par->metromem_img +
845 (epd_frame_table[0].fw * DPY_H));
846 DPRINTK("img offset=0x%x\n", cmd_size + wfm_size);
847 par->metromem_desc = (struct metromem_desc *) (par->metromem + cmd_size
848 + wfm_size + img_size + padding_size);
849 par->metromem_desc_dma = par->metromem_dma + cmd_size + wfm_size
850 + img_size + padding_size;
851
852 /* load the waveform in. assume mode 3, temp 31 for now */
853 /* a) request the waveform file from userspace
854 b) process waveform and decode into metromem */
855
856 retval = request_firmware(&fw_entry, "waveform.wbf", &dev->dev);
857 if (retval < 0) {
858 printk(KERN_ERR "metronomefb: couldn't get waveform\n");
859 goto err_dma_free;
860 }
861
862 retval = load_waveform((u8 *) fw_entry->data, fw_entry->size,
863 par->metromem_wfm, 3, 31, &par->frame_count);
864 if (retval < 0) {
865 printk(KERN_ERR "metronomefb: couldn't process waveform\n");
866 goto err_ld_wfm;
867 }
868 release_firmware(fw_entry);
869
870 retval = request_irq(IRQ_GPIO(RDY_GPIO_PIN), metronome_handle_irq,
871 IRQF_DISABLED, "Metronome", info);
872 if (retval) {
873 dev_err(&dev->dev, "request_irq failed: %d\n", retval);
874 goto err_ld_wfm;
875 }
876 set_irq_type(IRQ_GPIO(RDY_GPIO_PIN), IRQT_FALLING);
877
878 retval = metronome_init_regs(par);
879 if (retval < 0)
880 goto err_free_irq;
881
882 info->flags = FBINFO_FLAG_DEFAULT;
883
884 info->fbdefio = &metronomefb_defio;
885 fb_deferred_io_init(info);
886
887 retval = fb_alloc_cmap(&info->cmap, 8, 0);
888 if (retval < 0) {
889 printk(KERN_ERR "Failed to allocate colormap\n");
890 goto err_fb_rel;
891 }
892
893 /* set cmap */
894 for (i = 0; i < 8; i++)
895 info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/16;
896 memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*8);
897 memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*8);
898
899 retval = register_framebuffer(info);
900 if (retval < 0)
901 goto err_cmap;
902
903 platform_set_drvdata(dev, info);
904
905 printk(KERN_INFO
906 "fb%d: Metronome frame buffer device, using %dK of video"
907 " memory\n", info->node, videomemorysize >> 10);
908
909 return 0;
910
911 err_cmap:
912 fb_dealloc_cmap(&info->cmap);
913 err_fb_rel:
914 framebuffer_release(info);
915 err_free_irq:
916 free_irq(IRQ_GPIO(RDY_GPIO_PIN), info);
917 err_ld_wfm:
918 release_firmware(fw_entry);
919 err_dma_free:
920 dma_free_writecombine(&dev->dev, par->metromemsize, par->metromem,
921 par->metromem_dma);
922 err_csum_table:
923 vfree(par->csum_table);
924 err_vfree:
925 vfree(videomemory);
926 return retval;
927 }
928
929 static int __devexit metronomefb_remove(struct platform_device *dev)
930 {
931 struct fb_info *info = platform_get_drvdata(dev);
932
933 if (info) {
934 struct metronomefb_par *par = info->par;
935 fb_deferred_io_cleanup(info);
936 dma_free_writecombine(&dev->dev, par->metromemsize,
937 par->metromem, par->metromem_dma);
938 fb_dealloc_cmap(&info->cmap);
939 vfree(par->csum_table);
940 unregister_framebuffer(info);
941 vfree((void __force *)info->screen_base);
942 free_irq(IRQ_GPIO(RDY_GPIO_PIN), info);
943 framebuffer_release(info);
944 }
945 return 0;
946 }
947
948 static struct platform_driver metronomefb_driver = {
949 .probe = metronomefb_probe,
950 .remove = metronomefb_remove,
951 .driver = {
952 .name = "metronomefb",
953 },
954 };
955
956 static struct platform_device *metronomefb_device;
957
958 static int __init metronomefb_init(void)
959 {
960 int ret;
961
962 if (!metronomefb_enable) {
963 printk(KERN_ERR
964 "Use metronomefb_enable to enable the device\n");
965 return -ENXIO;
966 }
967
968 ret = platform_driver_register(&metronomefb_driver);
969 if (!ret) {
970 metronomefb_device = platform_device_alloc("metronomefb", 0);
971 if (metronomefb_device)
972 ret = platform_device_add(metronomefb_device);
973 else
974 ret = -ENOMEM;
975
976 if (ret) {
977 platform_device_put(metronomefb_device);
978 platform_driver_unregister(&metronomefb_driver);
979 }
980 }
981 return ret;
982
983 }
984
985 static void __exit metronomefb_exit(void)
986 {
987 platform_device_unregister(metronomefb_device);
988 platform_driver_unregister(&metronomefb_driver);
989 }
990
991 module_param(metronomefb_enable, uint, 0);
992 MODULE_PARM_DESC(metronomefb_enable, "Enable communication with Metronome");
993
994 module_init(metronomefb_init);
995 module_exit(metronomefb_exit);
996
997 MODULE_DESCRIPTION("fbdev driver for Metronome controller");
998 MODULE_AUTHOR("Jaya Kumar");
999 MODULE_LICENSE("GPL");
Verdex Pro support