URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [lcd.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * 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;
 
                    // 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 );
 
}
 
 
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [lcd.c] - Blame information for rev 1765

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