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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [lcd.c] - Blame information for rev 62

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
 *
 */
#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 <linux/delay.h>
 
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>
 
#include "lcd.h"
 
static int lcd_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg);
 
static unsigned int lcd_present = 1;
 
/* used in arch/mips/cobalt/reset.c */
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;
 
        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;
                        unsigned int index;
 
 
                        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:{
                        unsigned 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:{
                        unsigned 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;
                }
 
        default:
                return -EINVAL;
 
        }
 
        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 ssize_t lcd_read(struct file *file, char *buf,
                     size_t count, loff_t *ofs)
{
        long buttons_now;
 
        if (lcd_waiters > 0)
                return -EINVAL;
 
        lcd_waiters++;
        while (((buttons_now = (long) button_pressed()) == 0) &&
               !(signal_pending(current))) {
                msleep_interruptible(2000);
        }
        lcd_waiters--;
 
        if (signal_pending(current))
                return -ERESTARTSYS;
        return buttons_now;
}
 
/*
 *      The various file operations we support.
 */
 
static const 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
};
 
static int lcd_init(void)
{
        int ret;
        unsigned long data;
 
        pr_info("%s\n", LCD_DRIVER);
        ret = misc_register(&lcd_dev);
        if (ret) {
                printk(KERN_WARNING LCD "Unable to register misc device.\n");
                return ret;
        }
 
        /* 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;
                pr_info(LCD "LCD Not Present\n");
        } else {
                lcd_present = 1;
                WRITE_GAL(kGal_DevBank2PReg, kGal_DevBank2Cfg);
                WRITE_GAL(kGal_DevBank3PReg, kGal_DevBank3Cfg);
        }
 
        return 0;
}
 
static void __exit lcd_exit(void)
{
        misc_deregister(&lcd_dev);
}
 
module_init(lcd_init);
module_exit(lcd_exit);
 
MODULE_AUTHOR("Andrew Bose");
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [lcd.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
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			`#include <linux/types.h>`
15			`#include <linux/errno.h>`
16			`#include <linux/miscdevice.h>`
17			`#include <linux/slab.h>`
18			`#include <linux/ioport.h>`
19			`#include <linux/fcntl.h>`
20			`#include <linux/mc146818rtc.h>`
21			`#include <linux/netdevice.h>`
22			`#include <linux/sched.h>`
23			`#include <linux/delay.h>`
24
25			`#include <asm/io.h>`
26			`#include <asm/uaccess.h>`
27			`#include <asm/system.h>`
28
29			`#include "lcd.h"`
30
31			`static int lcd_ioctl(struct inode inode, struct file file,`
32			`unsigned int cmd, unsigned long arg);`
33
34			`static unsigned int lcd_present = 1;`
35
36			`/* used in arch/mips/cobalt/reset.c */`
37			`int led_state = 0;`
38
39			`#if defined(CONFIG_TULIP) && 0`
40
41			`#define MAX_INTERFACES 8`
42			`static linkcheck_func_t linkcheck_callbacks[MAX_INTERFACES];`
43			`static void *linkcheck_cookies[MAX_INTERFACES];`
44
45			`int lcd_register_linkcheck_func(int iface_num, void func, void cookie)`
46			`{`
47			`if (iface_num < 0 \|\|`
48			`iface_num >= MAX_INTERFACES \|\|`
49			`linkcheck_callbacks[iface_num] != NULL)`
50			`return -1;`
51			`linkcheck_callbacks[iface_num] = (linkcheck_func_t) func;`
52			`linkcheck_cookies[iface_num] = cookie;`
53			`return 0;`
54			`}`
55			`#endif`
56
57			`static int lcd_ioctl(struct inode inode, struct file file,`
58			`unsigned int cmd, unsigned long arg)`
59			`{`
60			`struct lcd_display button_display;`
61			`unsigned long address, a;`
62
63			`switch (cmd) {`
64			`case LCD_On:`
65			`udelay(150);`
66			`BusyCheck();`
67			`LCDWriteInst(0x0F);`
68			`break;`
69
70			`case LCD_Off:`
71			`udelay(150);`
72			`BusyCheck();`
73			`LCDWriteInst(0x08);`
74			`break;`
75
76			`case LCD_Reset:`
77			`udelay(150);`
78			`LCDWriteInst(0x3F);`
79			`udelay(150);`
80			`LCDWriteInst(0x3F);`
81			`udelay(150);`
82			`LCDWriteInst(0x3F);`
83			`udelay(150);`
84			`LCDWriteInst(0x3F);`
85			`udelay(150);`
86			`LCDWriteInst(0x01);`
87			`udelay(150);`
88			`LCDWriteInst(0x06);`
89			`break;`
90
91			`case LCD_Clear:`
92			`udelay(150);`
93			`BusyCheck();`
94			`LCDWriteInst(0x01);`
95			`break;`
96
97			`case LCD_Cursor_Left:`
98			`udelay(150);`
99			`BusyCheck();`
100			`LCDWriteInst(0x10);`
101			`break;`
102
103			`case LCD_Cursor_Right:`
104			`udelay(150);`
105			`BusyCheck();`
106			`LCDWriteInst(0x14);`
107			`break;`
108
109			`case LCD_Cursor_Off:`
110			`udelay(150);`
111			`BusyCheck();`
112			`LCDWriteInst(0x0C);`
113			`break;`
114
115			`case LCD_Cursor_On:`
116			`udelay(150);`
117			`BusyCheck();`
118			`LCDWriteInst(0x0F);`
119			`break;`
120
121			`case LCD_Blink_Off:`
122			`udelay(150);`
123			`BusyCheck();`
124			`LCDWriteInst(0x0E);`
125			`break;`
126
127			`case LCD_Get_Cursor_Pos:{`
128			`struct lcd_display display;`
129
130			`udelay(150);`
131			`BusyCheck();`
132			`display.cursor_address = (LCDReadInst);`
133			`display.cursor_address =`
134			`(display.cursor_address & 0x07F);`
135			`if (copy_to_user`
136			`((struct lcd_display *) arg, &display,`
137			`sizeof(struct lcd_display)))`
138			`return -EFAULT;`
139
140			`break;`
141			`}`
142
143
144			`case LCD_Set_Cursor_Pos:{`
145			`struct lcd_display display;`
146
147			`if (copy_from_user`
148			`(&display, (struct lcd_display *) arg,`
149			`sizeof(struct lcd_display)))`
150			`return -EFAULT;`
151
152			`a = (display.cursor_address \| kLCD_Addr);`
153
154			`udelay(150);`
155			`BusyCheck();`
156			`LCDWriteInst(a);`
157
158			`break;`
159			`}`
160
161			`case LCD_Get_Cursor:{`
162			`struct lcd_display display;`
163
164			`udelay(150);`
165			`BusyCheck();`
166			`display.character = LCDReadData;`
167
168			`if (copy_to_user`
169			`((struct lcd_display *) arg, &display,`
170			`sizeof(struct lcd_display)))`
171			`return -EFAULT;`
172			`udelay(150);`
173			`BusyCheck();`
174			`LCDWriteInst(0x10);`
175
176			`break;`
177			`}`
178
179			`case LCD_Set_Cursor:{`
180			`struct lcd_display display;`
181
182			`if (copy_from_user`
183			`(&display, (struct lcd_display *) arg,`
184			`sizeof(struct lcd_display)))`
185			`return -EFAULT;`
186
187			`udelay(150);`
188			`BusyCheck();`
189			`LCDWriteData(display.character);`
190			`udelay(150);`
191			`BusyCheck();`
192			`LCDWriteInst(0x10);`
193
194			`break;`
195			`}`
196
197
198			`case LCD_Disp_Left:`
199			`udelay(150);`
200			`BusyCheck();`
201			`LCDWriteInst(0x18);`
202			`break;`
203
204			`case LCD_Disp_Right:`
205			`udelay(150);`
206			`BusyCheck();`
207			`LCDWriteInst(0x1C);`
208			`break;`
209
210			`case LCD_Home:`
211			`udelay(150);`
212			`BusyCheck();`
213			`LCDWriteInst(0x02);`
214			`break;`
215
216			`case LCD_Write:{`
217			`struct lcd_display display;`
218			`unsigned int index;`
219
220
221			`if (copy_from_user`
222			`(&display, (struct lcd_display *) arg,`
223			`sizeof(struct lcd_display)))`
224			`return -EFAULT;`
225
226			`udelay(150);`
227			`BusyCheck();`
228			`LCDWriteInst(0x80);`
229			`udelay(150);`
230			`BusyCheck();`
231
232			`for (index = 0; index < (display.size1); index++) {`
233			`udelay(150);`
234			`BusyCheck();`
235			`LCDWriteData(display.line1[index]);`
236			`BusyCheck();`
237			`}`
238
239			`udelay(150);`
240			`BusyCheck();`
241			`LCDWriteInst(0xC0);`
242			`udelay(150);`
243			`BusyCheck();`
244			`for (index = 0; index < (display.size2); index++) {`
245			`udelay(150);`
246			`BusyCheck();`
247			`LCDWriteData(display.line2[index]);`
248			`}`
249
250			`break;`
251			`}`
252
253			`case LCD_Read:{`
254			`struct lcd_display display;`
255
256			`BusyCheck();`
257			`for (address = kDD_R00; address <= kDD_R01;`
258			`address++) {`
259			`a = (address \| kLCD_Addr);`
260
261			`udelay(150);`
262			`BusyCheck();`
263			`LCDWriteInst(a);`
264			`udelay(150);`
265			`BusyCheck();`
266			`display.line1[address] = LCDReadData;`
267			`}`
268
269			`display.line1[0x27] = '\0';`
270
271			`for (address = kDD_R10; address <= kDD_R11;`
272			`address++) {`
273			`a = (address \| kLCD_Addr);`
274
275			`udelay(150);`
276			`BusyCheck();`
277			`LCDWriteInst(a);`
278
279			`udelay(150);`
280			`BusyCheck();`
281			`display.line2[address - 0x40] =`
282			`LCDReadData;`
283			`}`
284
285			`display.line2[0x27] = '\0';`
286
287			`if (copy_to_user`
288			`((struct lcd_display *) arg, &display,`
289			`sizeof(struct lcd_display)))`
290			`return -EFAULT;`
291			`break;`
292			`}`
293
294			`// set all GPIO leds to led_display.leds`
295
296			`case LED_Set:{`
297			`struct lcd_display led_display;`
298
299
300			`if (copy_from_user`
301			`(&led_display, (struct lcd_display *) arg,`
302			`sizeof(struct lcd_display)))`
303			`return -EFAULT;`
304
305			`led_state = led_display.leds;`
306			`LEDSet(led_state);`
307
308			`break;`
309			`}`
310
311
312			`// set only bit led_display.leds`
313
314			`case LED_Bit_Set:{`
315			`unsigned int i;`
316			`int bit = 1;`
317			`struct lcd_display led_display;`
318
319
320			`if (copy_from_user`
321			`(&led_display, (struct lcd_display *) arg,`
322			`sizeof(struct lcd_display)))`
323			`return -EFAULT;`
324
325			`for (i = 0; i < (int) led_display.leds; i++) {`
326			`bit = 2 * bit;`
327			`}`
328
329			`led_state = led_state \| bit;`
330			`LEDSet(led_state);`
331			`break;`
332			`}`
333
334			`// clear only bit led_display.leds`
335
336			`case LED_Bit_Clear:{`
337			`unsigned int i;`
338			`int bit = 1;`
339			`struct lcd_display led_display;`
340
341
342			`if (copy_from_user`
343			`(&led_display, (struct lcd_display *) arg,`
344			`sizeof(struct lcd_display)))`
345			`return -EFAULT;`
346
347			`for (i = 0; i < (int) led_display.leds; i++) {`
348			`bit = 2 * bit;`
349			`}`
350
351			`led_state = led_state & ~bit;`
352			`LEDSet(led_state);`
353			`break;`
354			`}`
355
356
357			`case BUTTON_Read:{`
358			`button_display.buttons = GPIRead;`
359			`if (copy_to_user`
360			`((struct lcd_display *) arg, &button_display,`
361			`sizeof(struct lcd_display)))`
362			`return -EFAULT;`
363			`break;`
364			`}`
365
366			`case LINK_Check:{`
367			`button_display.buttons =`
368			`((volatile unsigned long ) (0xB0100060));`
369			`if (copy_to_user`
370			`((struct lcd_display *) arg, &button_display,`
371			`sizeof(struct lcd_display)))`
372			`return -EFAULT;`
373			`break;`
374			`}`
375
376			`case LINK_Check_2:{`
377			`int iface_num;`
378
379			`/* panel-utils should pass in the desired interface status is wanted for`
380			`* in "buttons" of the structure. We will set this to non-zero if the`
381			`* link is in fact up for the requested interface. --DaveM`
382			`*/`
383			`if (copy_from_user`
384			`(&button_display, (struct lcd_display *) arg,`
385			`sizeof(button_display)))`
386			`return -EFAULT;`
387			`iface_num = button_display.buttons;`
388			`#if defined(CONFIG_TULIP) && 0`
389			`if (iface_num >= 0 &&`
390			`iface_num < MAX_INTERFACES &&`
391			`linkcheck_callbacks[iface_num] != NULL) {`
392			`button_display.buttons =`
393			`linkcheck_callbacks[iface_num]`
394			`(linkcheck_cookies[iface_num]);`
395			`} else`
396			`#endif`
397			`button_display.buttons = 0;`
398
399			`if (__copy_to_user`
400			`((struct lcd_display *) arg, &button_display,`
401			`sizeof(struct lcd_display)))`
402			`return -EFAULT;`
403			`break;`
404			`}`
405
406			`default:`
407			`return -EINVAL;`
408
409			`}`
410
411			`return 0;`
412
413			`}`
414
415			`static int lcd_open(struct inode inode, struct file file)`
416			`{`
417			`if (!lcd_present)`
418			`return -ENXIO;`
419			`else`
420			`return 0;`
421			`}`
422
423			`/* Only RESET or NEXT counts as button pressed */`
424
425			`static inline int button_pressed(void)`
426			`{`
427			`unsigned long buttons = GPIRead;`
428
429			`if ((buttons == BUTTON_Next) \|\| (buttons == BUTTON_Next_B)`
430			`\|\| (buttons == BUTTON_Reset_B))`
431			`return buttons;`
432			`return 0;`
433			`}`
434
435			`/* LED daemon sits on this and we wake him up once a key is pressed. */`
436
437			`static int lcd_waiters = 0;`
438
439			`static ssize_t lcd_read(struct file file, char buf,`
440			`size_t count, loff_t *ofs)`
441			`{`
442			`long buttons_now;`
443
444			`if (lcd_waiters > 0)`
445			`return -EINVAL;`
446
447			`lcd_waiters++;`
448			`while (((buttons_now = (long) button_pressed()) == 0) &&`
449			`!(signal_pending(current))) {`
450			`msleep_interruptible(2000);`
451			`}`
452			`lcd_waiters--;`
453
454			`if (signal_pending(current))`
455			`return -ERESTARTSYS;`
456			`return buttons_now;`
457			`}`
458
459			`/*`
460			`* The various file operations we support.`
461			`*/`
462
463			`static const struct file_operations lcd_fops = {`
464			`.read = lcd_read,`
465			`.ioctl = lcd_ioctl,`
466			`.open = lcd_open,`
467			`};`
468
469			`static struct miscdevice lcd_dev = {`
470			`MISC_DYNAMIC_MINOR,`
471			`"lcd",`
472			`&lcd_fops`
473			`};`
474
475			`static int lcd_init(void)`
476			`{`
477			`int ret;`
478			`unsigned long data;`
479
480			`pr_info("%s\n", LCD_DRIVER);`
481			`ret = misc_register(&lcd_dev);`
482			`if (ret) {`
483			`printk(KERN_WARNING LCD "Unable to register misc device.\n");`
484			`return ret;`
485			`}`
486
487			`/* Check region? Naaah! Just snarf it up. */`
488			`/* request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/`
489
490			`udelay(150);`
491			`data = LCDReadData;`
492			`if ((data & 0x000000FF) == (0x00)) {`
493			`lcd_present = 0;`
494			`pr_info(LCD "LCD Not Present\n");`
495			`} else {`
496			`lcd_present = 1;`
497			`WRITE_GAL(kGal_DevBank2PReg, kGal_DevBank2Cfg);`
498			`WRITE_GAL(kGal_DevBank3PReg, kGal_DevBank3Cfg);`
499			`}`
500
501			`return 0;`
502			`}`
503
504			`static void __exit lcd_exit(void)`
505			`{`
506			`misc_deregister(&lcd_dev);`
507			`}`
508
509			`module_init(lcd_init);`
510			`module_exit(lcd_exit);`
511
512			`MODULE_AUTHOR("Andrew Bose");`
513			`MODULE_LICENSE("GPL");`