blob: 195cc2db4c2c0ecc4c4755a793118f87fce8e96f [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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800102static struct fb_fix_screeninfo metronomefb_fix = {
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700103 .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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800113static struct fb_var_screeninfo metronomefb_var = {
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700114 .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 */
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800170static int 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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800341static int metronome_powerup_cmd(struct metronomefb_par *par)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700342{
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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800370static int metronome_config_cmd(struct metronomefb_par *par)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700371{
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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800388static int metronome_init_cmd(struct metronomefb_par *par)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700389{
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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800414static int metronome_init_regs(struct metronomefb_par *par)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700415{
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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800572static int metronomefb_probe(struct platform_device *dev)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700573{
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);
Joe Perches1b86d772011-05-28 11:13:33 -0700631 videomemory = vzalloc(videomemorysize);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700632 if (!videomemory)
Jaya Kumare9355082008-08-19 11:17:55 +0100633 goto err_fb_rel;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700634
Jaya Kumar03c33a42008-04-28 02:15:38 -0700635 info->screen_base = (char __force __iomem *)videomemory;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700636 info->fbops = &metronomefb_ops;
637
Jaya Kumare9355082008-08-19 11:17:55 +0100638 metronomefb_fix.line_length = fw;
639 metronomefb_var.xres = fw;
640 metronomefb_var.yres = fh;
641 metronomefb_var.xres_virtual = fw;
642 metronomefb_var.yres_virtual = fh;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700643 info->var = metronomefb_var;
644 info->fix = metronomefb_fix;
645 info->fix.smem_len = videomemorysize;
646 par = info->par;
647 par->info = info;
Jaya Kumar03c33a42008-04-28 02:15:38 -0700648 par->board = board;
Jaya Kumare9355082008-08-19 11:17:55 +0100649 par->dt = epd_dt_index;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700650 init_waitqueue_head(&par->waitq);
651
652 /* this table caches per page csum values. */
653 par->csum_table = vmalloc(videomemorysize/PAGE_SIZE);
654 if (!par->csum_table)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700655 goto err_vfree;
Jaya Kumare9355082008-08-19 11:17:55 +0100656
657 /* the physical framebuffer that we use is setup by
658 * the platform device driver. It will provide us
659 * with cmd, wfm and image memory in a contiguous area. */
660 retval = board->setup_fb(par);
661 if (retval) {
662 dev_err(&dev->dev, "Failed to setup fb\n");
663 goto err_csum_table;
664 }
665
666 /* after this point we should have a framebuffer */
667 if ((!par->metromem_wfm) || (!par->metromem_img) ||
668 (!par->metromem_dma)) {
669 dev_err(&dev->dev, "fb access failure\n");
670 retval = -EINVAL;
671 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700672 }
673
674 info->fix.smem_start = par->metromem_dma;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700675
Jaya Kumar03c33a42008-04-28 02:15:38 -0700676 /* load the waveform in. assume mode 3, temp 31 for now
677 a) request the waveform file from userspace
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700678 b) process waveform and decode into metromem */
Jaya Kumar03c33a42008-04-28 02:15:38 -0700679 retval = request_firmware(&fw_entry, "metronome.wbf", &dev->dev);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700680 if (retval < 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100681 dev_err(&dev->dev, "Failed to get waveform\n");
Jaya Kumare9355082008-08-19 11:17:55 +0100682 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700683 }
684
Jaya Kumar28501332008-08-05 13:52:14 +0100685 retval = load_waveform((u8 *) fw_entry->data, fw_entry->size, 3, 31,
686 par);
Sebastian Siewior2422fbb2008-04-28 02:15:39 -0700687 release_firmware(fw_entry);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700688 if (retval < 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100689 dev_err(&dev->dev, "Failed processing waveform\n");
Jaya Kumare9355082008-08-19 11:17:55 +0100690 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700691 }
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700692
Wei Yongjune8ddb0c2013-10-12 14:25:23 +0800693 retval = board->setup_irq(info);
694 if (retval)
Jaya Kumare9355082008-08-19 11:17:55 +0100695 goto err_csum_table;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700696
697 retval = metronome_init_regs(par);
698 if (retval < 0)
699 goto err_free_irq;
700
Konrad Rzeszutek Wilka9b5ff92009-12-03 10:31:58 -0500701 info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700702
703 info->fbdefio = &metronomefb_defio;
704 fb_deferred_io_init(info);
705
706 retval = fb_alloc_cmap(&info->cmap, 8, 0);
707 if (retval < 0) {
Jaya Kumar28501332008-08-05 13:52:14 +0100708 dev_err(&dev->dev, "Failed to allocate colormap\n");
Jaya Kumare9355082008-08-19 11:17:55 +0100709 goto err_free_irq;
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700710 }
711
712 /* set cmap */
713 for (i = 0; i < 8; i++)
714 info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/16;
715 memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*8);
716 memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*8);
717
718 retval = register_framebuffer(info);
719 if (retval < 0)
720 goto err_cmap;
721
722 platform_set_drvdata(dev, info);
723
Jaya Kumar28501332008-08-05 13:52:14 +0100724 dev_dbg(&dev->dev,
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700725 "fb%d: Metronome frame buffer device, using %dK of video"
726 " memory\n", info->node, videomemorysize >> 10);
727
728 return 0;
729
730err_cmap:
731 fb_dealloc_cmap(&info->cmap);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700732err_free_irq:
Jaya Kumare9355082008-08-19 11:17:55 +0100733 board->cleanup(par);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700734err_csum_table:
735 vfree(par->csum_table);
736err_vfree:
737 vfree(videomemory);
Jaya Kumare9355082008-08-19 11:17:55 +0100738err_fb_rel:
739 framebuffer_release(info);
740err:
Jaya Kumar03c33a42008-04-28 02:15:38 -0700741 module_put(board->owner);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700742 return retval;
743}
744
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800745static int metronomefb_remove(struct platform_device *dev)
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700746{
747 struct fb_info *info = platform_get_drvdata(dev);
748
749 if (info) {
750 struct metronomefb_par *par = info->par;
Jaya Kumare9355082008-08-19 11:17:55 +0100751
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700752 unregister_framebuffer(info);
Jaya Kumare9355082008-08-19 11:17:55 +0100753 fb_deferred_io_cleanup(info);
754 fb_dealloc_cmap(&info->cmap);
755 par->board->cleanup(par);
756 vfree(par->csum_table);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700757 vfree((void __force *)info->screen_base);
Jaya Kumar03c33a42008-04-28 02:15:38 -0700758 module_put(par->board->owner);
Jaya Kumare9355082008-08-19 11:17:55 +0100759 dev_dbg(&dev->dev, "calling release\n");
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700760 framebuffer_release(info);
761 }
762 return 0;
763}
764
765static struct platform_driver metronomefb_driver = {
766 .probe = metronomefb_probe,
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800767 .remove = metronomefb_remove,
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700768 .driver = {
Jaya Kumar03c33a42008-04-28 02:15:38 -0700769 .owner = THIS_MODULE,
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700770 .name = "metronomefb",
771 },
772};
Hanjun Guoae6b6392013-09-29 13:32:03 +0800773module_platform_driver(metronomefb_driver);
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700774
Jaya Kumare9355082008-08-19 11:17:55 +0100775module_param(user_wfm_size, uint, 0);
776MODULE_PARM_DESC(user_wfm_size, "Set custom waveform size");
777
Jaya Kumarde7c6d12008-03-19 17:01:10 -0700778MODULE_DESCRIPTION("fbdev driver for Metronome controller");
779MODULE_AUTHOR("Jaya Kumar");
780MODULE_LICENSE("GPL");