blob: ed64edfd2c43b7a97e693ff30b6e26972caaf7f7 [file] [log] [blame]
Jaya Kumarde7c6d12008-03-19 17:01:10 -07001/*
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
Justin P. Mattock631dd1a2010-10-18 11:03:14 +020013 * Corporation. http://www.eink.com/
Jaya Kumarde7c6d12008-03-19 17:01:10 -070014 *
15 * This driver is written to be used with the Metronome display controller.
Jaya Kumar03c33a42008-04-28 02:15:38 -070016 * 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
Jaya Kumarde7c6d12008-03-19 17:01:10 -070019 *
Jaya Kumarde7c6d12008-03-19 17:01:10 -070020 */
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>
Jaya Kumarde7c6d12008-03-19 17:01:10 -070026#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
Jaya Kumar03c33a42008-04-28 02:15:38 -070038#include <video/metronomefb.h>
39
Jaya Kumarde7c6d12008-03-19 17:01:10 -070040#include <asm/unaligned.h>
41
Jaya Kumarde7c6d12008-03-19 17:01:10 -070042/* Display specific information */
43#define DPY_W 832
44#define DPY_H 622
45
Jaya Kumare9355082008-08-19 11:17:55 +010046static int user_wfm_size;
47
Jaya Kumarde7c6d12008-03-19 17:01:10 -070048/* frame differs from image. frame includes non-visible pixels */
49struct epd_frame {
50 int fw; /* frame width */
51 int fh; /* frame height */
Jaya Kumare9355082008-08-19 11:17:55 +010052 u16 config[4];
53 int wfm_size;
Jaya Kumarde7c6d12008-03-19 17:01:10 -070054};
55
56static struct epd_frame epd_frame_table[] = {
57 {
Jaya Kumare9355082008-08-19 11:17:55 +010058 .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,
Jaya Kumarde7c6d12008-03-19 17:01:10 -070099 },
100};
101
102static struct fb_fix_screeninfo metronomefb_fix __devinitdata = {
103 .id = "metronomefb",
104 .type = FB_TYPE_PACKED_PIXELS,
105 .visual = FB_VISUAL_STATIC_PSEUDOCOLOR,
106 .xpanstep = 0,
107 .ypanstep = 0,
108 .ywrapstep = 0,
109 .line_length = DPY_W,
110 .accel = FB_ACCEL_NONE,
111};
112
113static struct fb_var_screeninfo metronomefb_var __devinitdata = {
114 .xres = DPY_W,
115 .yres = DPY_H,
116 .xres_virtual = DPY_W,
117 .yres_virtual = DPY_H,
118 .bits_per_pixel = 8,
119 .grayscale = 1,
120 .nonstd = 1,
121 .red = { 4, 3, 0 },
122 .green = { 0, 0, 0 },
123 .blue = { 0, 0, 0 },
124 .transp = { 0, 0, 0 },
125};
126
Jaya Kumar03c33a42008-04-28 02:15:38 -0700127/* the waveform structure that is coming from userspace firmware */
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700128struct 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 */
148static 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
159static 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 */
Jaya Kumar28501332008-08-05 13:52:14 +0100170static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
171 struct metronomefb_par *par)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700172{
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;
Jaya Kumar28501332008-08-05 13:52:14 +0100183 u8 *metromem = par->metromem_wfm;
184 struct device *dev = par->info->dev;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700185
Jaya Kumare9355082008-08-19 11:17:55 +0100186 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) {
Alan Cox6d54aaf2008-10-15 10:50:32 +0100190 dev_err(dev, "Error: unexpected size %Zd != %d\n", size,
Jaya Kumare9355082008-08-19 11:17:55 +0100191 epd_frame_table[par->dt].wfm_size);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700192 return -EINVAL;
193 }
194
195 wfm_hdr = (struct waveform_hdr *) mem;
196
197 if (wfm_hdr->fvsn != 1) {
Jaya Kumar28501332008-08-05 13:52:14 +0100198 dev_err(dev, "Error: bad fvsn %x\n", wfm_hdr->fvsn);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700199 return -EINVAL;
200 }
201 if (wfm_hdr->luts != 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100202 dev_err(dev, "Error: bad luts %x\n", wfm_hdr->luts);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700203 return -EINVAL;
204 }
205 cksum = calc_cksum(32, 47, mem);
206 if (cksum != wfm_hdr->wfm_cs) {
Jaya Kumar28501332008-08-05 13:52:14 +0100207 dev_err(dev, "Error: bad cksum %x != %x\n", cksum,
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700208 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) {
Jaya Kumar28501332008-08-05 13:52:14 +0100215 dev_err(dev, "Error: unexpected value in padding\n");
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700216 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]) {
Jaya Kumar28501332008-08-05 13:52:14 +0100240 dev_err(dev, "Error: bad temperature range table cksum"
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700241 " %x != %x\n", cksum, mem[cksum_idx]);
242 return -EINVAL;
243 }
244
245 /* check waveform mode table address checksum */
Harvey Harrisond15c0a42008-04-29 01:03:41 -0700246 wmta = get_unaligned_le32(wfm_hdr->wmta) & 0x00FFFFFF;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700247 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]) {
Jaya Kumar28501332008-08-05 13:52:14 +0100252 dev_err(dev, "Error: bad mode table address cksum"
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700253 " %x != %x\n", cksum, mem[cksum_idx]);
254 return -EINVAL;
255 }
256
257 /* check waveform temperature table address checksum */
Harvey Harrisond15c0a42008-04-29 01:03:41 -0700258 tta = get_unaligned_le32(mem + wmta + m * 4) & 0x00FFFFFF;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700259 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]) {
Jaya Kumar28501332008-08-05 13:52:14 +0100264 dev_err(dev, "Error: bad temperature table address cksum"
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700265 " %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 */
Harvey Harrisond15c0a42008-04-29 01:03:41 -0700271 wfm_idx = get_unaligned_le32(mem + tta + trn * 4) & 0x00FFFFFF;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700272 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]) {
Jaya Kumar28501332008-08-05 13:52:14 +0100299 dev_err(dev, "Error: bad waveform data cksum"
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700300 " %x != %x\n", cksum, mem[cksum_idx]);
301 return -EINVAL;
302 }
Jaya Kumar28501332008-08-05 13:52:14 +0100303 par->frame_count = (mem_idx/64);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700304
305 return 0;
306}
307
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700308static int metronome_display_cmd(struct metronomefb_par *par)
309{
310 int i;
311 u16 cs;
312 u16 opcode;
313 static u8 borderval;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700314
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
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700320 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
Jaya Kumar03c33a42008-04-28 02:15:38 -0700338 return par->board->met_wait_event_intr(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700339}
340
341static int __devinit metronome_powerup_cmd(struct metronomefb_par *par)
342{
343 int i;
344 u16 cs;
345
346 /* setup power up command */
347 par->metromem_cmd->opcode = 0x1234; /* pwr up pseudo cmd */
348 cs = par->metromem_cmd->opcode;
349
350 /* set pwr1,2,3 to 1024 */
351 for (i = 0; i < 3; i++) {
352 par->metromem_cmd->args[i] = 1024;
353 cs += par->metromem_cmd->args[i];
354 }
355
356 /* the rest are 0 */
357 memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
358
359 par->metromem_cmd->csum = cs;
360
361 msleep(1);
Jaya Kumar03c33a42008-04-28 02:15:38 -0700362 par->board->set_rst(par, 1);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700363
364 msleep(1);
Jaya Kumar03c33a42008-04-28 02:15:38 -0700365 par->board->set_stdby(par, 1);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700366
Jaya Kumar03c33a42008-04-28 02:15:38 -0700367 return par->board->met_wait_event(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700368}
369
370static int __devinit metronome_config_cmd(struct metronomefb_par *par)
371{
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700372 /* setup config command
373 we can't immediately set the opcode since the controller
Jaya Kumare9355082008-08-19 11:17:55 +0100374 will try parse the command before we've set it all up */
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700375
Jaya Kumare9355082008-08-19 11:17:55 +0100376 memcpy(par->metromem_cmd->args, epd_frame_table[par->dt].config,
377 sizeof(epd_frame_table[par->dt].config));
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700378 /* the rest are 0 */
Jaya Kumare9355082008-08-19 11:17:55 +0100379 memset((u8 *) (par->metromem_cmd->args + 4), 0, (32-4)*2);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700380
Jaya Kumare9355082008-08-19 11:17:55 +0100381 par->metromem_cmd->csum = 0xCC10;
382 par->metromem_cmd->csum += calc_img_cksum(par->metromem_cmd->args, 4);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700383 par->metromem_cmd->opcode = 0xCC10; /* config cmd */
384
Jaya Kumar03c33a42008-04-28 02:15:38 -0700385 return par->board->met_wait_event(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700386}
387
388static int __devinit metronome_init_cmd(struct metronomefb_par *par)
389{
390 int i;
391 u16 cs;
392
393 /* setup init command
394 we can't immediately set the opcode since the controller
395 will try parse the command before we've set it all up
396 so we just set cs here and set the opcode at the end */
397
398 cs = 0xCC20;
399
400 /* set the args ( 2 bytes ) for init */
401 i = 0;
402 par->metromem_cmd->args[i] = 0;
403 cs += par->metromem_cmd->args[i++];
404
405 /* the rest are 0 */
406 memset((u8 *) (par->metromem_cmd->args + i), 0, (32-i)*2);
407
408 par->metromem_cmd->csum = cs;
409 par->metromem_cmd->opcode = 0xCC20; /* init cmd */
410
Jaya Kumar03c33a42008-04-28 02:15:38 -0700411 return par->board->met_wait_event(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700412}
413
414static int __devinit metronome_init_regs(struct metronomefb_par *par)
415{
416 int res;
417
Jaya Kumare9355082008-08-19 11:17:55 +0100418 res = par->board->setup_io(par);
419 if (res)
420 return res;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700421
422 res = metronome_powerup_cmd(par);
423 if (res)
424 return res;
425
426 res = metronome_config_cmd(par);
427 if (res)
428 return res;
429
430 res = metronome_init_cmd(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700431
432 return res;
433}
434
435static void metronomefb_dpy_update(struct metronomefb_par *par)
436{
Jaya Kumare9355082008-08-19 11:17:55 +0100437 int fbsize;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700438 u16 cksum;
439 unsigned char *buf = (unsigned char __force *)par->info->screen_base;
440
Jaya Kumare9355082008-08-19 11:17:55 +0100441 fbsize = par->info->fix.smem_len;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700442 /* copy from vm to metromem */
Jaya Kumare9355082008-08-19 11:17:55 +0100443 memcpy(par->metromem_img, buf, fbsize);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700444
Jaya Kumare9355082008-08-19 11:17:55 +0100445 cksum = calc_img_cksum((u16 *) par->metromem_img, fbsize/2);
446 *((u16 *)(par->metromem_img) + fbsize/2) = cksum;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700447 metronome_display_cmd(par);
448}
449
450static u16 metronomefb_dpy_update_page(struct metronomefb_par *par, int index)
451{
452 int i;
453 u16 csum = 0;
Jaya Kumar03c33a42008-04-28 02:15:38 -0700454 u16 *buf = (u16 __force *)(par->info->screen_base + index);
455 u16 *img = (u16 *)(par->metromem_img + index);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700456
457 /* swizzle from vm to metromem and recalc cksum at the same time*/
458 for (i = 0; i < PAGE_SIZE/2; i++) {
459 *(img + i) = (buf[i] << 5) & 0xE0E0;
460 csum += *(img + i);
461 }
462 return csum;
463}
464
465/* this is called back from the deferred io workqueue */
466static void metronomefb_dpy_deferred_io(struct fb_info *info,
467 struct list_head *pagelist)
468{
469 u16 cksum;
470 struct page *cur;
471 struct fb_deferred_io *fbdefio = info->fbdefio;
472 struct metronomefb_par *par = info->par;
473
474 /* walk the written page list and swizzle the data */
475 list_for_each_entry(cur, &fbdefio->pagelist, lru) {
476 cksum = metronomefb_dpy_update_page(par,
477 (cur->index << PAGE_SHIFT));
478 par->metromem_img_csum -= par->csum_table[cur->index];
479 par->csum_table[cur->index] = cksum;
480 par->metromem_img_csum += cksum;
481 }
482
483 metronome_display_cmd(par);
484}
485
486static void metronomefb_fillrect(struct fb_info *info,
487 const struct fb_fillrect *rect)
488{
489 struct metronomefb_par *par = info->par;
490
Jaya Kumar555514f2008-04-28 02:15:36 -0700491 sys_fillrect(info, rect);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700492 metronomefb_dpy_update(par);
493}
494
495static void metronomefb_copyarea(struct fb_info *info,
496 const struct fb_copyarea *area)
497{
498 struct metronomefb_par *par = info->par;
499
Jaya Kumar555514f2008-04-28 02:15:36 -0700500 sys_copyarea(info, area);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700501 metronomefb_dpy_update(par);
502}
503
504static void metronomefb_imageblit(struct fb_info *info,
505 const struct fb_image *image)
506{
507 struct metronomefb_par *par = info->par;
508
Jaya Kumar555514f2008-04-28 02:15:36 -0700509 sys_imageblit(info, image);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700510 metronomefb_dpy_update(par);
511}
512
513/*
514 * this is the slow path from userspace. they can seek and write to
515 * the fb. it is based on fb_sys_write
516 */
517static ssize_t metronomefb_write(struct fb_info *info, const char __user *buf,
518 size_t count, loff_t *ppos)
519{
520 struct metronomefb_par *par = info->par;
521 unsigned long p = *ppos;
522 void *dst;
523 int err = 0;
524 unsigned long total_size;
525
526 if (info->state != FBINFO_STATE_RUNNING)
527 return -EPERM;
528
529 total_size = info->fix.smem_len;
530
531 if (p > total_size)
532 return -EFBIG;
533
534 if (count > total_size) {
535 err = -EFBIG;
536 count = total_size;
537 }
538
539 if (count + p > total_size) {
540 if (!err)
541 err = -ENOSPC;
542
543 count = total_size - p;
544 }
545
Jaya Kumar03c33a42008-04-28 02:15:38 -0700546 dst = (void __force *)(info->screen_base + p);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700547
548 if (copy_from_user(dst, buf, count))
549 err = -EFAULT;
550
551 if (!err)
552 *ppos += count;
553
554 metronomefb_dpy_update(par);
555
556 return (err) ? err : count;
557}
558
559static struct fb_ops metronomefb_ops = {
560 .owner = THIS_MODULE,
561 .fb_write = metronomefb_write,
562 .fb_fillrect = metronomefb_fillrect,
563 .fb_copyarea = metronomefb_copyarea,
564 .fb_imageblit = metronomefb_imageblit,
565};
566
567static struct fb_deferred_io metronomefb_defio = {
568 .delay = HZ,
569 .deferred_io = metronomefb_dpy_deferred_io,
570};
571
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700572static int __devinit metronomefb_probe(struct platform_device *dev)
573{
574 struct fb_info *info;
Jaya Kumar03c33a42008-04-28 02:15:38 -0700575 struct metronome_board *board;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700576 int retval = -ENOMEM;
577 int videomemorysize;
578 unsigned char *videomemory;
579 struct metronomefb_par *par;
580 const struct firmware *fw_entry;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700581 int i;
Jaya Kumare9355082008-08-19 11:17:55 +0100582 int panel_type;
583 int fw, fh;
584 int epd_dt_index;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700585
Jaya Kumar03c33a42008-04-28 02:15:38 -0700586 /* pick up board specific routines */
587 board = dev->dev.platform_data;
588 if (!board)
589 return -EINVAL;
590
591 /* try to count device specific driver, if can't, platform recalls */
592 if (!try_module_get(board->owner))
593 return -ENODEV;
594
Jaya Kumare9355082008-08-19 11:17:55 +0100595 info = framebuffer_alloc(sizeof(struct metronomefb_par), &dev->dev);
596 if (!info)
597 goto err;
598
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700599 /* we have two blocks of memory.
600 info->screen_base which is vm, and is the fb used by apps.
601 par->metromem which is physically contiguous memory and
602 contains the display controller commands, waveform,
603 processed image data and padding. this is the data pulled
Jaya Kumare9355082008-08-19 11:17:55 +0100604 by the device's LCD controller and pushed to Metronome.
605 the metromem memory is allocated by the board driver and
606 is provided to us */
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700607
Jaya Kumare9355082008-08-19 11:17:55 +0100608 panel_type = board->get_panel_type();
609 switch (panel_type) {
610 case 6:
611 epd_dt_index = 0;
612 break;
613 case 8:
614 epd_dt_index = 1;
615 break;
616 case 97:
617 epd_dt_index = 2;
618 break;
619 default:
620 dev_err(&dev->dev, "Unexpected panel type. Defaulting to 6\n");
621 epd_dt_index = 0;
622 break;
623 }
624
625 fw = epd_frame_table[epd_dt_index].fw;
626 fh = epd_frame_table[epd_dt_index].fh;
627
628 /* we need to add a spare page because our csum caching scheme walks
629 * to the end of the page */
630 videomemorysize = PAGE_SIZE + (fw * fh);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700631 videomemory = vmalloc(videomemorysize);
632 if (!videomemory)
Jaya Kumare9355082008-08-19 11:17:55 +0100633 goto err_fb_rel;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700634
635 memset(videomemory, 0, videomemorysize);
636
Jaya Kumar03c33a42008-04-28 02:15:38 -0700637 info->screen_base = (char __force __iomem *)videomemory;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700638 info->fbops = &metronomefb_ops;
639
Jaya Kumare9355082008-08-19 11:17:55 +0100640 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;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700645 info->var = metronomefb_var;
646 info->fix = metronomefb_fix;
647 info->fix.smem_len = videomemorysize;
648 par = info->par;
649 par->info = info;
Jaya Kumar03c33a42008-04-28 02:15:38 -0700650 par->board = board;
Jaya Kumare9355082008-08-19 11:17:55 +0100651 par->dt = epd_dt_index;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700652 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)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700657 goto err_vfree;
Jaya Kumare9355082008-08-19 11:17:55 +0100658
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;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700674 }
675
676 info->fix.smem_start = par->metromem_dma;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700677
Jaya Kumar03c33a42008-04-28 02:15:38 -0700678 /* load the waveform in. assume mode 3, temp 31 for now
679 a) request the waveform file from userspace
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700680 b) process waveform and decode into metromem */
Jaya Kumar03c33a42008-04-28 02:15:38 -0700681 retval = request_firmware(&fw_entry, "metronome.wbf", &dev->dev);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700682 if (retval < 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100683 dev_err(&dev->dev, "Failed to get waveform\n");
Jaya Kumare9355082008-08-19 11:17:55 +0100684 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700685 }
686
Jaya Kumar28501332008-08-05 13:52:14 +0100687 retval = load_waveform((u8 *) fw_entry->data, fw_entry->size, 3, 31,
688 par);
Sebastian Siewior2422fbb2008-04-28 02:15:39 -0700689 release_firmware(fw_entry);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700690 if (retval < 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100691 dev_err(&dev->dev, "Failed processing waveform\n");
Jaya Kumare9355082008-08-19 11:17:55 +0100692 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700693 }
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700694
Jaya Kumar03c33a42008-04-28 02:15:38 -0700695 if (board->setup_irq(info))
Jaya Kumare9355082008-08-19 11:17:55 +0100696 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700697
698 retval = metronome_init_regs(par);
699 if (retval < 0)
700 goto err_free_irq;
701
Konrad Rzeszutek Wilka9b5ff92009-12-03 10:31:58 -0500702 info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700703
704 info->fbdefio = &metronomefb_defio;
705 fb_deferred_io_init(info);
706
707 retval = fb_alloc_cmap(&info->cmap, 8, 0);
708 if (retval < 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100709 dev_err(&dev->dev, "Failed to allocate colormap\n");
Jaya Kumare9355082008-08-19 11:17:55 +0100710 goto err_free_irq;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700711 }
712
713 /* set cmap */
714 for (i = 0; i < 8; i++)
715 info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/16;
716 memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*8);
717 memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*8);
718
719 retval = register_framebuffer(info);
720 if (retval < 0)
721 goto err_cmap;
722
723 platform_set_drvdata(dev, info);
724
Jaya Kumar28501332008-08-05 13:52:14 +0100725 dev_dbg(&dev->dev,
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700726 "fb%d: Metronome frame buffer device, using %dK of video"
727 " memory\n", info->node, videomemorysize >> 10);
728
729 return 0;
730
731err_cmap:
732 fb_dealloc_cmap(&info->cmap);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700733err_free_irq:
Jaya Kumare9355082008-08-19 11:17:55 +0100734 board->cleanup(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700735err_csum_table:
736 vfree(par->csum_table);
737err_vfree:
738 vfree(videomemory);
Jaya Kumare9355082008-08-19 11:17:55 +0100739err_fb_rel:
740 framebuffer_release(info);
741err:
Jaya Kumar03c33a42008-04-28 02:15:38 -0700742 module_put(board->owner);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700743 return retval;
744}
745
746static int __devexit metronomefb_remove(struct platform_device *dev)
747{
748 struct fb_info *info = platform_get_drvdata(dev);
749
750 if (info) {
751 struct metronomefb_par *par = info->par;
Jaya Kumare9355082008-08-19 11:17:55 +0100752
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700753 unregister_framebuffer(info);
Jaya Kumare9355082008-08-19 11:17:55 +0100754 fb_deferred_io_cleanup(info);
755 fb_dealloc_cmap(&info->cmap);
756 par->board->cleanup(par);
757 vfree(par->csum_table);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700758 vfree((void __force *)info->screen_base);
Jaya Kumar03c33a42008-04-28 02:15:38 -0700759 module_put(par->board->owner);
Jaya Kumare9355082008-08-19 11:17:55 +0100760 dev_dbg(&dev->dev, "calling release\n");
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700761 framebuffer_release(info);
762 }
763 return 0;
764}
765
766static struct platform_driver metronomefb_driver = {
767 .probe = metronomefb_probe,
axel lin1e93f392011-02-13 04:02:10 +0000768 .remove = __devexit_p(metronomefb_remove),
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700769 .driver = {
Jaya Kumar03c33a42008-04-28 02:15:38 -0700770 .owner = THIS_MODULE,
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700771 .name = "metronomefb",
772 },
773};
774
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700775static int __init metronomefb_init(void)
776{
Jaya Kumar03c33a42008-04-28 02:15:38 -0700777 return platform_driver_register(&metronomefb_driver);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700778}
779
780static void __exit metronomefb_exit(void)
781{
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700782 platform_driver_unregister(&metronomefb_driver);
783}
784
Jaya Kumare9355082008-08-19 11:17:55 +0100785module_param(user_wfm_size, uint, 0);
786MODULE_PARM_DESC(user_wfm_size, "Set custom waveform size");
787
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700788module_init(metronomefb_init);
789module_exit(metronomefb_exit);
790
791MODULE_DESCRIPTION("fbdev driver for Metronome controller");
792MODULE_AUTHOR("Jaya Kumar");
793MODULE_LICENSE("GPL");