| /* |
| * LCD, LED and Button interface for Cobalt |
| * |
| * This file is subject to the terms and conditions of the GNU General Public |
| * License. See the file "COPYING" in the main directory of this archive |
| * for more details. |
| * |
| * Copyright (C) 1996, 1997 by Andrew Bose |
| * |
| * Linux kernel version history: |
| * March 2001: Ported from 2.0.34 by Liam Davies |
| * |
| */ |
| |
| #define RTC_IO_EXTENT 0x10 /*Only really two ports, but... */ |
| |
| #include <linux/config.h> |
| #include <linux/types.h> |
| #include <linux/errno.h> |
| #include <linux/miscdevice.h> |
| #include <linux/slab.h> |
| #include <linux/ioport.h> |
| #include <linux/fcntl.h> |
| #include <linux/mc146818rtc.h> |
| #include <linux/netdevice.h> |
| #include <linux/sched.h> |
| |
| #include <asm/io.h> |
| #include <asm/uaccess.h> |
| #include <asm/system.h> |
| #include <linux/delay.h> |
| |
| #include "lcd.h" |
| |
| static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, |
| unsigned long arg); |
| |
| static int lcd_present = 1; |
| |
| int led_state = 0; |
| |
| #if defined(CONFIG_TULIP) && 0 |
| |
| #define MAX_INTERFACES 8 |
| static linkcheck_func_t linkcheck_callbacks[MAX_INTERFACES]; |
| static void *linkcheck_cookies[MAX_INTERFACES]; |
| |
| int lcd_register_linkcheck_func(int iface_num, void *func, void *cookie) |
| { |
| if (iface_num < 0 || |
| iface_num >= MAX_INTERFACES || |
| linkcheck_callbacks[iface_num] != NULL) |
| return -1; |
| linkcheck_callbacks[iface_num] = (linkcheck_func_t) func; |
| linkcheck_cookies[iface_num] = cookie; |
| return 0; |
| } |
| #endif |
| |
| static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, |
| unsigned long arg) |
| { |
| struct lcd_display button_display; |
| unsigned long address, a; |
| int index; |
| |
| switch (cmd) { |
| case LCD_On: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x0F); |
| break; |
| |
| case LCD_Off: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x08); |
| break; |
| |
| case LCD_Reset: |
| udelay(150); |
| LCDWriteInst(0x3F); |
| udelay(150); |
| LCDWriteInst(0x3F); |
| udelay(150); |
| LCDWriteInst(0x3F); |
| udelay(150); |
| LCDWriteInst(0x3F); |
| udelay(150); |
| LCDWriteInst(0x01); |
| udelay(150); |
| LCDWriteInst(0x06); |
| break; |
| |
| case LCD_Clear: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x01); |
| break; |
| |
| case LCD_Cursor_Left: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x10); |
| break; |
| |
| case LCD_Cursor_Right: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x14); |
| break; |
| |
| case LCD_Cursor_Off: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x0C); |
| break; |
| |
| case LCD_Cursor_On: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x0F); |
| break; |
| |
| case LCD_Blink_Off: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x0E); |
| break; |
| |
| case LCD_Get_Cursor_Pos:{ |
| struct lcd_display display; |
| |
| udelay(150); |
| BusyCheck(); |
| display.cursor_address = ( LCDReadInst ); |
| display.cursor_address = ( display.cursor_address & 0x07F ); |
| if(copy_to_user((struct lcd_display*)arg, &display, sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| break; |
| } |
| |
| |
| case LCD_Set_Cursor_Pos: { |
| struct lcd_display display; |
| |
| if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| a = (display.cursor_address | kLCD_Addr ); |
| |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst( a ); |
| |
| break; |
| } |
| |
| case LCD_Get_Cursor: { |
| struct lcd_display display; |
| |
| udelay(150); |
| BusyCheck(); |
| display.character = LCDReadData; |
| |
| if(copy_to_user((struct lcd_display*)arg, &display, sizeof(struct lcd_display))) |
| return -EFAULT; |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x10); |
| |
| break; |
| } |
| |
| case LCD_Set_Cursor:{ |
| struct lcd_display display; |
| |
| if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| udelay(150); |
| BusyCheck(); |
| LCDWriteData( display.character ); |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x10); |
| |
| break; |
| } |
| |
| |
| case LCD_Disp_Left: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x18); |
| break; |
| |
| case LCD_Disp_Right: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x1C); |
| break; |
| |
| case LCD_Home: |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x02); |
| break; |
| |
| case LCD_Write: { |
| struct lcd_display display; |
| |
| |
| if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0x80); |
| udelay(150); |
| BusyCheck(); |
| |
| for (index = 0; index < (display.size1); index++) { |
| udelay(150); |
| BusyCheck(); |
| LCDWriteData( display.line1[index]); |
| BusyCheck(); |
| } |
| |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst(0xC0); |
| udelay(150); |
| BusyCheck(); |
| for (index = 0; index < (display.size2); index++) { |
| udelay(150); |
| BusyCheck(); |
| LCDWriteData( display.line2[index]); |
| } |
| |
| break; |
| } |
| |
| case LCD_Read: { |
| struct lcd_display display; |
| |
| BusyCheck(); |
| for (address = kDD_R00; address <= kDD_R01; address++) { |
| a = (address | kLCD_Addr ); |
| |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst( a ); |
| udelay(150); |
| BusyCheck(); |
| display.line1[address] = LCDReadData; |
| } |
| |
| display.line1[ 0x27 ] = '\0'; |
| |
| for (address = kDD_R10; address <= kDD_R11; address++) { |
| a = (address | kLCD_Addr ); |
| |
| udelay(150); |
| BusyCheck(); |
| LCDWriteInst( a ); |
| |
| udelay(150); |
| BusyCheck(); |
| display.line2[address - 0x40 ] = LCDReadData; |
| } |
| |
| display.line2[ 0x27 ] = '\0'; |
| |
| if(copy_to_user((struct lcd_display*)arg, &display, |
| sizeof(struct lcd_display))) |
| return -EFAULT; |
| break; |
| } |
| |
| // set all GPIO leds to led_display.leds |
| |
| case LED_Set: { |
| struct lcd_display led_display; |
| |
| |
| if(copy_from_user(&led_display, (struct lcd_display*)arg, |
| sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| led_state = led_display.leds; |
| LEDSet(led_state); |
| |
| break; |
| } |
| |
| |
| // set only bit led_display.leds |
| |
| case LED_Bit_Set: { |
| int i; |
| int bit=1; |
| struct lcd_display led_display; |
| |
| |
| if(copy_from_user(&led_display, (struct lcd_display*)arg, |
| sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| for (i=0;i<(int)led_display.leds;i++) |
| { |
| bit = 2*bit; |
| } |
| |
| led_state = led_state | bit; |
| LEDSet(led_state); |
| break; |
| } |
| |
| // clear only bit led_display.leds |
| |
| case LED_Bit_Clear: { |
| int i; |
| int bit=1; |
| struct lcd_display led_display; |
| |
| |
| if(copy_from_user(&led_display, (struct lcd_display*)arg, |
| sizeof(struct lcd_display))) |
| return -EFAULT; |
| |
| for (i=0;i<(int)led_display.leds;i++) |
| { |
| bit = 2*bit; |
| } |
| |
| led_state = led_state & ~bit; |
| LEDSet(led_state); |
| break; |
| } |
| |
| |
| case BUTTON_Read: { |
| button_display.buttons = GPIRead; |
| if(copy_to_user((struct lcd_display*)arg, &button_display, sizeof(struct lcd_display))) |
| return -EFAULT; |
| break; |
| } |
| |
| case LINK_Check: { |
| button_display.buttons = *((volatile unsigned long *) (0xB0100060) ); |
| if(copy_to_user((struct lcd_display*)arg, &button_display, sizeof(struct lcd_display))) |
| return -EFAULT; |
| break; |
| } |
| |
| case LINK_Check_2: { |
| int iface_num; |
| |
| /* panel-utils should pass in the desired interface status is wanted for |
| * in "buttons" of the structure. We will set this to non-zero if the |
| * link is in fact up for the requested interface. --DaveM |
| */ |
| if(copy_from_user(&button_display, (struct lcd_display *)arg, sizeof(button_display))) |
| return -EFAULT; |
| iface_num = button_display.buttons; |
| #if defined(CONFIG_TULIP) && 0 |
| if (iface_num >= 0 && |
| iface_num < MAX_INTERFACES && |
| linkcheck_callbacks[iface_num] != NULL) { |
| button_display.buttons = |
| linkcheck_callbacks[iface_num](linkcheck_cookies[iface_num]); |
| } else |
| #endif |
| button_display.buttons = 0; |
| |
| if(__copy_to_user((struct lcd_display*)arg, &button_display, sizeof(struct lcd_display))) |
| return -EFAULT; |
| break; |
| } |
| |
| // Erase the flash |
| |
| case FLASH_Erase: { |
| |
| int ctr=0; |
| |
| if (!capable(CAP_SYS_ADMIN)) return -EPERM; |
| |
| // Chip Erase Sequence |
| WRITE_FLASH( kFlash_Addr1, kFlash_Data1 ); |
| WRITE_FLASH( kFlash_Addr2, kFlash_Data2 ); |
| WRITE_FLASH( kFlash_Addr1, kFlash_Erase3 ); |
| WRITE_FLASH( kFlash_Addr1, kFlash_Data1 ); |
| WRITE_FLASH( kFlash_Addr2, kFlash_Data2 ); |
| WRITE_FLASH( kFlash_Addr1, kFlash_Erase6 ); |
| |
| printk( "Erasing Flash.\n"); |
| |
| while ( (!dqpoll(0x00000000,0xFF)) && (!timeout(0x00000000)) ) { |
| ctr++; |
| } |
| |
| printk("\n"); |
| printk("\n"); |
| printk("\n"); |
| |
| if (READ_FLASH(0x07FFF0)==0xFF) { printk("Erase Successful\r\n"); } |
| else if (timeout) { printk("Erase Timed Out\r\n"); } |
| |
| break; |
| } |
| |
| // burn the flash |
| |
| case FLASH_Burn: { |
| |
| volatile unsigned long burn_addr; |
| unsigned long flags; |
| int i; |
| unsigned char *rom; |
| |
| |
| struct lcd_display display; |
| |
| if (!capable(CAP_SYS_ADMIN)) return -EPERM; |
| |
| if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display))) |
| return -EFAULT; |
| rom = (unsigned char *) kmalloc((128),GFP_ATOMIC); |
| if ( rom == NULL ) { |
| printk ("broken\n"); |
| return 1; |
| } |
| |
| printk("Churning and Burning -"); |
| save_flags(flags); |
| for (i=0; i<FLASH_SIZE; i=i+128) { |
| |
| if(copy_from_user(rom, display.RomImage + i, 128)) { |
| kfree(rom); |
| return -EFAULT; |
| } |
| burn_addr = kFlashBase + i; |
| cli(); |
| for ( index = 0; index < ( 128 ) ; index++ ) |
| { |
| |
| WRITE_FLASH( kFlash_Addr1, kFlash_Data1 ); |
| WRITE_FLASH( kFlash_Addr2, kFlash_Data2 ); |
| WRITE_FLASH( kFlash_Addr1, kFlash_Prog ); |
| *((volatile unsigned char *)burn_addr) = (volatile unsigned char) rom[index]; |
| |
| while ( (!dqpoll(burn_addr,(volatile unsigned char) rom[index])) && (!timeout(burn_addr)) ) { |
| } |
| burn_addr++; |
| } |
| restore_flags(flags); |
| if ( *((volatile unsigned char *)(burn_addr-1)) == (volatile unsigned char) rom[index-1] ) { |
| } else if (timeout) { |
| printk("Program timed out\r\n"); |
| } |
| |
| |
| } |
| kfree(rom); |
| |
| break; |
| } |
| |
| // read the flash all at once |
| |
| case FLASH_Read: { |
| |
| unsigned char *user_bytes; |
| volatile unsigned long read_addr; |
| int i; |
| |
| user_bytes = &(((struct lcd_display *)arg)->RomImage[0]); |
| |
| if(!access_ok(VERIFY_WRITE, user_bytes, FLASH_SIZE)) |
| return -EFAULT; |
| |
| printk("Reading Flash"); |
| for (i=0; i<FLASH_SIZE; i++) { |
| unsigned char tmp_byte; |
| read_addr = kFlashBase + i; |
| tmp_byte = *((volatile unsigned char *)read_addr); |
| if(__put_user (tmp_byte, &user_bytes[i])) |
| return -EFAULT; |
| } |
| |
| |
| break; |
| } |
| |
| |
| |
| |
| |
| default: |
| return 0; |
| break; |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| static int lcd_open(struct inode *inode, struct file *file) |
| { |
| if (!lcd_present) |
| return -ENXIO; |
| else |
| return 0; |
| } |
| |
| /* Only RESET or NEXT counts as button pressed */ |
| |
| static inline int button_pressed(void) |
| { |
| unsigned long buttons = GPIRead; |
| |
| if ( (buttons == BUTTON_Next) || (buttons == BUTTON_Next_B) || (buttons == BUTTON_Reset_B) ) |
| return buttons; |
| return 0; |
| } |
| |
| /* LED daemon sits on this and we wake him up once a key is pressed. */ |
| |
| static int lcd_waiters = 0; |
| |
| static long lcd_read(struct inode *inode, struct file *file, char *buf, unsigned long count) |
| { |
| long buttons_now; |
| |
| if(lcd_waiters > 0) |
| return -EINVAL; |
| |
| lcd_waiters++; |
| while(((buttons_now = (long)button_pressed()) == 0) && |
| !(signal_pending(current))) { |
| current->state = TASK_INTERRUPTIBLE; |
| schedule_timeout(2 * HZ); |
| } |
| lcd_waiters--; |
| |
| if(signal_pending(current)) |
| return -ERESTARTSYS; |
| return buttons_now; |
| } |
| |
| /* |
| * The various file operations we support. |
| */ |
| |
| static struct file_operations lcd_fops = { |
| read: lcd_read, |
| ioctl: lcd_ioctl, |
| open: lcd_open, |
| }; |
| |
| static struct miscdevice lcd_dev = { |
| MISC_DYNAMIC_MINOR, |
| "lcd", |
| &lcd_fops |
| }; |
| |
| int lcd_init(void) |
| { |
| unsigned long data; |
| |
| printk("%s\n", LCD_DRIVER); |
| misc_register(&lcd_dev); |
| |
| /* Check region? Naaah! Just snarf it up. */ |
| /* request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/ |
| |
| udelay(150); |
| data = LCDReadData; |
| if ( (data & 0x000000FF) == (0x00) ) { |
| lcd_present = 0; |
| printk("LCD Not Present\n"); |
| } |
| else { |
| lcd_present = 1; |
| WRITE_GAL( kGal_DevBank2PReg, kGal_DevBank2Cfg ); |
| WRITE_GAL( kGal_DevBank3PReg, kGal_DevBank3Cfg ); |
| } |
| |
| return 0; |
| } |
| |
| |
| // |
| // Function: dqpoll |
| // |
| // Description: Polls the data lines to see if the flash is busy |
| // |
| // In: address, byte data |
| // |
| // Out: 0 = busy, 1 = write or erase complete |
| // |
| // |
| |
| int dqpoll( volatile unsigned long address, volatile unsigned char data ) { |
| |
| volatile unsigned char dq7; |
| |
| dq7 = data & 0x80; |
| |
| return ( (READ_FLASH(address) & 0x80) == dq7 ); |
| |
| } |
| |
| |
| // |
| // Function: timeout |
| // |
| // Description: Checks to see if erase or write has timed out |
| // By polling dq5 |
| // |
| // In: address |
| // |
| // |
| // Out: 0 = not timed out, 1 = timed out |
| |
| int timeout( volatile unsigned long address ) { |
| |
| |
| return ( (READ_FLASH(address) & 0x20) == 0x20 ); |
| |
| } |
| |
| |
| |