1 /*
2  * broadsheetfb.c -- FB driver for E-Ink Broadsheet controller
3  *
4  * Copyright (C) 2008, Jaya Kumar
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License. See the file COPYING in the main directory of this archive for
8  * more details.
9  *
10  * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
11  *
12  * This driver is written to be used with the Broadsheet display controller.
13  *
14  * It is intended to be architecture independent. A board specific driver
15  * must be used to perform all the physical IO interactions.
16  *
17  */
18 
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/string.h>
23 #include <linux/mm.h>
24 #include <linux/slab.h>
25 #include <linux/vmalloc.h>
26 #include <linux/delay.h>
27 #include <linux/interrupt.h>
28 #include <linux/fb.h>
29 #include <linux/init.h>
30 #include <linux/platform_device.h>
31 #include <linux/list.h>
32 #include <linux/firmware.h>
33 #include <linux/uaccess.h>
34 
35 #include <video/broadsheetfb.h>
36 
37 /* track panel specific parameters */
38 struct panel_info {
39 	int w;
40 	int h;
41 	u16 sdcfg;
42 	u16 gdcfg;
43 	u16 lutfmt;
44 	u16 fsynclen;
45 	u16 fendfbegin;
46 	u16 lsynclen;
47 	u16 lendlbegin;
48 	u16 pixclk;
49 };
50 
51 /* table of panel specific parameters to be indexed into by the board drivers */
52 static struct panel_info panel_table[] = {
53 	{	/* standard 6" on TFT backplane */
54 		.w = 800,
55 		.h = 600,
56 		.sdcfg = (100 | (1 << 8) | (1 << 9)),
57 		.gdcfg = 2,
58 		.lutfmt = (4 | (1 << 7)),
59 		.fsynclen = 4,
60 		.fendfbegin = (10 << 8) | 4,
61 		.lsynclen = 10,
62 		.lendlbegin = (100 << 8) | 4,
63 		.pixclk = 6,
64 	},
65 	{	/* custom 3.7" flexible on PET or steel */
66 		.w = 320,
67 		.h = 240,
68 		.sdcfg = (67 | (0 << 8) | (0 << 9) | (0 << 10) | (0 << 12)),
69 		.gdcfg = 3,
70 		.lutfmt = (4 | (1 << 7)),
71 		.fsynclen = 0,
72 		.fendfbegin = (80 << 8) | 4,
73 		.lsynclen = 10,
74 		.lendlbegin = (80 << 8) | 20,
75 		.pixclk = 14,
76 	},
77 	{	/* standard 9.7" on TFT backplane */
78 		.w = 1200,
79 		.h = 825,
80 		.sdcfg = (100 | (1 << 8) | (1 << 9) | (0 << 10) | (0 << 12)),
81 		.gdcfg = 2,
82 		.lutfmt = (4 | (1 << 7)),
83 		.fsynclen = 0,
84 		.fendfbegin = (4 << 8) | 4,
85 		.lsynclen = 4,
86 		.lendlbegin = (60 << 8) | 10,
87 		.pixclk = 3,
88 	},
89 };
90 
91 #define DPY_W 800
92 #define DPY_H 600
93 
94 static struct fb_fix_screeninfo broadsheetfb_fix = {
95 	.id =		"broadsheetfb",
96 	.type =		FB_TYPE_PACKED_PIXELS,
97 	.visual =	FB_VISUAL_STATIC_PSEUDOCOLOR,
98 	.xpanstep =	0,
99 	.ypanstep =	0,
100 	.ywrapstep =	0,
101 	.line_length =	DPY_W,
102 	.accel =	FB_ACCEL_NONE,
103 };
104 
105 static struct fb_var_screeninfo broadsheetfb_var = {
106 	.xres		= DPY_W,
107 	.yres		= DPY_H,
108 	.xres_virtual	= DPY_W,
109 	.yres_virtual	= DPY_H,
110 	.bits_per_pixel	= 8,
111 	.grayscale	= 1,
112 	.red =		{ 0, 4, 0 },
113 	.green =	{ 0, 4, 0 },
114 	.blue =		{ 0, 4, 0 },
115 	.transp =	{ 0, 0, 0 },
116 };
117 
118 /* main broadsheetfb functions */
119 static void broadsheet_gpio_issue_data(struct broadsheetfb_par *par, u16 data)
120 {
121 	par->board->set_ctl(par, BS_WR, 0);
122 	par->board->set_hdb(par, data);
123 	par->board->set_ctl(par, BS_WR, 1);
124 }
125 
126 static void broadsheet_gpio_issue_cmd(struct broadsheetfb_par *par, u16 data)
127 {
128 	par->board->set_ctl(par, BS_DC, 0);
129 	broadsheet_gpio_issue_data(par, data);
130 }
131 
132 static void broadsheet_gpio_send_command(struct broadsheetfb_par *par, u16 data)
133 {
134 	par->board->wait_for_rdy(par);
135 
136 	par->board->set_ctl(par, BS_CS, 0);
137 	broadsheet_gpio_issue_cmd(par, data);
138 	par->board->set_ctl(par, BS_DC, 1);
139 	par->board->set_ctl(par, BS_CS, 1);
140 }
141 
142 static void broadsheet_gpio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
143 					int argc, u16 *argv)
144 {
145 	int i;
146 
147 	par->board->wait_for_rdy(par);
148 
149 	par->board->set_ctl(par, BS_CS, 0);
150 	broadsheet_gpio_issue_cmd(par, cmd);
151 	par->board->set_ctl(par, BS_DC, 1);
152 
153 	for (i = 0; i < argc; i++)
154 		broadsheet_gpio_issue_data(par, argv[i]);
155 	par->board->set_ctl(par, BS_CS, 1);
156 }
157 
158 static void broadsheet_mmio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
159 				    int argc, u16 *argv)
160 {
161 	int i;
162 
163 	par->board->mmio_write(par, BS_MMIO_CMD, cmd);
164 
165 	for (i = 0; i < argc; i++)
166 		par->board->mmio_write(par, BS_MMIO_DATA, argv[i]);
167 }
168 
169 static void broadsheet_send_command(struct broadsheetfb_par *par, u16 data)
170 {
171 	if (par->board->mmio_write)
172 		par->board->mmio_write(par, BS_MMIO_CMD, data);
173 	else
174 		broadsheet_gpio_send_command(par, data);
175 }
176 
177 static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
178 				    int argc, u16 *argv)
179 {
180 	if (par->board->mmio_write)
181 		broadsheet_mmio_send_cmdargs(par, cmd, argc, argv);
182 	else
183 		broadsheet_gpio_send_cmdargs(par, cmd, argc, argv);
184 }
185 
186 static void broadsheet_gpio_burst_write(struct broadsheetfb_par *par, int size,
187 					u16 *data)
188 {
189 	int i;
190 	u16 tmp;
191 
192 	par->board->set_ctl(par, BS_CS, 0);
193 	par->board->set_ctl(par, BS_DC, 1);
194 
195 	for (i = 0; i < size; i++) {
196 		par->board->set_ctl(par, BS_WR, 0);
197 		tmp = (data[i] & 0x0F) << 4;
198 		tmp |= (data[i] & 0x0F00) << 4;
199 		par->board->set_hdb(par, tmp);
200 		par->board->set_ctl(par, BS_WR, 1);
201 	}
202 
203 	par->board->set_ctl(par, BS_CS, 1);
204 }
205 
206 static void broadsheet_mmio_burst_write(struct broadsheetfb_par *par, int size,
207 				   u16 *data)
208 {
209 	int i;
210 	u16 tmp;
211 
212 	for (i = 0; i < size; i++) {
213 		tmp = (data[i] & 0x0F) << 4;
214 		tmp |= (data[i] & 0x0F00) << 4;
215 		par->board->mmio_write(par, BS_MMIO_DATA, tmp);
216 	}
217 
218 }
219 
220 static void broadsheet_burst_write(struct broadsheetfb_par *par, int size,
221 				   u16 *data)
222 {
223 	if (par->board->mmio_write)
224 		broadsheet_mmio_burst_write(par, size, data);
225 	else
226 		broadsheet_gpio_burst_write(par, size, data);
227 }
228 
229 static u16 broadsheet_gpio_get_data(struct broadsheetfb_par *par)
230 {
231 	u16 res;
232 	/* wait for ready to go hi. (lo is busy) */
233 	par->board->wait_for_rdy(par);
234 
235 	/* cs lo, dc lo for cmd, we lo for each data, db as usual */
236 	par->board->set_ctl(par, BS_DC, 1);
237 	par->board->set_ctl(par, BS_CS, 0);
238 	par->board->set_ctl(par, BS_WR, 0);
239 
240 	res = par->board->get_hdb(par);
241 
242 	/* strobe wr */
243 	par->board->set_ctl(par, BS_WR, 1);
244 	par->board->set_ctl(par, BS_CS, 1);
245 
246 	return res;
247 }
248 
249 
250 static u16 broadsheet_get_data(struct broadsheetfb_par *par)
251 {
252 	if (par->board->mmio_read)
253 		return par->board->mmio_read(par);
254 	else
255 		return broadsheet_gpio_get_data(par);
256 }
257 
258 static void broadsheet_gpio_write_reg(struct broadsheetfb_par *par, u16 reg,
259 					u16 data)
260 {
261 	/* wait for ready to go hi. (lo is busy) */
262 	par->board->wait_for_rdy(par);
263 
264 	/* cs lo, dc lo for cmd, we lo for each data, db as usual */
265 	par->board->set_ctl(par, BS_CS, 0);
266 
267 	broadsheet_gpio_issue_cmd(par, BS_CMD_WR_REG);
268 
269 	par->board->set_ctl(par, BS_DC, 1);
270 
271 	broadsheet_gpio_issue_data(par, reg);
272 	broadsheet_gpio_issue_data(par, data);
273 
274 	par->board->set_ctl(par, BS_CS, 1);
275 }
276 
277 static void broadsheet_mmio_write_reg(struct broadsheetfb_par *par, u16 reg,
278 				 u16 data)
279 {
280 	par->board->mmio_write(par, BS_MMIO_CMD, BS_CMD_WR_REG);
281 	par->board->mmio_write(par, BS_MMIO_DATA, reg);
282 	par->board->mmio_write(par, BS_MMIO_DATA, data);
283 
284 }
285 
286 static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg,
287 					u16 data)
288 {
289 	if (par->board->mmio_write)
290 		broadsheet_mmio_write_reg(par, reg, data);
291 	else
292 		broadsheet_gpio_write_reg(par, reg, data);
293 }
294 
295 static void broadsheet_write_reg32(struct broadsheetfb_par *par, u16 reg,
296 					u32 data)
297 {
298 	broadsheet_write_reg(par, reg, cpu_to_le32(data) & 0xFFFF);
299 	broadsheet_write_reg(par, reg + 2, (cpu_to_le32(data) >> 16) & 0xFFFF);
300 }
301 
302 
303 static u16 broadsheet_read_reg(struct broadsheetfb_par *par, u16 reg)
304 {
305 	broadsheet_send_cmdargs(par, BS_CMD_RD_REG, 1, &reg);
306 	par->board->wait_for_rdy(par);
307 	return broadsheet_get_data(par);
308 }
309 
310 /* functions for waveform manipulation */
311 static int is_broadsheet_pll_locked(struct broadsheetfb_par *par)
312 {
313 	return broadsheet_read_reg(par, 0x000A) & 0x0001;
314 }
315 
316 static int broadsheet_setup_plls(struct broadsheetfb_par *par)
317 {
318 	int retry_count = 0;
319 	u16 tmp;
320 
321 	/* disable arral saemipu mode */
322 	broadsheet_write_reg(par, 0x0006, 0x0000);
323 
324 	broadsheet_write_reg(par, 0x0010, 0x0004);
325 	broadsheet_write_reg(par, 0x0012, 0x5949);
326 	broadsheet_write_reg(par, 0x0014, 0x0040);
327 	broadsheet_write_reg(par, 0x0016, 0x0000);
328 
329 	do {
330 		if (retry_count++ > 100)
331 			return -ETIMEDOUT;
332 		mdelay(1);
333 	} while (!is_broadsheet_pll_locked(par));
334 
335 	tmp = broadsheet_read_reg(par, 0x0006);
336 	tmp &= ~0x1;
337 	broadsheet_write_reg(par, 0x0006, tmp);
338 
339 	return 0;
340 }
341 
342 static int broadsheet_setup_spi(struct broadsheetfb_par *par)
343 {
344 
345 	broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1));
346 	broadsheet_write_reg(par, 0x0208, 0x0001);
347 
348 	return 0;
349 }
350 
351 static int broadsheet_setup_spiflash(struct broadsheetfb_par *par,
352 						u16 *orig_sfmcd)
353 {
354 
355 	*orig_sfmcd = broadsheet_read_reg(par, 0x0204);
356 	broadsheet_write_reg(par, 0x0208, 0);
357 	broadsheet_write_reg(par, 0x0204, 0);
358 	broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1));
359 
360 	return 0;
361 }
362 
363 static int broadsheet_spiflash_wait_for_bit(struct broadsheetfb_par *par,
364 						u16 reg, int bitnum, int val,
365 						int timeout)
366 {
367 	u16 tmp;
368 
369 	do {
370 		tmp = broadsheet_read_reg(par, reg);
371 		if (((tmp >> bitnum) & 1) == val)
372 			return 0;
373 		mdelay(1);
374 	} while (timeout--);
375 
376 	return -ETIMEDOUT;
377 }
378 
379 static int broadsheet_spiflash_write_byte(struct broadsheetfb_par *par, u8 data)
380 {
381 	broadsheet_write_reg(par, 0x0202, (data | 0x100));
382 
383 	return broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100);
384 }
385 
386 static int broadsheet_spiflash_read_byte(struct broadsheetfb_par *par, u8 *data)
387 {
388 	int err;
389 	u16 tmp;
390 
391 	broadsheet_write_reg(par, 0x0202, 0);
392 
393 	err = broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100);
394 	if (err)
395 		return err;
396 
397 	tmp = broadsheet_read_reg(par, 0x200);
398 
399 	*data = tmp & 0xFF;
400 
401 	return 0;
402 }
403 
404 static int broadsheet_spiflash_wait_for_status(struct broadsheetfb_par *par,
405 								int timeout)
406 {
407 	u8 tmp;
408 	int err;
409 
410 	do {
411 		broadsheet_write_reg(par, 0x0208, 1);
412 
413 		err = broadsheet_spiflash_write_byte(par, 0x05);
414 		if (err)
415 			goto failout;
416 
417 		err = broadsheet_spiflash_read_byte(par, &tmp);
418 		if (err)
419 			goto failout;
420 
421 		broadsheet_write_reg(par, 0x0208, 0);
422 
423 		if (!(tmp & 0x1))
424 			return 0;
425 
426 		mdelay(5);
427 	} while (timeout--);
428 
429 	dev_err(par->info->device, "Timed out waiting for spiflash status\n");
430 	return -ETIMEDOUT;
431 
432 failout:
433 	broadsheet_write_reg(par, 0x0208, 0);
434 	return err;
435 }
436 
437 static int broadsheet_spiflash_op_on_address(struct broadsheetfb_par *par,
438 							u8 op, u32 addr)
439 {
440 	int i;
441 	u8 tmp;
442 	int err;
443 
444 	broadsheet_write_reg(par, 0x0208, 1);
445 
446 	err = broadsheet_spiflash_write_byte(par, op);
447 	if (err)
448 		return err;
449 
450 	for (i = 2; i >= 0; i--) {
451 		tmp = ((addr >> (i * 8)) & 0xFF);
452 		err = broadsheet_spiflash_write_byte(par, tmp);
453 		if (err)
454 			return err;
455 	}
456 
457 	return err;
458 }
459 
460 static int broadsheet_verify_spiflash(struct broadsheetfb_par *par,
461 						int *flash_type)
462 {
463 	int err = 0;
464 	u8 sig;
465 
466 	err = broadsheet_spiflash_op_on_address(par, 0xAB, 0x00000000);
467 	if (err)
468 		goto failout;
469 
470 	err = broadsheet_spiflash_read_byte(par, &sig);
471 	if (err)
472 		goto failout;
473 
474 	if ((sig != 0x10) && (sig != 0x11)) {
475 		dev_err(par->info->device, "Unexpected flash type\n");
476 		err = -EINVAL;
477 		goto failout;
478 	}
479 
480 	*flash_type = sig;
481 
482 failout:
483 	broadsheet_write_reg(par, 0x0208, 0);
484 	return err;
485 }
486 
487 static int broadsheet_setup_for_wfm_write(struct broadsheetfb_par *par,
488 					u16 *initial_sfmcd, int *flash_type)
489 
490 {
491 	int err;
492 
493 	err = broadsheet_setup_plls(par);
494 	if (err)
495 		return err;
496 
497 	broadsheet_write_reg(par, 0x0106, 0x0203);
498 
499 	err = broadsheet_setup_spi(par);
500 	if (err)
501 		return err;
502 
503 	err = broadsheet_setup_spiflash(par, initial_sfmcd);
504 	if (err)
505 		return err;
506 
507 	return broadsheet_verify_spiflash(par, flash_type);
508 }
509 
510 static int broadsheet_spiflash_write_control(struct broadsheetfb_par *par,
511 						int mode)
512 {
513 	int err;
514 
515 	broadsheet_write_reg(par, 0x0208, 1);
516 	if (mode)
517 		err = broadsheet_spiflash_write_byte(par, 0x06);
518 	else
519 		err = broadsheet_spiflash_write_byte(par, 0x04);
520 
521 	broadsheet_write_reg(par, 0x0208, 0);
522 	return err;
523 }
524 
525 static int broadsheet_spiflash_erase_sector(struct broadsheetfb_par *par,
526 						int addr)
527 {
528 	int err;
529 
530 	broadsheet_spiflash_write_control(par, 1);
531 
532 	err = broadsheet_spiflash_op_on_address(par, 0xD8, addr);
533 
534 	broadsheet_write_reg(par, 0x0208, 0);
535 
536 	if (err)
537 		return err;
538 
539 	err = broadsheet_spiflash_wait_for_status(par, 1000);
540 
541 	return err;
542 }
543 
544 static int broadsheet_spiflash_read_range(struct broadsheetfb_par *par,
545 						int addr, int size, char *data)
546 {
547 	int err;
548 	int i;
549 
550 	err = broadsheet_spiflash_op_on_address(par, 0x03, addr);
551 	if (err)
552 		goto failout;
553 
554 	for (i = 0; i < size; i++) {
555 		err = broadsheet_spiflash_read_byte(par, &data[i]);
556 		if (err)
557 			goto failout;
558 	}
559 
560 failout:
561 	broadsheet_write_reg(par, 0x0208, 0);
562 	return err;
563 }
564 
565 #define BS_SPIFLASH_PAGE_SIZE 256
566 static int broadsheet_spiflash_write_page(struct broadsheetfb_par *par,
567 						int addr, const char *data)
568 {
569 	int err;
570 	int i;
571 
572 	broadsheet_spiflash_write_control(par, 1);
573 
574 	err = broadsheet_spiflash_op_on_address(par, 0x02, addr);
575 	if (err)
576 		goto failout;
577 
578 	for (i = 0; i < BS_SPIFLASH_PAGE_SIZE; i++) {
579 		err = broadsheet_spiflash_write_byte(par, data[i]);
580 		if (err)
581 			goto failout;
582 	}
583 
584 	broadsheet_write_reg(par, 0x0208, 0);
585 
586 	err = broadsheet_spiflash_wait_for_status(par, 100);
587 
588 failout:
589 	return err;
590 }
591 
592 static int broadsheet_spiflash_write_sector(struct broadsheetfb_par *par,
593 				int addr, const char *data, int sector_size)
594 {
595 	int i;
596 	int err;
597 
598 	for (i = 0; i < sector_size; i += BS_SPIFLASH_PAGE_SIZE) {
599 		err = broadsheet_spiflash_write_page(par, addr + i, &data[i]);
600 		if (err)
601 			return err;
602 	}
603 	return 0;
604 }
605 
606 /*
607  * The caller must guarantee that the data to be rewritten is entirely
608  * contained within this sector. That is, data_start_addr + data_len
609  * must be less than sector_start_addr + sector_size.
610  */
611 static int broadsheet_spiflash_rewrite_sector(struct broadsheetfb_par *par,
612 					int sector_size, int data_start_addr,
613 					int data_len, const char *data)
614 {
615 	int err;
616 	char *sector_buffer;
617 	int tail_start_addr;
618 	int start_sector_addr;
619 
620 	sector_buffer = kzalloc(sector_size, GFP_KERNEL);
621 	if (!sector_buffer)
622 		return -ENOMEM;
623 
624 	/* the start address of the sector is the 0th byte of that sector */
625 	start_sector_addr = (data_start_addr / sector_size) * sector_size;
626 
627 	/*
628 	 * check if there is head data that we need to readback into our sector
629 	 * buffer first
630 	 */
631 	if (data_start_addr != start_sector_addr) {
632 		/*
633 		 * we need to read every byte up till the start address of our
634 		 * data and we put it into our sector buffer.
635 		 */
636 		err = broadsheet_spiflash_read_range(par, start_sector_addr,
637 						data_start_addr, sector_buffer);
638 		if (err)
639 			goto out;
640 	}
641 
642 	/* now we copy our data into the right place in the sector buffer */
643 	memcpy(sector_buffer + data_start_addr, data, data_len);
644 
645 	/*
646 	 * now we check if there is a tail section of the sector that we need to
647 	 * readback.
648 	 */
649 	tail_start_addr = (data_start_addr + data_len) % sector_size;
650 
651 	if (tail_start_addr) {
652 		int tail_len;
653 
654 		tail_len = sector_size - tail_start_addr;
655 
656 		/* now we read this tail into our sector buffer */
657 		err = broadsheet_spiflash_read_range(par, tail_start_addr,
658 			tail_len, sector_buffer + tail_start_addr);
659 		if (err)
660 			goto out;
661 	}
662 
663 	/* if we got here we have the full sector that we want to rewrite. */
664 
665 	/* first erase the sector */
666 	err = broadsheet_spiflash_erase_sector(par, start_sector_addr);
667 	if (err)
668 		goto out;
669 
670 	/* now write it */
671 	err = broadsheet_spiflash_write_sector(par, start_sector_addr,
672 					sector_buffer, sector_size);
673 out:
674 	kfree(sector_buffer);
675 	return err;
676 }
677 
678 static int broadsheet_write_spiflash(struct broadsheetfb_par *par, u32 wfm_addr,
679 				const u8 *wfm, int bytecount, int flash_type)
680 {
681 	int sector_size;
682 	int err;
683 	int cur_addr;
684 	int writecount;
685 	int maxlen;
686 	int offset = 0;
687 
688 	switch (flash_type) {
689 	case 0x10:
690 		sector_size = 32*1024;
691 		break;
692 	case 0x11:
693 	default:
694 		sector_size = 64*1024;
695 		break;
696 	}
697 
698 	while (bytecount) {
699 		cur_addr = wfm_addr + offset;
700 		maxlen = roundup(cur_addr, sector_size) - cur_addr;
701 		writecount = min(bytecount, maxlen);
702 
703 		err = broadsheet_spiflash_rewrite_sector(par, sector_size,
704 				cur_addr, writecount, wfm + offset);
705 		if (err)
706 			return err;
707 
708 		offset += writecount;
709 		bytecount -= writecount;
710 	}
711 
712 	return 0;
713 }
714 
715 static int broadsheet_store_waveform_to_spiflash(struct broadsheetfb_par *par,
716 						const u8 *wfm, size_t wfm_size)
717 {
718 	int err = 0;
719 	u16 initial_sfmcd = 0;
720 	int flash_type = 0;
721 
722 	err = broadsheet_setup_for_wfm_write(par, &initial_sfmcd, &flash_type);
723 	if (err)
724 		goto failout;
725 
726 	err = broadsheet_write_spiflash(par, 0x886, wfm, wfm_size, flash_type);
727 
728 failout:
729 	broadsheet_write_reg(par, 0x0204, initial_sfmcd);
730 	return err;
731 }
732 
733 static ssize_t broadsheet_loadstore_waveform(struct device *dev,
734 						struct device_attribute *attr,
735 						const char *buf, size_t len)
736 {
737 	int err;
738 	struct fb_info *info = dev_get_drvdata(dev);
739 	struct broadsheetfb_par *par = info->par;
740 	const struct firmware *fw_entry;
741 
742 	if (len < 1)
743 		return -EINVAL;
744 
745 	err = request_firmware(&fw_entry, "broadsheet.wbf", dev);
746 	if (err < 0) {
747 		dev_err(dev, "Failed to get broadsheet waveform\n");
748 		goto err_failed;
749 	}
750 
751 	/* try to enforce reasonable min max on waveform */
752 	if ((fw_entry->size < 8*1024) || (fw_entry->size > 64*1024)) {
753 		dev_err(dev, "Invalid waveform\n");
754 		err = -EINVAL;
755 		goto err_fw;
756 	}
757 
758 	mutex_lock(&(par->io_lock));
759 	err = broadsheet_store_waveform_to_spiflash(par, fw_entry->data,
760 							fw_entry->size);
761 
762 	mutex_unlock(&(par->io_lock));
763 	if (err < 0) {
764 		dev_err(dev, "Failed to store broadsheet waveform\n");
765 		goto err_fw;
766 	}
767 
768 	dev_info(dev, "Stored broadsheet waveform, size %zd\n", fw_entry->size);
769 
770 	err = len;
771 
772 err_fw:
773 	release_firmware(fw_entry);
774 err_failed:
775 	return err;
776 }
777 static DEVICE_ATTR(loadstore_waveform, S_IWUSR, NULL,
778 			broadsheet_loadstore_waveform);
779 
780 /* upper level functions that manipulate the display and other stuff */
781 static void broadsheet_init_display(struct broadsheetfb_par *par)
782 {
783 	u16 args[5];
784 	int xres = par->info->var.xres;
785 	int yres = par->info->var.yres;
786 
787 	args[0] = panel_table[par->panel_index].w;
788 	args[1] = panel_table[par->panel_index].h;
789 	args[2] = panel_table[par->panel_index].sdcfg;
790 	args[3] = panel_table[par->panel_index].gdcfg;
791 	args[4] = panel_table[par->panel_index].lutfmt;
792 	broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
793 
794 	/* did the controller really set it? */
795 	broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
796 
797 	args[0] = panel_table[par->panel_index].fsynclen;
798 	args[1] = panel_table[par->panel_index].fendfbegin;
799 	args[2] = panel_table[par->panel_index].lsynclen;
800 	args[3] = panel_table[par->panel_index].lendlbegin;
801 	args[4] = panel_table[par->panel_index].pixclk;
802 	broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_TMG, 5, args);
803 
804 	broadsheet_write_reg32(par, 0x310, xres*yres*2);
805 
806 	/* setup waveform */
807 	args[0] = 0x886;
808 	args[1] = 0;
809 	broadsheet_send_cmdargs(par, BS_CMD_RD_WFM_INFO, 2, args);
810 
811 	broadsheet_send_command(par, BS_CMD_UPD_GDRV_CLR);
812 
813 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
814 
815 	broadsheet_write_reg(par, 0x330, 0x84);
816 
817 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
818 
819 	args[0] = (0x3 << 4);
820 	broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
821 
822 	args[0] = 0x154;
823 	broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
824 
825 	broadsheet_burst_write(par, (panel_table[par->panel_index].w *
826 					panel_table[par->panel_index].h)/2,
827 					(u16 *) par->info->screen_base);
828 
829 	broadsheet_send_command(par, BS_CMD_LD_IMG_END);
830 
831 	args[0] = 0x4300;
832 	broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
833 
834 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
835 
836 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
837 
838 	par->board->wait_for_rdy(par);
839 }
840 
841 static void broadsheet_identify(struct broadsheetfb_par *par)
842 {
843 	u16 rev, prc;
844 	struct device *dev = par->info->device;
845 
846 	rev = broadsheet_read_reg(par, BS_REG_REV);
847 	prc = broadsheet_read_reg(par, BS_REG_PRC);
848 	dev_info(dev, "Broadsheet Rev 0x%x, Product Code 0x%x\n", rev, prc);
849 
850 	if (prc != 0x0047)
851 		dev_warn(dev, "Unrecognized Broadsheet Product Code\n");
852 	if (rev != 0x0100)
853 		dev_warn(dev, "Unrecognized Broadsheet Revision\n");
854 }
855 
856 static void broadsheet_init(struct broadsheetfb_par *par)
857 {
858 	broadsheet_send_command(par, BS_CMD_INIT_SYS_RUN);
859 	/* the controller needs a second */
860 	msleep(1000);
861 	broadsheet_init_display(par);
862 }
863 
864 static void broadsheetfb_dpy_update_pages(struct broadsheetfb_par *par,
865 						u16 y1, u16 y2)
866 {
867 	u16 args[5];
868 	unsigned char *buf = (unsigned char *)par->info->screen_base;
869 
870 	mutex_lock(&(par->io_lock));
871 	/* y1 must be a multiple of 4 so drop the lower bits */
872 	y1 &= 0xFFFC;
873 	/* y2 must be a multiple of 4 , but - 1 so up the lower bits */
874 	y2 |= 0x0003;
875 
876 	args[0] = 0x3 << 4;
877 	args[1] = 0;
878 	args[2] = y1;
879 	args[3] = cpu_to_le16(par->info->var.xres);
880 	args[4] = y2;
881 	broadsheet_send_cmdargs(par, BS_CMD_LD_IMG_AREA, 5, args);
882 
883 	args[0] = 0x154;
884 	broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
885 
886 	buf += y1 * par->info->var.xres;
887 	broadsheet_burst_write(par, ((1 + y2 - y1) * par->info->var.xres)/2,
888 				(u16 *) buf);
889 
890 	broadsheet_send_command(par, BS_CMD_LD_IMG_END);
891 
892 	args[0] = 0x4300;
893 	broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
894 
895 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
896 
897 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
898 
899 	par->board->wait_for_rdy(par);
900 	mutex_unlock(&(par->io_lock));
901 
902 }
903 
904 static void broadsheetfb_dpy_update(struct broadsheetfb_par *par)
905 {
906 	u16 args[5];
907 
908 	mutex_lock(&(par->io_lock));
909 	args[0] = 0x3 << 4;
910 	broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
911 
912 	args[0] = 0x154;
913 	broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
914 	broadsheet_burst_write(par, (panel_table[par->panel_index].w *
915 					panel_table[par->panel_index].h)/2,
916 					(u16 *) par->info->screen_base);
917 
918 	broadsheet_send_command(par, BS_CMD_LD_IMG_END);
919 
920 	args[0] = 0x4300;
921 	broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args);
922 
923 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG);
924 
925 	broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
926 
927 	par->board->wait_for_rdy(par);
928 	mutex_unlock(&(par->io_lock));
929 }
930 
931 /* this is called back from the deferred io workqueue */
932 static void broadsheetfb_dpy_deferred_io(struct fb_info *info,
933 				struct list_head *pagelist)
934 {
935 	u16 y1 = 0, h = 0;
936 	int prev_index = -1;
937 	struct page *cur;
938 	struct fb_deferred_io *fbdefio = info->fbdefio;
939 	int h_inc;
940 	u16 yres = info->var.yres;
941 	u16 xres = info->var.xres;
942 
943 	/* height increment is fixed per page */
944 	h_inc = DIV_ROUND_UP(PAGE_SIZE , xres);
945 
946 	/* walk the written page list and swizzle the data */
947 	list_for_each_entry(cur, &fbdefio->pagelist, lru) {
948 		if (prev_index < 0) {
949 			/* just starting so assign first page */
950 			y1 = (cur->index << PAGE_SHIFT) / xres;
951 			h = h_inc;
952 		} else if ((prev_index + 1) == cur->index) {
953 			/* this page is consecutive so increase our height */
954 			h += h_inc;
955 		} else {
956 			/* page not consecutive, issue previous update first */
957 			broadsheetfb_dpy_update_pages(info->par, y1, y1 + h);
958 			/* start over with our non consecutive page */
959 			y1 = (cur->index << PAGE_SHIFT) / xres;
960 			h = h_inc;
961 		}
962 		prev_index = cur->index;
963 	}
964 
965 	/* if we still have any pages to update we do so now */
966 	if (h >= yres) {
967 		/* its a full screen update, just do it */
968 		broadsheetfb_dpy_update(info->par);
969 	} else {
970 		broadsheetfb_dpy_update_pages(info->par, y1,
971 						min((u16) (y1 + h), yres));
972 	}
973 }
974 
975 static void broadsheetfb_fillrect(struct fb_info *info,
976 				   const struct fb_fillrect *rect)
977 {
978 	struct broadsheetfb_par *par = info->par;
979 
980 	sys_fillrect(info, rect);
981 
982 	broadsheetfb_dpy_update(par);
983 }
984 
985 static void broadsheetfb_copyarea(struct fb_info *info,
986 				   const struct fb_copyarea *area)
987 {
988 	struct broadsheetfb_par *par = info->par;
989 
990 	sys_copyarea(info, area);
991 
992 	broadsheetfb_dpy_update(par);
993 }
994 
995 static void broadsheetfb_imageblit(struct fb_info *info,
996 				const struct fb_image *image)
997 {
998 	struct broadsheetfb_par *par = info->par;
999 
1000 	sys_imageblit(info, image);
1001 
1002 	broadsheetfb_dpy_update(par);
1003 }
1004 
1005 /*
1006  * this is the slow path from userspace. they can seek and write to
1007  * the fb. it's inefficient to do anything less than a full screen draw
1008  */
1009 static ssize_t broadsheetfb_write(struct fb_info *info, const char __user *buf,
1010 				size_t count, loff_t *ppos)
1011 {
1012 	struct broadsheetfb_par *par = info->par;
1013 	unsigned long p = *ppos;
1014 	void *dst;
1015 	int err = 0;
1016 	unsigned long total_size;
1017 
1018 	if (info->state != FBINFO_STATE_RUNNING)
1019 		return -EPERM;
1020 
1021 	total_size = info->fix.smem_len;
1022 
1023 	if (p > total_size)
1024 		return -EFBIG;
1025 
1026 	if (count > total_size) {
1027 		err = -EFBIG;
1028 		count = total_size;
1029 	}
1030 
1031 	if (count + p > total_size) {
1032 		if (!err)
1033 			err = -ENOSPC;
1034 
1035 		count = total_size - p;
1036 	}
1037 
1038 	dst = (void *)(info->screen_base + p);
1039 
1040 	if (copy_from_user(dst, buf, count))
1041 		err = -EFAULT;
1042 
1043 	if  (!err)
1044 		*ppos += count;
1045 
1046 	broadsheetfb_dpy_update(par);
1047 
1048 	return (err) ? err : count;
1049 }
1050 
1051 static struct fb_ops broadsheetfb_ops = {
1052 	.owner		= THIS_MODULE,
1053 	.fb_read        = fb_sys_read,
1054 	.fb_write	= broadsheetfb_write,
1055 	.fb_fillrect	= broadsheetfb_fillrect,
1056 	.fb_copyarea	= broadsheetfb_copyarea,
1057 	.fb_imageblit	= broadsheetfb_imageblit,
1058 };
1059 
1060 static struct fb_deferred_io broadsheetfb_defio = {
1061 	.delay		= HZ/4,
1062 	.deferred_io	= broadsheetfb_dpy_deferred_io,
1063 };
1064 
1065 static int broadsheetfb_probe(struct platform_device *dev)
1066 {
1067 	struct fb_info *info;
1068 	struct broadsheet_board *board;
1069 	int retval = -ENOMEM;
1070 	int videomemorysize;
1071 	unsigned char *videomemory;
1072 	struct broadsheetfb_par *par;
1073 	int i;
1074 	int dpyw, dpyh;
1075 	int panel_index;
1076 
1077 	/* pick up board specific routines */
1078 	board = dev->dev.platform_data;
1079 	if (!board)
1080 		return -EINVAL;
1081 
1082 	/* try to count device specific driver, if can't, platform recalls */
1083 	if (!try_module_get(board->owner))
1084 		return -ENODEV;
1085 
1086 	info = framebuffer_alloc(sizeof(struct broadsheetfb_par), &dev->dev);
1087 	if (!info)
1088 		goto err;
1089 
1090 	switch (board->get_panel_type()) {
1091 	case 37:
1092 		panel_index = 1;
1093 		break;
1094 	case 97:
1095 		panel_index = 2;
1096 		break;
1097 	case 6:
1098 	default:
1099 		panel_index = 0;
1100 		break;
1101 	}
1102 
1103 	dpyw = panel_table[panel_index].w;
1104 	dpyh = panel_table[panel_index].h;
1105 
1106 	videomemorysize = roundup((dpyw*dpyh), PAGE_SIZE);
1107 
1108 	videomemory = vzalloc(videomemorysize);
1109 	if (!videomemory)
1110 		goto err_fb_rel;
1111 
1112 	info->screen_base = (char *)videomemory;
1113 	info->fbops = &broadsheetfb_ops;
1114 
1115 	broadsheetfb_var.xres = dpyw;
1116 	broadsheetfb_var.yres = dpyh;
1117 	broadsheetfb_var.xres_virtual = dpyw;
1118 	broadsheetfb_var.yres_virtual = dpyh;
1119 	info->var = broadsheetfb_var;
1120 
1121 	broadsheetfb_fix.line_length = dpyw;
1122 	info->fix = broadsheetfb_fix;
1123 	info->fix.smem_len = videomemorysize;
1124 	par = info->par;
1125 	par->panel_index = panel_index;
1126 	par->info = info;
1127 	par->board = board;
1128 	par->write_reg = broadsheet_write_reg;
1129 	par->read_reg = broadsheet_read_reg;
1130 	init_waitqueue_head(&par->waitq);
1131 
1132 	mutex_init(&par->io_lock);
1133 
1134 	info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
1135 
1136 	info->fbdefio = &broadsheetfb_defio;
1137 	fb_deferred_io_init(info);
1138 
1139 	retval = fb_alloc_cmap(&info->cmap, 16, 0);
1140 	if (retval < 0) {
1141 		dev_err(&dev->dev, "Failed to allocate colormap\n");
1142 		goto err_vfree;
1143 	}
1144 
1145 	/* set cmap */
1146 	for (i = 0; i < 16; i++)
1147 		info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/32;
1148 	memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*16);
1149 	memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*16);
1150 
1151 	retval = par->board->setup_irq(info);
1152 	if (retval < 0)
1153 		goto err_cmap;
1154 
1155 	/* this inits the dpy */
1156 	retval = board->init(par);
1157 	if (retval < 0)
1158 		goto err_free_irq;
1159 
1160 	broadsheet_identify(par);
1161 
1162 	broadsheet_init(par);
1163 
1164 	retval = register_framebuffer(info);
1165 	if (retval < 0)
1166 		goto err_free_irq;
1167 
1168 	platform_set_drvdata(dev, info);
1169 
1170 	retval = device_create_file(&dev->dev, &dev_attr_loadstore_waveform);
1171 	if (retval < 0)
1172 		goto err_unreg_fb;
1173 
1174 	fb_info(info, "Broadsheet frame buffer, using %dK of video memory\n",
1175 		videomemorysize >> 10);
1176 
1177 
1178 	return 0;
1179 
1180 err_unreg_fb:
1181 	unregister_framebuffer(info);
1182 err_free_irq:
1183 	board->cleanup(par);
1184 err_cmap:
1185 	fb_dealloc_cmap(&info->cmap);
1186 err_vfree:
1187 	vfree(videomemory);
1188 err_fb_rel:
1189 	framebuffer_release(info);
1190 err:
1191 	module_put(board->owner);
1192 	return retval;
1193 
1194 }
1195 
1196 static int broadsheetfb_remove(struct platform_device *dev)
1197 {
1198 	struct fb_info *info = platform_get_drvdata(dev);
1199 
1200 	if (info) {
1201 		struct broadsheetfb_par *par = info->par;
1202 
1203 		device_remove_file(info->dev, &dev_attr_loadstore_waveform);
1204 		unregister_framebuffer(info);
1205 		fb_deferred_io_cleanup(info);
1206 		par->board->cleanup(par);
1207 		fb_dealloc_cmap(&info->cmap);
1208 		vfree((void *)info->screen_base);
1209 		module_put(par->board->owner);
1210 		framebuffer_release(info);
1211 	}
1212 	return 0;
1213 }
1214 
1215 static struct platform_driver broadsheetfb_driver = {
1216 	.probe	= broadsheetfb_probe,
1217 	.remove = broadsheetfb_remove,
1218 	.driver	= {
1219 		.name	= "broadsheetfb",
1220 	},
1221 };
1222 module_platform_driver(broadsheetfb_driver);
1223 
1224 MODULE_DESCRIPTION("fbdev driver for Broadsheet controller");
1225 MODULE_AUTHOR("Jaya Kumar");
1226 MODULE_LICENSE("GPL");
1227