patch-2.4.19 linux-2.4.19/drivers/char/lcd.c
Next file: linux-2.4.19/drivers/char/lcd.h
Previous file: linux-2.4.19/drivers/char/keyboard.c
Back to the patch index
Back to the overall index
- Lines: 633
- Date:
Fri Aug 2 17:39:43 2002
- Orig file:
linux-2.4.18/drivers/char/lcd.c
- Orig date:
Wed Dec 31 16:00:00 1969
diff -urN linux-2.4.18/drivers/char/lcd.c linux-2.4.19/drivers/char/lcd.c
@@ -0,0 +1,632 @@
+/*
+ * 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/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;
+
+ // 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(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))
+ 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=
+{
+ LCD_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 );
+
+}
+
+
+
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)