]>
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(); |
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, |
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"); |