[linux-2.6-block.git] / drivers / char / lcd.c

/*
 * 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/smp_lock.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)
{
	cycle_kernel_lock();

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