blob: da601fd6c07ae24424350dc77541fb695c9ad15c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * LCD, LED and Button interface for Cobalt
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
6 * for more details.
7 *
8 * Copyright (C) 1996, 1997 by Andrew Bose
9 *
10 * Linux kernel version history:
11 * March 2001: Ported from 2.0.34 by Liam Davies
12 *
13 */
14
15#define RTC_IO_EXTENT 0x10 /*Only really two ports, but... */
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/types.h>
18#include <linux/errno.h>
19#include <linux/miscdevice.h>
20#include <linux/slab.h>
21#include <linux/ioport.h>
22#include <linux/fcntl.h>
23#include <linux/mc146818rtc.h>
24#include <linux/netdevice.h>
25#include <linux/sched.h>
26#include <linux/delay.h>
27
28#include <asm/io.h>
29#include <asm/uaccess.h>
30#include <asm/system.h>
31#include <linux/delay.h>
32
33#include "lcd.h"
34
35static DEFINE_SPINLOCK(lcd_lock);
36
37static int lcd_ioctl(struct inode *inode, struct file *file,
38 unsigned int cmd, unsigned long arg);
39
40static unsigned int lcd_present = 1;
41
42/* used in arch/mips/cobalt/reset.c */
43int led_state = 0;
44
45#if defined(CONFIG_TULIP) && 0
46
47#define MAX_INTERFACES 8
48static linkcheck_func_t linkcheck_callbacks[MAX_INTERFACES];
49static void *linkcheck_cookies[MAX_INTERFACES];
50
51int lcd_register_linkcheck_func(int iface_num, void *func, void *cookie)
52{
53 if (iface_num < 0 ||
54 iface_num >= MAX_INTERFACES ||
55 linkcheck_callbacks[iface_num] != NULL)
56 return -1;
57 linkcheck_callbacks[iface_num] = (linkcheck_func_t) func;
58 linkcheck_cookies[iface_num] = cookie;
59 return 0;
60}
61#endif
62
63static int lcd_ioctl(struct inode *inode, struct file *file,
64 unsigned int cmd, unsigned long arg)
65{
66 struct lcd_display button_display;
67 unsigned long address, a;
68
69 switch (cmd) {
70 case LCD_On:
71 udelay(150);
72 BusyCheck();
73 LCDWriteInst(0x0F);
74 break;
75
76 case LCD_Off:
77 udelay(150);
78 BusyCheck();
79 LCDWriteInst(0x08);
80 break;
81
82 case LCD_Reset:
83 udelay(150);
84 LCDWriteInst(0x3F);
85 udelay(150);
86 LCDWriteInst(0x3F);
87 udelay(150);
88 LCDWriteInst(0x3F);
89 udelay(150);
90 LCDWriteInst(0x3F);
91 udelay(150);
92 LCDWriteInst(0x01);
93 udelay(150);
94 LCDWriteInst(0x06);
95 break;
96
97 case LCD_Clear:
98 udelay(150);
99 BusyCheck();
100 LCDWriteInst(0x01);
101 break;
102
103 case LCD_Cursor_Left:
104 udelay(150);
105 BusyCheck();
106 LCDWriteInst(0x10);
107 break;
108
109 case LCD_Cursor_Right:
110 udelay(150);
111 BusyCheck();
112 LCDWriteInst(0x14);
113 break;
114
115 case LCD_Cursor_Off:
116 udelay(150);
117 BusyCheck();
118 LCDWriteInst(0x0C);
119 break;
120
121 case LCD_Cursor_On:
122 udelay(150);
123 BusyCheck();
124 LCDWriteInst(0x0F);
125 break;
126
127 case LCD_Blink_Off:
128 udelay(150);
129 BusyCheck();
130 LCDWriteInst(0x0E);
131 break;
132
133 case LCD_Get_Cursor_Pos:{
134 struct lcd_display display;
135
136 udelay(150);
137 BusyCheck();
138 display.cursor_address = (LCDReadInst);
139 display.cursor_address =
140 (display.cursor_address & 0x07F);
141 if (copy_to_user
142 ((struct lcd_display *) arg, &display,
143 sizeof(struct lcd_display)))
144 return -EFAULT;
145
146 break;
147 }
148
149
150 case LCD_Set_Cursor_Pos:{
151 struct lcd_display display;
152
153 if (copy_from_user
154 (&display, (struct lcd_display *) arg,
155 sizeof(struct lcd_display)))
156 return -EFAULT;
157
158 a = (display.cursor_address | kLCD_Addr);
159
160 udelay(150);
161 BusyCheck();
162 LCDWriteInst(a);
163
164 break;
165 }
166
167 case LCD_Get_Cursor:{
168 struct lcd_display display;
169
170 udelay(150);
171 BusyCheck();
172 display.character = LCDReadData;
173
174 if (copy_to_user
175 ((struct lcd_display *) arg, &display,
176 sizeof(struct lcd_display)))
177 return -EFAULT;
178 udelay(150);
179 BusyCheck();
180 LCDWriteInst(0x10);
181
182 break;
183 }
184
185 case LCD_Set_Cursor:{
186 struct lcd_display display;
187
188 if (copy_from_user
189 (&display, (struct lcd_display *) arg,
190 sizeof(struct lcd_display)))
191 return -EFAULT;
192
193 udelay(150);
194 BusyCheck();
195 LCDWriteData(display.character);
196 udelay(150);
197 BusyCheck();
198 LCDWriteInst(0x10);
199
200 break;
201 }
202
203
204 case LCD_Disp_Left:
205 udelay(150);
206 BusyCheck();
207 LCDWriteInst(0x18);
208 break;
209
210 case LCD_Disp_Right:
211 udelay(150);
212 BusyCheck();
213 LCDWriteInst(0x1C);
214 break;
215
216 case LCD_Home:
217 udelay(150);
218 BusyCheck();
219 LCDWriteInst(0x02);
220 break;
221
222 case LCD_Write:{
223 struct lcd_display display;
224 unsigned int index;
225
226
227 if (copy_from_user
228 (&display, (struct lcd_display *) arg,
229 sizeof(struct lcd_display)))
230 return -EFAULT;
231
232 udelay(150);
233 BusyCheck();
234 LCDWriteInst(0x80);
235 udelay(150);
236 BusyCheck();
237
238 for (index = 0; index < (display.size1); index++) {
239 udelay(150);
240 BusyCheck();
241 LCDWriteData(display.line1[index]);
242 BusyCheck();
243 }
244
245 udelay(150);
246 BusyCheck();
247 LCDWriteInst(0xC0);
248 udelay(150);
249 BusyCheck();
250 for (index = 0; index < (display.size2); index++) {
251 udelay(150);
252 BusyCheck();
253 LCDWriteData(display.line2[index]);
254 }
255
256 break;
257 }
258
259 case LCD_Read:{
260 struct lcd_display display;
261
262 BusyCheck();
263 for (address = kDD_R00; address <= kDD_R01;
264 address++) {
265 a = (address | kLCD_Addr);
266
267 udelay(150);
268 BusyCheck();
269 LCDWriteInst(a);
270 udelay(150);
271 BusyCheck();
272 display.line1[address] = LCDReadData;
273 }
274
275 display.line1[0x27] = '\0';
276
277 for (address = kDD_R10; address <= kDD_R11;
278 address++) {
279 a = (address | kLCD_Addr);
280
281 udelay(150);
282 BusyCheck();
283 LCDWriteInst(a);
284
285 udelay(150);
286 BusyCheck();
287 display.line2[address - 0x40] =
288 LCDReadData;
289 }
290
291 display.line2[0x27] = '\0';
292
293 if (copy_to_user
294 ((struct lcd_display *) arg, &display,
295 sizeof(struct lcd_display)))
296 return -EFAULT;
297 break;
298 }
299
300// set all GPIO leds to led_display.leds
301
302 case LED_Set:{
303 struct lcd_display led_display;
304
305
306 if (copy_from_user
307 (&led_display, (struct lcd_display *) arg,
308 sizeof(struct lcd_display)))
309 return -EFAULT;
310
311 led_state = led_display.leds;
312 LEDSet(led_state);
313
314 break;
315 }
316
317
318// set only bit led_display.leds
319
320 case LED_Bit_Set:{
321 unsigned int i;
322 int bit = 1;
323 struct lcd_display led_display;
324
325
326 if (copy_from_user
327 (&led_display, (struct lcd_display *) arg,
328 sizeof(struct lcd_display)))
329 return -EFAULT;
330
331 for (i = 0; i < (int) led_display.leds; i++) {
332 bit = 2 * bit;
333 }
334
335 led_state = led_state | bit;
336 LEDSet(led_state);
337 break;
338 }
339
340// clear only bit led_display.leds
341
342 case LED_Bit_Clear:{
343 unsigned int i;
344 int bit = 1;
345 struct lcd_display led_display;
346
347
348 if (copy_from_user
349 (&led_display, (struct lcd_display *) arg,
350 sizeof(struct lcd_display)))
351 return -EFAULT;
352
353 for (i = 0; i < (int) led_display.leds; i++) {
354 bit = 2 * bit;
355 }
356
357 led_state = led_state & ~bit;
358 LEDSet(led_state);
359 break;
360 }
361
362
363 case BUTTON_Read:{
364 button_display.buttons = GPIRead;
365 if (copy_to_user
366 ((struct lcd_display *) arg, &button_display,
367 sizeof(struct lcd_display)))
368 return -EFAULT;
369 break;
370 }
371
372 case LINK_Check:{
373 button_display.buttons =
374 *((volatile unsigned long *) (0xB0100060));
375 if (copy_to_user
376 ((struct lcd_display *) arg, &button_display,
377 sizeof(struct lcd_display)))
378 return -EFAULT;
379 break;
380 }
381
382 case LINK_Check_2:{
383 int iface_num;
384
385 /* panel-utils should pass in the desired interface status is wanted for
386 * in "buttons" of the structure. We will set this to non-zero if the
387 * link is in fact up for the requested interface. --DaveM
388 */
389 if (copy_from_user
390 (&button_display, (struct lcd_display *) arg,
391 sizeof(button_display)))
392 return -EFAULT;
393 iface_num = button_display.buttons;
394#if defined(CONFIG_TULIP) && 0
395 if (iface_num >= 0 &&
396 iface_num < MAX_INTERFACES &&
397 linkcheck_callbacks[iface_num] != NULL) {
398 button_display.buttons =
399 linkcheck_callbacks[iface_num]
400 (linkcheck_cookies[iface_num]);
401 } else
402#endif
403 button_display.buttons = 0;
404
405 if (__copy_to_user
406 ((struct lcd_display *) arg, &button_display,
407 sizeof(struct lcd_display)))
408 return -EFAULT;
409 break;
410 }
411
412// Erase the flash
413
414 case FLASH_Erase:{
415
416 int ctr = 0;
417
418 if ( !capable(CAP_SYS_ADMIN) ) return -EPERM;
419
420 pr_info(LCD "Erasing Flash\n");
421
422 // Chip Erase Sequence
423 WRITE_FLASH(kFlash_Addr1, kFlash_Data1);
424 WRITE_FLASH(kFlash_Addr2, kFlash_Data2);
425 WRITE_FLASH(kFlash_Addr1, kFlash_Erase3);
426 WRITE_FLASH(kFlash_Addr1, kFlash_Data1);
427 WRITE_FLASH(kFlash_Addr2, kFlash_Data2);
428 WRITE_FLASH(kFlash_Addr1, kFlash_Erase6);
429
430 while ((!dqpoll(0x00000000, 0xFF))
431 && (!timeout(0x00000000))) {
432 ctr++;
433 }
434
435 if (READ_FLASH(0x07FFF0) == 0xFF) {
436 pr_info(LCD "Erase Successful\n");
437 } else if (timeout) {
438 pr_info(LCD "Erase Timed Out\n");
439 }
440
441 break;
442 }
443
444// burn the flash
445
446 case FLASH_Burn:{
447
448 volatile unsigned long burn_addr;
449 unsigned long flags;
450 unsigned int i, index;
451 unsigned char *rom;
452
453
454 struct lcd_display display;
455
456 if ( !capable(CAP_SYS_ADMIN) ) return -EPERM;
457
458 if (copy_from_user
459 (&display, (struct lcd_display *) arg,
460 sizeof(struct lcd_display)))
461 return -EFAULT;
462 rom = (unsigned char *) kmalloc((128), GFP_ATOMIC);
463 if (rom == NULL) {
464 printk(KERN_ERR LCD "kmalloc() failed in %s\n",
465 __FUNCTION__);
466 return -ENOMEM;
467 }
468
469 pr_info(LCD "Starting Flash burn\n");
470 for (i = 0; i < FLASH_SIZE; i = i + 128) {
471
472 if (copy_from_user
473 (rom, display.RomImage + i, 128)) {
474 kfree(rom);
475 return -EFAULT;
476 }
477 burn_addr = kFlashBase + i;
478 spin_lock_irqsave(&lcd_lock, flags);
479 for (index = 0; index < (128); index++) {
480
481 WRITE_FLASH(kFlash_Addr1,
482 kFlash_Data1);
483 WRITE_FLASH(kFlash_Addr2,
484 kFlash_Data2);
485 WRITE_FLASH(kFlash_Addr1,
486 kFlash_Prog);
487 *((volatile unsigned char *)burn_addr) =
488 (volatile unsigned char) rom[index];
489
490 while ((!dqpoll (burn_addr,
491 (volatile unsigned char)
492 rom[index])) &&
493 (!timeout(burn_addr))) { }
494 burn_addr++;
495 }
496 spin_unlock_irqrestore(&lcd_lock, flags);
497 if (* ((volatile unsigned char *)
498 (burn_addr - 1)) ==
499 (volatile unsigned char)
500 rom[index - 1]) {
501 } else if (timeout) {
502 pr_info(LCD "Flash burn timed out\n");
503 }
504
505
506 }
507 kfree(rom);
508
509 pr_info(LCD "Flash successfully burned\n");
510
511 break;
512 }
513
514// read the flash all at once
515
516 case FLASH_Read:{
517
518 unsigned char *user_bytes;
519 volatile unsigned long read_addr;
520 unsigned int i;
521
522 user_bytes =
523 &(((struct lcd_display *) arg)->RomImage[0]);
524
525 if (!access_ok
526 (VERIFY_WRITE, user_bytes, FLASH_SIZE))
527 return -EFAULT;
528
529 pr_info(LCD "Reading Flash");
530 for (i = 0; i < FLASH_SIZE; i++) {
531 unsigned char tmp_byte;
532 read_addr = kFlashBase + i;
533 tmp_byte =
534 *((volatile unsigned char *)
535 read_addr);
536 if (__put_user(tmp_byte, &user_bytes[i]))
537 return -EFAULT;
538 }
539
540
541 break;
542 }
543
544 default:
545 return -EINVAL;
546
547 }
548
549 return 0;
550
551}
552
553static int lcd_open(struct inode *inode, struct file *file)
554{
555 if (!lcd_present)
556 return -ENXIO;
557 else
558 return 0;
559}
560
561/* Only RESET or NEXT counts as button pressed */
562
563static inline int button_pressed(void)
564{
565 unsigned long buttons = GPIRead;
566
567 if ((buttons == BUTTON_Next) || (buttons == BUTTON_Next_B)
568 || (buttons == BUTTON_Reset_B))
569 return buttons;
570 return 0;
571}
572
573/* LED daemon sits on this and we wake him up once a key is pressed. */
574
575static int lcd_waiters = 0;
576
Ralf Baechlec4ed38a2005-02-21 16:18:36 +0000577static ssize_t lcd_read(struct file *file, char *buf,
578 size_t count, loff_t *ofs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
580 long buttons_now;
581
582 if (lcd_waiters > 0)
583 return -EINVAL;
584
585 lcd_waiters++;
586 while (((buttons_now = (long) button_pressed()) == 0) &&
587 !(signal_pending(current))) {
588 msleep_interruptible(2000);
589 }
590 lcd_waiters--;
591
592 if (signal_pending(current))
593 return -ERESTARTSYS;
594 return buttons_now;
595}
596
597/*
598 * The various file operations we support.
599 */
600
Arjan van de Ven62322d22006-07-03 00:24:21 -0700601static const struct file_operations lcd_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 .read = lcd_read,
603 .ioctl = lcd_ioctl,
604 .open = lcd_open,
605};
606
607static struct miscdevice lcd_dev = {
608 MISC_DYNAMIC_MINOR,
609 "lcd",
610 &lcd_fops
611};
612
613static int lcd_init(void)
614{
Christophe Lucascf85d5c2005-09-10 00:26:32 -0700615 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 unsigned long data;
617
618 pr_info("%s\n", LCD_DRIVER);
Christophe Lucascf85d5c2005-09-10 00:26:32 -0700619 ret = misc_register(&lcd_dev);
620 if (ret) {
621 printk(KERN_WARNING LCD "Unable to register misc device.\n");
622 return ret;
623 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 /* Check region? Naaah! Just snarf it up. */
626/* request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/
627
628 udelay(150);
629 data = LCDReadData;
630 if ((data & 0x000000FF) == (0x00)) {
631 lcd_present = 0;
632 pr_info(LCD "LCD Not Present\n");
633 } else {
634 lcd_present = 1;
635 WRITE_GAL(kGal_DevBank2PReg, kGal_DevBank2Cfg);
636 WRITE_GAL(kGal_DevBank3PReg, kGal_DevBank3Cfg);
637 }
638
639 return 0;
640}
641
642static void __exit lcd_exit(void)
643{
644 misc_deregister(&lcd_dev);
645}
646
647//
648// Function: dqpoll
649//
650// Description: Polls the data lines to see if the flash is busy
651//
652// In: address, byte data
653//
654// Out: 0 = busy, 1 = write or erase complete
655//
656//
657
658static int dqpoll(volatile unsigned long address, volatile unsigned char data)
659{
660 volatile unsigned char dq7;
661
662 dq7 = data & 0x80;
663
664 return ((READ_FLASH(address) & 0x80) == dq7);
665}
666
667//
668// Function: timeout
669//
670// Description: Checks to see if erase or write has timed out
671// By polling dq5
672//
673// In: address
674//
675//
676// Out: 0 = not timed out, 1 = timed out
677
678static int timeout(volatile unsigned long address)
679{
680 return (READ_FLASH(address) & 0x20) == 0x20;
681}
682
683module_init(lcd_init);
684module_exit(lcd_exit);
685
686MODULE_AUTHOR("Andrew Bose");
687MODULE_LICENSE("GPL");