This source file includes following definitions.
- lcd_get_bits
- set_data_bits
- set_ctrl_bits
- panel_set_bits
- pin_to_bits
- lcd_send_serial
- lcd_backlight
- lcd_write_cmd_s
- lcd_write_data_s
- lcd_write_cmd_p8
- lcd_write_data_p8
- lcd_write_cmd_tilcd
- lcd_write_data_tilcd
- lcd_clear_fast_s
- lcd_clear_fast_p8
- lcd_clear_fast_tilcd
- lcd_init
- keypad_read
- keypad_open
- keypad_release
- keypad_send_key
- phys_scan_contacts
- input_state_high
- input_state_falling
- panel_process_inputs
- panel_scan_timer
- init_scan_timer
- input_name2mask
- panel_bind_key
- panel_bind_callback
- keypad_init
- panel_attach
- panel_detach
- panel_init_module
- panel_cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
35
36 #include <linux/module.h>
37
38 #include <linux/types.h>
39 #include <linux/errno.h>
40 #include <linux/signal.h>
41 #include <linux/sched.h>
42 #include <linux/spinlock.h>
43 #include <linux/interrupt.h>
44 #include <linux/miscdevice.h>
45 #include <linux/slab.h>
46 #include <linux/ioport.h>
47 #include <linux/fcntl.h>
48 #include <linux/init.h>
49 #include <linux/delay.h>
50 #include <linux/kernel.h>
51 #include <linux/ctype.h>
52 #include <linux/parport.h>
53 #include <linux/list.h>
54
55 #include <linux/io.h>
56 #include <linux/uaccess.h>
57
58 #include "charlcd.h"
59
60 #define KEYPAD_MINOR 185
61
62 #define LCD_MAXBYTES 256
63
64 #define KEYPAD_BUFFER 64
65
66
67 #define INPUT_POLL_TIME (HZ / 50)
68
69 #define KEYPAD_REP_START (10)
70
71 #define KEYPAD_REP_DELAY (2)
72
73
74 #define PNL_PINPUT(a) ((((unsigned char)(a)) ^ 0x7F) >> 3)
75
76 #define PNL_PBUSY 0x80
77 #define PNL_PACK 0x40
78 #define PNL_POUTPA 0x20
79 #define PNL_PSELECD 0x10
80 #define PNL_PERRORP 0x08
81
82 #define PNL_PBIDIR 0x20
83
84 #define PNL_PINTEN 0x10
85 #define PNL_PSELECP 0x08
86 #define PNL_PINITP 0x04
87 #define PNL_PAUTOLF 0x02
88 #define PNL_PSTROBE 0x01
89
90 #define PNL_PD0 0x01
91 #define PNL_PD1 0x02
92 #define PNL_PD2 0x04
93 #define PNL_PD3 0x08
94 #define PNL_PD4 0x10
95 #define PNL_PD5 0x20
96 #define PNL_PD6 0x40
97 #define PNL_PD7 0x80
98
99 #define PIN_NONE 0
100 #define PIN_STROBE 1
101 #define PIN_D0 2
102 #define PIN_D1 3
103 #define PIN_D2 4
104 #define PIN_D3 5
105 #define PIN_D4 6
106 #define PIN_D5 7
107 #define PIN_D6 8
108 #define PIN_D7 9
109 #define PIN_AUTOLF 14
110 #define PIN_INITP 16
111 #define PIN_SELECP 17
112 #define PIN_NOT_SET 127
113
114 #define NOT_SET -1
115
116
117 #define r_ctr(x) (parport_read_control((x)->port))
118 #define r_dtr(x) (parport_read_data((x)->port))
119 #define r_str(x) (parport_read_status((x)->port))
120 #define w_ctr(x, y) (parport_write_control((x)->port, (y)))
121 #define w_dtr(x, y) (parport_write_data((x)->port, (y)))
122
123
124
125 static __u8 scan_mask_o;
126
127 static __u8 scan_mask_i;
128
129 enum input_type {
130 INPUT_TYPE_STD,
131 INPUT_TYPE_KBD,
132 };
133
134 enum input_state {
135 INPUT_ST_LOW,
136 INPUT_ST_RISING,
137 INPUT_ST_HIGH,
138 INPUT_ST_FALLING,
139 };
140
141 struct logical_input {
142 struct list_head list;
143 __u64 mask;
144 __u64 value;
145 enum input_type type;
146 enum input_state state;
147 __u8 rise_time, fall_time;
148 __u8 rise_timer, fall_timer, high_timer;
149
150 union {
151 struct {
152 void (*press_fct)(int);
153 void (*release_fct)(int);
154 int press_data;
155 int release_data;
156 } std;
157 struct {
158 char press_str[sizeof(void *) + sizeof(int)] __nonstring;
159 char repeat_str[sizeof(void *) + sizeof(int)] __nonstring;
160 char release_str[sizeof(void *) + sizeof(int)] __nonstring;
161 } kbd;
162 } u;
163 };
164
165 static LIST_HEAD(logical_inputs);
166
167
168
169
170
171
172
173
174
175
176
177
178
179 static __u64 phys_read;
180
181 static __u64 phys_read_prev;
182
183 static __u64 phys_curr;
184
185 static __u64 phys_prev;
186
187 static char inputs_stable;
188
189
190 static struct {
191 bool enabled;
192 } keypad;
193
194 static char keypad_buffer[KEYPAD_BUFFER];
195 static int keypad_buflen;
196 static int keypad_start;
197 static char keypressed;
198 static wait_queue_head_t keypad_read_wait;
199
200
201 static struct {
202 bool enabled;
203 bool initialized;
204
205 int charset;
206 int proto;
207
208
209 struct {
210 int e;
211 int rs;
212 int rw;
213 int cl;
214 int da;
215 int bl;
216 } pins;
217
218 struct charlcd *charlcd;
219 } lcd;
220
221
222 static int selected_lcd_type = NOT_SET;
223
224
225
226
227
228
229 #define BIT_CLR 0
230 #define BIT_SET 1
231 #define BIT_MSK 2
232 #define BIT_STATES 3
233
234
235
236 #define LCD_BIT_E 0
237 #define LCD_BIT_RS 1
238 #define LCD_BIT_RW 2
239 #define LCD_BIT_BL 3
240 #define LCD_BIT_CL 4
241 #define LCD_BIT_DA 5
242 #define LCD_BITS 6
243
244
245
246
247 #define LCD_PORT_C 0
248 #define LCD_PORT_D 1
249 #define LCD_PORTS 2
250
251 static unsigned char lcd_bits[LCD_PORTS][LCD_BITS][BIT_STATES];
252
253
254
255
256 #define LCD_PROTO_PARALLEL 0
257 #define LCD_PROTO_SERIAL 1
258 #define LCD_PROTO_TI_DA8XX_LCD 2
259
260
261
262
263 #define LCD_CHARSET_NORMAL 0
264 #define LCD_CHARSET_KS0074 1
265
266
267
268
269 #define LCD_TYPE_NONE 0
270 #define LCD_TYPE_CUSTOM 1
271 #define LCD_TYPE_OLD 2
272 #define LCD_TYPE_KS0074 3
273 #define LCD_TYPE_HANTRONIX 4
274 #define LCD_TYPE_NEXCOM 5
275
276
277
278
279 #define KEYPAD_TYPE_NONE 0
280 #define KEYPAD_TYPE_OLD 1
281 #define KEYPAD_TYPE_NEW 2
282 #define KEYPAD_TYPE_NEXCOM 3
283
284
285
286
287 #define PANEL_PROFILE_CUSTOM 0
288 #define PANEL_PROFILE_OLD 1
289 #define PANEL_PROFILE_NEW 2
290 #define PANEL_PROFILE_HANTRONIX 3
291 #define PANEL_PROFILE_NEXCOM 4
292 #define PANEL_PROFILE_LARGE 5
293
294
295
296
297 #define DEFAULT_PARPORT 0
298 #define DEFAULT_PROFILE PANEL_PROFILE_LARGE
299 #define DEFAULT_KEYPAD_TYPE KEYPAD_TYPE_OLD
300 #define DEFAULT_LCD_TYPE LCD_TYPE_OLD
301 #define DEFAULT_LCD_HEIGHT 2
302 #define DEFAULT_LCD_WIDTH 40
303 #define DEFAULT_LCD_BWIDTH 40
304 #define DEFAULT_LCD_HWIDTH 64
305 #define DEFAULT_LCD_CHARSET LCD_CHARSET_NORMAL
306 #define DEFAULT_LCD_PROTO LCD_PROTO_PARALLEL
307
308 #define DEFAULT_LCD_PIN_E PIN_AUTOLF
309 #define DEFAULT_LCD_PIN_RS PIN_SELECP
310 #define DEFAULT_LCD_PIN_RW PIN_INITP
311 #define DEFAULT_LCD_PIN_SCL PIN_STROBE
312 #define DEFAULT_LCD_PIN_SDA PIN_D0
313 #define DEFAULT_LCD_PIN_BL PIN_NOT_SET
314
315 #ifdef CONFIG_PANEL_PARPORT
316 #undef DEFAULT_PARPORT
317 #define DEFAULT_PARPORT CONFIG_PANEL_PARPORT
318 #endif
319
320 #ifdef CONFIG_PANEL_PROFILE
321 #undef DEFAULT_PROFILE
322 #define DEFAULT_PROFILE CONFIG_PANEL_PROFILE
323 #endif
324
325 #if DEFAULT_PROFILE == 0
326 #ifdef CONFIG_PANEL_KEYPAD
327 #undef DEFAULT_KEYPAD_TYPE
328 #define DEFAULT_KEYPAD_TYPE CONFIG_PANEL_KEYPAD
329 #endif
330
331 #ifdef CONFIG_PANEL_LCD
332 #undef DEFAULT_LCD_TYPE
333 #define DEFAULT_LCD_TYPE CONFIG_PANEL_LCD
334 #endif
335
336 #ifdef CONFIG_PANEL_LCD_HEIGHT
337 #undef DEFAULT_LCD_HEIGHT
338 #define DEFAULT_LCD_HEIGHT CONFIG_PANEL_LCD_HEIGHT
339 #endif
340
341 #ifdef CONFIG_PANEL_LCD_WIDTH
342 #undef DEFAULT_LCD_WIDTH
343 #define DEFAULT_LCD_WIDTH CONFIG_PANEL_LCD_WIDTH
344 #endif
345
346 #ifdef CONFIG_PANEL_LCD_BWIDTH
347 #undef DEFAULT_LCD_BWIDTH
348 #define DEFAULT_LCD_BWIDTH CONFIG_PANEL_LCD_BWIDTH
349 #endif
350
351 #ifdef CONFIG_PANEL_LCD_HWIDTH
352 #undef DEFAULT_LCD_HWIDTH
353 #define DEFAULT_LCD_HWIDTH CONFIG_PANEL_LCD_HWIDTH
354 #endif
355
356 #ifdef CONFIG_PANEL_LCD_CHARSET
357 #undef DEFAULT_LCD_CHARSET
358 #define DEFAULT_LCD_CHARSET CONFIG_PANEL_LCD_CHARSET
359 #endif
360
361 #ifdef CONFIG_PANEL_LCD_PROTO
362 #undef DEFAULT_LCD_PROTO
363 #define DEFAULT_LCD_PROTO CONFIG_PANEL_LCD_PROTO
364 #endif
365
366 #ifdef CONFIG_PANEL_LCD_PIN_E
367 #undef DEFAULT_LCD_PIN_E
368 #define DEFAULT_LCD_PIN_E CONFIG_PANEL_LCD_PIN_E
369 #endif
370
371 #ifdef CONFIG_PANEL_LCD_PIN_RS
372 #undef DEFAULT_LCD_PIN_RS
373 #define DEFAULT_LCD_PIN_RS CONFIG_PANEL_LCD_PIN_RS
374 #endif
375
376 #ifdef CONFIG_PANEL_LCD_PIN_RW
377 #undef DEFAULT_LCD_PIN_RW
378 #define DEFAULT_LCD_PIN_RW CONFIG_PANEL_LCD_PIN_RW
379 #endif
380
381 #ifdef CONFIG_PANEL_LCD_PIN_SCL
382 #undef DEFAULT_LCD_PIN_SCL
383 #define DEFAULT_LCD_PIN_SCL CONFIG_PANEL_LCD_PIN_SCL
384 #endif
385
386 #ifdef CONFIG_PANEL_LCD_PIN_SDA
387 #undef DEFAULT_LCD_PIN_SDA
388 #define DEFAULT_LCD_PIN_SDA CONFIG_PANEL_LCD_PIN_SDA
389 #endif
390
391 #ifdef CONFIG_PANEL_LCD_PIN_BL
392 #undef DEFAULT_LCD_PIN_BL
393 #define DEFAULT_LCD_PIN_BL CONFIG_PANEL_LCD_PIN_BL
394 #endif
395
396 #endif
397
398
399
400
401 static atomic_t keypad_available = ATOMIC_INIT(1);
402
403 static struct pardevice *pprt;
404
405 static int keypad_initialized;
406
407 static DEFINE_SPINLOCK(pprt_lock);
408 static struct timer_list scan_timer;
409
410 MODULE_DESCRIPTION("Generic parallel port LCD/Keypad driver");
411
412 static int parport = DEFAULT_PARPORT;
413 module_param(parport, int, 0000);
414 MODULE_PARM_DESC(parport, "Parallel port index (0=lpt1, 1=lpt2, ...)");
415
416 static int profile = DEFAULT_PROFILE;
417 module_param(profile, int, 0000);
418 MODULE_PARM_DESC(profile,
419 "1=16x2 old kp; 2=serial 16x2, new kp; 3=16x2 hantronix; "
420 "4=16x2 nexcom; default=40x2, old kp");
421
422 static int keypad_type = NOT_SET;
423 module_param(keypad_type, int, 0000);
424 MODULE_PARM_DESC(keypad_type,
425 "Keypad type: 0=none, 1=old 6 keys, 2=new 6+1 keys, 3=nexcom 4 keys");
426
427 static int lcd_type = NOT_SET;
428 module_param(lcd_type, int, 0000);
429 MODULE_PARM_DESC(lcd_type,
430 "LCD type: 0=none, 1=compiled-in, 2=old, 3=serial ks0074, 4=hantronix, 5=nexcom");
431
432 static int lcd_height = NOT_SET;
433 module_param(lcd_height, int, 0000);
434 MODULE_PARM_DESC(lcd_height, "Number of lines on the LCD");
435
436 static int lcd_width = NOT_SET;
437 module_param(lcd_width, int, 0000);
438 MODULE_PARM_DESC(lcd_width, "Number of columns on the LCD");
439
440 static int lcd_bwidth = NOT_SET;
441 module_param(lcd_bwidth, int, 0000);
442 MODULE_PARM_DESC(lcd_bwidth, "Internal LCD line width (40)");
443
444 static int lcd_hwidth = NOT_SET;
445 module_param(lcd_hwidth, int, 0000);
446 MODULE_PARM_DESC(lcd_hwidth, "LCD line hardware address (64)");
447
448 static int lcd_charset = NOT_SET;
449 module_param(lcd_charset, int, 0000);
450 MODULE_PARM_DESC(lcd_charset, "LCD character set: 0=standard, 1=KS0074");
451
452 static int lcd_proto = NOT_SET;
453 module_param(lcd_proto, int, 0000);
454 MODULE_PARM_DESC(lcd_proto,
455 "LCD communication: 0=parallel (//), 1=serial, 2=TI LCD Interface");
456
457
458
459
460
461
462
463
464
465
466 static int lcd_e_pin = PIN_NOT_SET;
467 module_param(lcd_e_pin, int, 0000);
468 MODULE_PARM_DESC(lcd_e_pin,
469 "# of the // port pin connected to LCD 'E' signal, with polarity (-17..17)");
470
471 static int lcd_rs_pin = PIN_NOT_SET;
472 module_param(lcd_rs_pin, int, 0000);
473 MODULE_PARM_DESC(lcd_rs_pin,
474 "# of the // port pin connected to LCD 'RS' signal, with polarity (-17..17)");
475
476 static int lcd_rw_pin = PIN_NOT_SET;
477 module_param(lcd_rw_pin, int, 0000);
478 MODULE_PARM_DESC(lcd_rw_pin,
479 "# of the // port pin connected to LCD 'RW' signal, with polarity (-17..17)");
480
481 static int lcd_cl_pin = PIN_NOT_SET;
482 module_param(lcd_cl_pin, int, 0000);
483 MODULE_PARM_DESC(lcd_cl_pin,
484 "# of the // port pin connected to serial LCD 'SCL' signal, with polarity (-17..17)");
485
486 static int lcd_da_pin = PIN_NOT_SET;
487 module_param(lcd_da_pin, int, 0000);
488 MODULE_PARM_DESC(lcd_da_pin,
489 "# of the // port pin connected to serial LCD 'SDA' signal, with polarity (-17..17)");
490
491 static int lcd_bl_pin = PIN_NOT_SET;
492 module_param(lcd_bl_pin, int, 0000);
493 MODULE_PARM_DESC(lcd_bl_pin,
494 "# of the // port pin connected to LCD backlight, with polarity (-17..17)");
495
496
497
498 static int lcd_enabled = NOT_SET;
499 module_param(lcd_enabled, int, 0000);
500 MODULE_PARM_DESC(lcd_enabled, "Deprecated option, use lcd_type instead");
501
502 static int keypad_enabled = NOT_SET;
503 module_param(keypad_enabled, int, 0000);
504 MODULE_PARM_DESC(keypad_enabled, "Deprecated option, use keypad_type instead");
505
506
507 static const unsigned char lcd_char_conv_ks0074[256] = {
508
509 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
510 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
511 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
512 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
513 0x20, 0x21, 0x22, 0x23, 0xa2, 0x25, 0x26, 0x27,
514 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
515 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
516 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
517 0xa0, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
518 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
519 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
520 0x58, 0x59, 0x5a, 0xfa, 0xfb, 0xfc, 0x1d, 0xc4,
521 0x96, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
522 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
523 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
524 0x78, 0x79, 0x7a, 0xfd, 0xfe, 0xff, 0xce, 0x20,
525 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
526 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
527 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
528 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
529 0x20, 0x40, 0xb1, 0xa1, 0x24, 0xa3, 0xfe, 0x5f,
530 0x22, 0xc8, 0x61, 0x14, 0x97, 0x2d, 0xad, 0x96,
531 0x80, 0x8c, 0x82, 0x83, 0x27, 0x8f, 0x86, 0xdd,
532 0x2c, 0x81, 0x6f, 0x15, 0x8b, 0x8a, 0x84, 0x60,
533 0xe2, 0xe2, 0xe2, 0x5b, 0x5b, 0xae, 0xbc, 0xa9,
534 0xc5, 0xbf, 0xc6, 0xf1, 0xe3, 0xe3, 0xe3, 0xe3,
535 0x44, 0x5d, 0xa8, 0xe4, 0xec, 0xec, 0x5c, 0x78,
536 0xab, 0xa6, 0xe5, 0x5e, 0x5e, 0xe6, 0xaa, 0xbe,
537 0x7f, 0xe7, 0xaf, 0x7b, 0x7b, 0xaf, 0xbd, 0xc8,
538 0xa4, 0xa5, 0xc7, 0xf6, 0xa7, 0xe8, 0x69, 0x69,
539 0xed, 0x7d, 0xa8, 0xe4, 0xec, 0x5c, 0x5c, 0x25,
540 0xac, 0xa6, 0xea, 0xef, 0x7e, 0xeb, 0xb2, 0x79,
541 };
542
543 static const char old_keypad_profile[][4][9] = {
544 {"S0", "Left\n", "Left\n", ""},
545 {"S1", "Down\n", "Down\n", ""},
546 {"S2", "Up\n", "Up\n", ""},
547 {"S3", "Right\n", "Right\n", ""},
548 {"S4", "Esc\n", "Esc\n", ""},
549 {"S5", "Ret\n", "Ret\n", ""},
550 {"", "", "", ""}
551 };
552
553
554 static const char new_keypad_profile[][4][9] = {
555 {"S0", "Left\n", "Left\n", ""},
556 {"S1", "Down\n", "Down\n", ""},
557 {"S2", "Up\n", "Up\n", ""},
558 {"S3", "Right\n", "Right\n", ""},
559 {"S4s5", "", "Esc\n", "Esc\n"},
560 {"s4S5", "", "Ret\n", "Ret\n"},
561 {"S4S5", "Help\n", "", ""},
562
563 {"", "", "", ""}
564 };
565
566
567 static const char nexcom_keypad_profile[][4][9] = {
568 {"a-p-e-", "Down\n", "Down\n", ""},
569 {"a-p-E-", "Ret\n", "Ret\n", ""},
570 {"a-P-E-", "Esc\n", "Esc\n", ""},
571 {"a-P-e-", "Up\n", "Up\n", ""},
572
573 {"", "", "", ""}
574 };
575
576 static const char (*keypad_profile)[4][9] = old_keypad_profile;
577
578 static DECLARE_BITMAP(bits, LCD_BITS);
579
580 static void lcd_get_bits(unsigned int port, int *val)
581 {
582 unsigned int bit, state;
583
584 for (bit = 0; bit < LCD_BITS; bit++) {
585 state = test_bit(bit, bits) ? BIT_SET : BIT_CLR;
586 *val &= lcd_bits[port][bit][BIT_MSK];
587 *val |= lcd_bits[port][bit][state];
588 }
589 }
590
591
592 static int set_data_bits(void)
593 {
594 int val;
595
596 val = r_dtr(pprt);
597 lcd_get_bits(LCD_PORT_D, &val);
598 w_dtr(pprt, val);
599 return val;
600 }
601
602
603 static int set_ctrl_bits(void)
604 {
605 int val;
606
607 val = r_ctr(pprt);
608 lcd_get_bits(LCD_PORT_C, &val);
609 w_ctr(pprt, val);
610 return val;
611 }
612
613
614 static void panel_set_bits(void)
615 {
616 set_data_bits();
617 set_ctrl_bits();
618 }
619
620
621
622
623
624
625
626
627
628
629 static void pin_to_bits(int pin, unsigned char *d_val, unsigned char *c_val)
630 {
631 int d_bit, c_bit, inv;
632
633 d_val[0] = 0;
634 c_val[0] = 0;
635 d_val[1] = 0;
636 c_val[1] = 0;
637 d_val[2] = 0xFF;
638 c_val[2] = 0xFF;
639
640 if (pin == 0)
641 return;
642
643 inv = (pin < 0);
644 if (inv)
645 pin = -pin;
646
647 d_bit = 0;
648 c_bit = 0;
649
650 switch (pin) {
651 case PIN_STROBE:
652 c_bit = PNL_PSTROBE;
653 inv = !inv;
654 break;
655 case PIN_D0...PIN_D7:
656 d_bit = 1 << (pin - 2);
657 break;
658 case PIN_AUTOLF:
659 c_bit = PNL_PAUTOLF;
660 inv = !inv;
661 break;
662 case PIN_INITP:
663 c_bit = PNL_PINITP;
664 break;
665 case PIN_SELECP:
666 c_bit = PNL_PSELECP;
667 inv = !inv;
668 break;
669 default:
670 break;
671 }
672
673 if (c_bit) {
674 c_val[2] &= ~c_bit;
675 c_val[!inv] = c_bit;
676 } else if (d_bit) {
677 d_val[2] &= ~d_bit;
678 d_val[!inv] = d_bit;
679 }
680 }
681
682
683
684
685
686 static void lcd_send_serial(int byte)
687 {
688 int bit;
689
690
691
692
693
694 for (bit = 0; bit < 8; bit++) {
695 clear_bit(LCD_BIT_CL, bits);
696 panel_set_bits();
697 if (byte & 1) {
698 set_bit(LCD_BIT_DA, bits);
699 } else {
700 clear_bit(LCD_BIT_DA, bits);
701 }
702
703 panel_set_bits();
704 udelay(2);
705 set_bit(LCD_BIT_CL, bits);
706 panel_set_bits();
707 udelay(1);
708 byte >>= 1;
709 }
710 }
711
712
713 static void lcd_backlight(struct charlcd *charlcd, int on)
714 {
715 if (lcd.pins.bl == PIN_NONE)
716 return;
717
718
719 spin_lock_irq(&pprt_lock);
720 if (on)
721 set_bit(LCD_BIT_BL, bits);
722 else
723 clear_bit(LCD_BIT_BL, bits);
724 panel_set_bits();
725 spin_unlock_irq(&pprt_lock);
726 }
727
728
729 static void lcd_write_cmd_s(struct charlcd *charlcd, int cmd)
730 {
731 spin_lock_irq(&pprt_lock);
732 lcd_send_serial(0x1F);
733 lcd_send_serial(cmd & 0x0F);
734 lcd_send_serial((cmd >> 4) & 0x0F);
735 udelay(40);
736 spin_unlock_irq(&pprt_lock);
737 }
738
739
740 static void lcd_write_data_s(struct charlcd *charlcd, int data)
741 {
742 spin_lock_irq(&pprt_lock);
743 lcd_send_serial(0x5F);
744 lcd_send_serial(data & 0x0F);
745 lcd_send_serial((data >> 4) & 0x0F);
746 udelay(40);
747 spin_unlock_irq(&pprt_lock);
748 }
749
750
751 static void lcd_write_cmd_p8(struct charlcd *charlcd, int cmd)
752 {
753 spin_lock_irq(&pprt_lock);
754
755 w_dtr(pprt, cmd);
756 udelay(20);
757
758 set_bit(LCD_BIT_E, bits);
759 clear_bit(LCD_BIT_RS, bits);
760 clear_bit(LCD_BIT_RW, bits);
761 set_ctrl_bits();
762
763 udelay(40);
764
765 clear_bit(LCD_BIT_E, bits);
766 set_ctrl_bits();
767
768 udelay(120);
769 spin_unlock_irq(&pprt_lock);
770 }
771
772
773 static void lcd_write_data_p8(struct charlcd *charlcd, int data)
774 {
775 spin_lock_irq(&pprt_lock);
776
777 w_dtr(pprt, data);
778 udelay(20);
779
780 set_bit(LCD_BIT_E, bits);
781 set_bit(LCD_BIT_RS, bits);
782 clear_bit(LCD_BIT_RW, bits);
783 set_ctrl_bits();
784
785 udelay(40);
786
787 clear_bit(LCD_BIT_E, bits);
788 set_ctrl_bits();
789
790 udelay(45);
791 spin_unlock_irq(&pprt_lock);
792 }
793
794
795 static void lcd_write_cmd_tilcd(struct charlcd *charlcd, int cmd)
796 {
797 spin_lock_irq(&pprt_lock);
798
799 w_ctr(pprt, cmd);
800 udelay(60);
801 spin_unlock_irq(&pprt_lock);
802 }
803
804
805 static void lcd_write_data_tilcd(struct charlcd *charlcd, int data)
806 {
807 spin_lock_irq(&pprt_lock);
808
809 w_dtr(pprt, data);
810 udelay(60);
811 spin_unlock_irq(&pprt_lock);
812 }
813
814
815 static void lcd_clear_fast_s(struct charlcd *charlcd)
816 {
817 int pos;
818
819 spin_lock_irq(&pprt_lock);
820 for (pos = 0; pos < charlcd->height * charlcd->hwidth; pos++) {
821 lcd_send_serial(0x5F);
822 lcd_send_serial(' ' & 0x0F);
823 lcd_send_serial((' ' >> 4) & 0x0F);
824
825 udelay(40);
826 }
827 spin_unlock_irq(&pprt_lock);
828 }
829
830
831 static void lcd_clear_fast_p8(struct charlcd *charlcd)
832 {
833 int pos;
834
835 spin_lock_irq(&pprt_lock);
836 for (pos = 0; pos < charlcd->height * charlcd->hwidth; pos++) {
837
838 w_dtr(pprt, ' ');
839
840
841 udelay(20);
842
843 set_bit(LCD_BIT_E, bits);
844 set_bit(LCD_BIT_RS, bits);
845 clear_bit(LCD_BIT_RW, bits);
846 set_ctrl_bits();
847
848
849 udelay(40);
850
851 clear_bit(LCD_BIT_E, bits);
852 set_ctrl_bits();
853
854
855 udelay(45);
856 }
857 spin_unlock_irq(&pprt_lock);
858 }
859
860
861 static void lcd_clear_fast_tilcd(struct charlcd *charlcd)
862 {
863 int pos;
864
865 spin_lock_irq(&pprt_lock);
866 for (pos = 0; pos < charlcd->height * charlcd->hwidth; pos++) {
867
868 w_dtr(pprt, ' ');
869 udelay(60);
870 }
871
872 spin_unlock_irq(&pprt_lock);
873 }
874
875 static const struct charlcd_ops charlcd_serial_ops = {
876 .write_cmd = lcd_write_cmd_s,
877 .write_data = lcd_write_data_s,
878 .clear_fast = lcd_clear_fast_s,
879 .backlight = lcd_backlight,
880 };
881
882 static const struct charlcd_ops charlcd_parallel_ops = {
883 .write_cmd = lcd_write_cmd_p8,
884 .write_data = lcd_write_data_p8,
885 .clear_fast = lcd_clear_fast_p8,
886 .backlight = lcd_backlight,
887 };
888
889 static const struct charlcd_ops charlcd_tilcd_ops = {
890 .write_cmd = lcd_write_cmd_tilcd,
891 .write_data = lcd_write_data_tilcd,
892 .clear_fast = lcd_clear_fast_tilcd,
893 .backlight = lcd_backlight,
894 };
895
896
897 static void lcd_init(void)
898 {
899 struct charlcd *charlcd;
900
901 charlcd = charlcd_alloc(0);
902 if (!charlcd)
903 return;
904
905
906
907
908
909 charlcd->height = lcd_height;
910 charlcd->width = lcd_width;
911 charlcd->bwidth = lcd_bwidth;
912 charlcd->hwidth = lcd_hwidth;
913
914 switch (selected_lcd_type) {
915 case LCD_TYPE_OLD:
916
917 lcd.proto = LCD_PROTO_PARALLEL;
918 lcd.charset = LCD_CHARSET_NORMAL;
919 lcd.pins.e = PIN_STROBE;
920 lcd.pins.rs = PIN_AUTOLF;
921
922 charlcd->width = 40;
923 charlcd->bwidth = 40;
924 charlcd->hwidth = 64;
925 charlcd->height = 2;
926 break;
927 case LCD_TYPE_KS0074:
928
929 lcd.proto = LCD_PROTO_SERIAL;
930 lcd.charset = LCD_CHARSET_KS0074;
931 lcd.pins.bl = PIN_AUTOLF;
932 lcd.pins.cl = PIN_STROBE;
933 lcd.pins.da = PIN_D0;
934
935 charlcd->width = 16;
936 charlcd->bwidth = 40;
937 charlcd->hwidth = 16;
938 charlcd->height = 2;
939 break;
940 case LCD_TYPE_NEXCOM:
941
942 lcd.proto = LCD_PROTO_PARALLEL;
943 lcd.charset = LCD_CHARSET_NORMAL;
944 lcd.pins.e = PIN_AUTOLF;
945 lcd.pins.rs = PIN_SELECP;
946 lcd.pins.rw = PIN_INITP;
947
948 charlcd->width = 16;
949 charlcd->bwidth = 40;
950 charlcd->hwidth = 64;
951 charlcd->height = 2;
952 break;
953 case LCD_TYPE_CUSTOM:
954
955 lcd.proto = DEFAULT_LCD_PROTO;
956 lcd.charset = DEFAULT_LCD_CHARSET;
957
958 break;
959 case LCD_TYPE_HANTRONIX:
960
961 default:
962 lcd.proto = LCD_PROTO_PARALLEL;
963 lcd.charset = LCD_CHARSET_NORMAL;
964 lcd.pins.e = PIN_STROBE;
965 lcd.pins.rs = PIN_SELECP;
966
967 charlcd->width = 16;
968 charlcd->bwidth = 40;
969 charlcd->hwidth = 64;
970 charlcd->height = 2;
971 break;
972 }
973
974
975 if (lcd_height != NOT_SET)
976 charlcd->height = lcd_height;
977 if (lcd_width != NOT_SET)
978 charlcd->width = lcd_width;
979 if (lcd_bwidth != NOT_SET)
980 charlcd->bwidth = lcd_bwidth;
981 if (lcd_hwidth != NOT_SET)
982 charlcd->hwidth = lcd_hwidth;
983 if (lcd_charset != NOT_SET)
984 lcd.charset = lcd_charset;
985 if (lcd_proto != NOT_SET)
986 lcd.proto = lcd_proto;
987 if (lcd_e_pin != PIN_NOT_SET)
988 lcd.pins.e = lcd_e_pin;
989 if (lcd_rs_pin != PIN_NOT_SET)
990 lcd.pins.rs = lcd_rs_pin;
991 if (lcd_rw_pin != PIN_NOT_SET)
992 lcd.pins.rw = lcd_rw_pin;
993 if (lcd_cl_pin != PIN_NOT_SET)
994 lcd.pins.cl = lcd_cl_pin;
995 if (lcd_da_pin != PIN_NOT_SET)
996 lcd.pins.da = lcd_da_pin;
997 if (lcd_bl_pin != PIN_NOT_SET)
998 lcd.pins.bl = lcd_bl_pin;
999
1000
1001 if (charlcd->width <= 0)
1002 charlcd->width = DEFAULT_LCD_WIDTH;
1003 if (charlcd->bwidth <= 0)
1004 charlcd->bwidth = DEFAULT_LCD_BWIDTH;
1005 if (charlcd->hwidth <= 0)
1006 charlcd->hwidth = DEFAULT_LCD_HWIDTH;
1007 if (charlcd->height <= 0)
1008 charlcd->height = DEFAULT_LCD_HEIGHT;
1009
1010 if (lcd.proto == LCD_PROTO_SERIAL) {
1011 charlcd->ops = &charlcd_serial_ops;
1012
1013 if (lcd.pins.cl == PIN_NOT_SET)
1014 lcd.pins.cl = DEFAULT_LCD_PIN_SCL;
1015 if (lcd.pins.da == PIN_NOT_SET)
1016 lcd.pins.da = DEFAULT_LCD_PIN_SDA;
1017
1018 } else if (lcd.proto == LCD_PROTO_PARALLEL) {
1019 charlcd->ops = &charlcd_parallel_ops;
1020
1021 if (lcd.pins.e == PIN_NOT_SET)
1022 lcd.pins.e = DEFAULT_LCD_PIN_E;
1023 if (lcd.pins.rs == PIN_NOT_SET)
1024 lcd.pins.rs = DEFAULT_LCD_PIN_RS;
1025 if (lcd.pins.rw == PIN_NOT_SET)
1026 lcd.pins.rw = DEFAULT_LCD_PIN_RW;
1027 } else {
1028 charlcd->ops = &charlcd_tilcd_ops;
1029 }
1030
1031 if (lcd.pins.bl == PIN_NOT_SET)
1032 lcd.pins.bl = DEFAULT_LCD_PIN_BL;
1033
1034 if (lcd.pins.e == PIN_NOT_SET)
1035 lcd.pins.e = PIN_NONE;
1036 if (lcd.pins.rs == PIN_NOT_SET)
1037 lcd.pins.rs = PIN_NONE;
1038 if (lcd.pins.rw == PIN_NOT_SET)
1039 lcd.pins.rw = PIN_NONE;
1040 if (lcd.pins.bl == PIN_NOT_SET)
1041 lcd.pins.bl = PIN_NONE;
1042 if (lcd.pins.cl == PIN_NOT_SET)
1043 lcd.pins.cl = PIN_NONE;
1044 if (lcd.pins.da == PIN_NOT_SET)
1045 lcd.pins.da = PIN_NONE;
1046
1047 if (lcd.charset == NOT_SET)
1048 lcd.charset = DEFAULT_LCD_CHARSET;
1049
1050 if (lcd.charset == LCD_CHARSET_KS0074)
1051 charlcd->char_conv = lcd_char_conv_ks0074;
1052 else
1053 charlcd->char_conv = NULL;
1054
1055 pin_to_bits(lcd.pins.e, lcd_bits[LCD_PORT_D][LCD_BIT_E],
1056 lcd_bits[LCD_PORT_C][LCD_BIT_E]);
1057 pin_to_bits(lcd.pins.rs, lcd_bits[LCD_PORT_D][LCD_BIT_RS],
1058 lcd_bits[LCD_PORT_C][LCD_BIT_RS]);
1059 pin_to_bits(lcd.pins.rw, lcd_bits[LCD_PORT_D][LCD_BIT_RW],
1060 lcd_bits[LCD_PORT_C][LCD_BIT_RW]);
1061 pin_to_bits(lcd.pins.bl, lcd_bits[LCD_PORT_D][LCD_BIT_BL],
1062 lcd_bits[LCD_PORT_C][LCD_BIT_BL]);
1063 pin_to_bits(lcd.pins.cl, lcd_bits[LCD_PORT_D][LCD_BIT_CL],
1064 lcd_bits[LCD_PORT_C][LCD_BIT_CL]);
1065 pin_to_bits(lcd.pins.da, lcd_bits[LCD_PORT_D][LCD_BIT_DA],
1066 lcd_bits[LCD_PORT_C][LCD_BIT_DA]);
1067
1068 lcd.charlcd = charlcd;
1069 lcd.initialized = true;
1070 }
1071
1072
1073
1074
1075
1076 static ssize_t keypad_read(struct file *file,
1077 char __user *buf, size_t count, loff_t *ppos)
1078 {
1079 unsigned i = *ppos;
1080 char __user *tmp = buf;
1081
1082 if (keypad_buflen == 0) {
1083 if (file->f_flags & O_NONBLOCK)
1084 return -EAGAIN;
1085
1086 if (wait_event_interruptible(keypad_read_wait,
1087 keypad_buflen != 0))
1088 return -EINTR;
1089 }
1090
1091 for (; count-- > 0 && (keypad_buflen > 0);
1092 ++i, ++tmp, --keypad_buflen) {
1093 put_user(keypad_buffer[keypad_start], tmp);
1094 keypad_start = (keypad_start + 1) % KEYPAD_BUFFER;
1095 }
1096 *ppos = i;
1097
1098 return tmp - buf;
1099 }
1100
1101 static int keypad_open(struct inode *inode, struct file *file)
1102 {
1103 int ret;
1104
1105 ret = -EBUSY;
1106 if (!atomic_dec_and_test(&keypad_available))
1107 goto fail;
1108
1109 ret = -EPERM;
1110 if (file->f_mode & FMODE_WRITE)
1111 goto fail;
1112
1113 keypad_buflen = 0;
1114 return 0;
1115 fail:
1116 atomic_inc(&keypad_available);
1117 return ret;
1118 }
1119
1120 static int keypad_release(struct inode *inode, struct file *file)
1121 {
1122 atomic_inc(&keypad_available);
1123 return 0;
1124 }
1125
1126 static const struct file_operations keypad_fops = {
1127 .read = keypad_read,
1128 .open = keypad_open,
1129 .release = keypad_release,
1130 .llseek = default_llseek,
1131 };
1132
1133 static struct miscdevice keypad_dev = {
1134 .minor = KEYPAD_MINOR,
1135 .name = "keypad",
1136 .fops = &keypad_fops,
1137 };
1138
1139 static void keypad_send_key(const char *string, int max_len)
1140 {
1141
1142 if (!atomic_read(&keypad_available)) {
1143 while (max_len-- && keypad_buflen < KEYPAD_BUFFER && *string) {
1144 keypad_buffer[(keypad_start + keypad_buflen++) %
1145 KEYPAD_BUFFER] = *string++;
1146 }
1147 wake_up_interruptible(&keypad_read_wait);
1148 }
1149 }
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161 static void phys_scan_contacts(void)
1162 {
1163 int bit, bitval;
1164 char oldval;
1165 char bitmask;
1166 char gndmask;
1167
1168 phys_prev = phys_curr;
1169 phys_read_prev = phys_read;
1170 phys_read = 0;
1171
1172
1173 oldval = r_dtr(pprt) | scan_mask_o;
1174
1175 w_dtr(pprt, oldval & ~scan_mask_o);
1176
1177
1178 bitmask = PNL_PINPUT(r_str(pprt)) & scan_mask_i;
1179
1180 w_dtr(pprt, oldval);
1181
1182
1183
1184
1185
1186
1187 gndmask = PNL_PINPUT(r_str(pprt)) & scan_mask_i;
1188
1189
1190 phys_read |= (__u64)gndmask << 40;
1191
1192 if (bitmask != gndmask) {
1193
1194
1195
1196
1197
1198 for (bit = 0; bit < 8; bit++) {
1199 bitval = BIT(bit);
1200
1201 if (!(scan_mask_o & bitval))
1202 continue;
1203
1204 w_dtr(pprt, oldval & ~bitval);
1205 bitmask = PNL_PINPUT(r_str(pprt)) & ~gndmask;
1206 phys_read |= (__u64)bitmask << (5 * bit);
1207 }
1208 w_dtr(pprt, oldval);
1209 }
1210
1211
1212
1213
1214 phys_curr = (phys_prev & (phys_read ^ phys_read_prev)) |
1215 (phys_read & ~(phys_read ^ phys_read_prev));
1216 }
1217
1218 static inline int input_state_high(struct logical_input *input)
1219 {
1220 #if 0
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238 if (((phys_prev & input->mask) == input->value) &&
1239 ((phys_curr & input->mask) > input->value)) {
1240 input->state = INPUT_ST_LOW;
1241 return 1;
1242 }
1243 #endif
1244
1245 if ((phys_curr & input->mask) == input->value) {
1246 if ((input->type == INPUT_TYPE_STD) &&
1247 (input->high_timer == 0)) {
1248 input->high_timer++;
1249 if (input->u.std.press_fct)
1250 input->u.std.press_fct(input->u.std.press_data);
1251 } else if (input->type == INPUT_TYPE_KBD) {
1252
1253 keypressed = 1;
1254
1255 if (input->high_timer == 0) {
1256 char *press_str = input->u.kbd.press_str;
1257
1258 if (press_str[0]) {
1259 int s = sizeof(input->u.kbd.press_str);
1260
1261 keypad_send_key(press_str, s);
1262 }
1263 }
1264
1265 if (input->u.kbd.repeat_str[0]) {
1266 char *repeat_str = input->u.kbd.repeat_str;
1267
1268 if (input->high_timer >= KEYPAD_REP_START) {
1269 int s = sizeof(input->u.kbd.repeat_str);
1270
1271 input->high_timer -= KEYPAD_REP_DELAY;
1272 keypad_send_key(repeat_str, s);
1273 }
1274
1275 inputs_stable = 0;
1276 }
1277
1278 if (input->high_timer < 255)
1279 input->high_timer++;
1280 }
1281 return 1;
1282 }
1283
1284
1285 input->state = INPUT_ST_FALLING;
1286 input->fall_timer = 0;
1287
1288 return 0;
1289 }
1290
1291 static inline void input_state_falling(struct logical_input *input)
1292 {
1293 #if 0
1294
1295 if (((phys_prev & input->mask) == input->value) &&
1296 ((phys_curr & input->mask) > input->value)) {
1297 input->state = INPUT_ST_LOW;
1298 return;
1299 }
1300 #endif
1301
1302 if ((phys_curr & input->mask) == input->value) {
1303 if (input->type == INPUT_TYPE_KBD) {
1304
1305 keypressed = 1;
1306
1307 if (input->u.kbd.repeat_str[0]) {
1308 char *repeat_str = input->u.kbd.repeat_str;
1309
1310 if (input->high_timer >= KEYPAD_REP_START) {
1311 int s = sizeof(input->u.kbd.repeat_str);
1312
1313 input->high_timer -= KEYPAD_REP_DELAY;
1314 keypad_send_key(repeat_str, s);
1315 }
1316
1317 inputs_stable = 0;
1318 }
1319
1320 if (input->high_timer < 255)
1321 input->high_timer++;
1322 }
1323 input->state = INPUT_ST_HIGH;
1324 } else if (input->fall_timer >= input->fall_time) {
1325
1326 if (input->type == INPUT_TYPE_STD) {
1327 void (*release_fct)(int) = input->u.std.release_fct;
1328
1329 if (release_fct)
1330 release_fct(input->u.std.release_data);
1331 } else if (input->type == INPUT_TYPE_KBD) {
1332 char *release_str = input->u.kbd.release_str;
1333
1334 if (release_str[0]) {
1335 int s = sizeof(input->u.kbd.release_str);
1336
1337 keypad_send_key(release_str, s);
1338 }
1339 }
1340
1341 input->state = INPUT_ST_LOW;
1342 } else {
1343 input->fall_timer++;
1344 inputs_stable = 0;
1345 }
1346 }
1347
1348 static void panel_process_inputs(void)
1349 {
1350 struct logical_input *input;
1351
1352 keypressed = 0;
1353 inputs_stable = 1;
1354 list_for_each_entry(input, &logical_inputs, list) {
1355 switch (input->state) {
1356 case INPUT_ST_LOW:
1357 if ((phys_curr & input->mask) != input->value)
1358 break;
1359
1360
1361
1362
1363
1364
1365
1366 if ((phys_prev & input->mask) == input->value)
1367 break;
1368 input->rise_timer = 0;
1369 input->state = INPUT_ST_RISING;
1370
1371 case INPUT_ST_RISING:
1372 if ((phys_curr & input->mask) != input->value) {
1373 input->state = INPUT_ST_LOW;
1374 break;
1375 }
1376 if (input->rise_timer < input->rise_time) {
1377 inputs_stable = 0;
1378 input->rise_timer++;
1379 break;
1380 }
1381 input->high_timer = 0;
1382 input->state = INPUT_ST_HIGH;
1383
1384 case INPUT_ST_HIGH:
1385 if (input_state_high(input))
1386 break;
1387
1388 case INPUT_ST_FALLING:
1389 input_state_falling(input);
1390 }
1391 }
1392 }
1393
1394 static void panel_scan_timer(struct timer_list *unused)
1395 {
1396 if (keypad.enabled && keypad_initialized) {
1397 if (spin_trylock_irq(&pprt_lock)) {
1398 phys_scan_contacts();
1399
1400
1401 spin_unlock_irq(&pprt_lock);
1402 }
1403
1404 if (!inputs_stable || phys_curr != phys_prev)
1405 panel_process_inputs();
1406 }
1407
1408 if (keypressed && lcd.enabled && lcd.initialized)
1409 charlcd_poke(lcd.charlcd);
1410
1411 mod_timer(&scan_timer, jiffies + INPUT_POLL_TIME);
1412 }
1413
1414 static void init_scan_timer(void)
1415 {
1416 if (scan_timer.function)
1417 return;
1418
1419 timer_setup(&scan_timer, panel_scan_timer, 0);
1420 scan_timer.expires = jiffies + INPUT_POLL_TIME;
1421 add_timer(&scan_timer);
1422 }
1423
1424
1425
1426
1427
1428
1429 static u8 input_name2mask(const char *name, __u64 *mask, __u64 *value,
1430 u8 *imask, u8 *omask)
1431 {
1432 const char sigtab[] = "EeSsPpAaBb";
1433 u8 im, om;
1434 __u64 m, v;
1435
1436 om = 0;
1437 im = 0;
1438 m = 0ULL;
1439 v = 0ULL;
1440 while (*name) {
1441 int in, out, bit, neg;
1442 const char *idx;
1443
1444 idx = strchr(sigtab, *name);
1445 if (!idx)
1446 return 0;
1447
1448 in = idx - sigtab;
1449 neg = (in & 1);
1450 in >>= 1;
1451 im |= BIT(in);
1452
1453 name++;
1454 if (*name >= '0' && *name <= '7') {
1455 out = *name - '0';
1456 om |= BIT(out);
1457 } else if (*name == '-') {
1458 out = 8;
1459 } else {
1460 return 0;
1461 }
1462
1463 bit = (out * 5) + in;
1464
1465 m |= 1ULL << bit;
1466 if (!neg)
1467 v |= 1ULL << bit;
1468 name++;
1469 }
1470 *mask = m;
1471 *value = v;
1472 if (imask)
1473 *imask |= im;
1474 if (omask)
1475 *omask |= om;
1476 return 1;
1477 }
1478
1479
1480
1481
1482
1483 static struct logical_input *panel_bind_key(const char *name, const char *press,
1484 const char *repeat,
1485 const char *release)
1486 {
1487 struct logical_input *key;
1488
1489 key = kzalloc(sizeof(*key), GFP_KERNEL);
1490 if (!key)
1491 return NULL;
1492
1493 if (!input_name2mask(name, &key->mask, &key->value, &scan_mask_i,
1494 &scan_mask_o)) {
1495 kfree(key);
1496 return NULL;
1497 }
1498
1499 key->type = INPUT_TYPE_KBD;
1500 key->state = INPUT_ST_LOW;
1501 key->rise_time = 1;
1502 key->fall_time = 1;
1503
1504 strncpy(key->u.kbd.press_str, press, sizeof(key->u.kbd.press_str));
1505 strncpy(key->u.kbd.repeat_str, repeat, sizeof(key->u.kbd.repeat_str));
1506 strncpy(key->u.kbd.release_str, release,
1507 sizeof(key->u.kbd.release_str));
1508 list_add(&key->list, &logical_inputs);
1509 return key;
1510 }
1511
1512 #if 0
1513
1514
1515
1516
1517
1518
1519 static struct logical_input *panel_bind_callback(char *name,
1520 void (*press_fct)(int),
1521 int press_data,
1522 void (*release_fct)(int),
1523 int release_data)
1524 {
1525 struct logical_input *callback;
1526
1527 callback = kmalloc(sizeof(*callback), GFP_KERNEL);
1528 if (!callback)
1529 return NULL;
1530
1531 memset(callback, 0, sizeof(struct logical_input));
1532 if (!input_name2mask(name, &callback->mask, &callback->value,
1533 &scan_mask_i, &scan_mask_o))
1534 return NULL;
1535
1536 callback->type = INPUT_TYPE_STD;
1537 callback->state = INPUT_ST_LOW;
1538 callback->rise_time = 1;
1539 callback->fall_time = 1;
1540 callback->u.std.press_fct = press_fct;
1541 callback->u.std.press_data = press_data;
1542 callback->u.std.release_fct = release_fct;
1543 callback->u.std.release_data = release_data;
1544 list_add(&callback->list, &logical_inputs);
1545 return callback;
1546 }
1547 #endif
1548
1549 static void keypad_init(void)
1550 {
1551 int keynum;
1552
1553 init_waitqueue_head(&keypad_read_wait);
1554 keypad_buflen = 0;
1555
1556
1557
1558 for (keynum = 0; keypad_profile[keynum][0][0]; keynum++) {
1559 panel_bind_key(keypad_profile[keynum][0],
1560 keypad_profile[keynum][1],
1561 keypad_profile[keynum][2],
1562 keypad_profile[keynum][3]);
1563 }
1564
1565 init_scan_timer();
1566 keypad_initialized = 1;
1567 }
1568
1569
1570
1571
1572
1573 static void panel_attach(struct parport *port)
1574 {
1575 struct pardev_cb panel_cb;
1576
1577 if (port->number != parport)
1578 return;
1579
1580 if (pprt) {
1581 pr_err("%s: port->number=%d parport=%d, already registered!\n",
1582 __func__, port->number, parport);
1583 return;
1584 }
1585
1586 memset(&panel_cb, 0, sizeof(panel_cb));
1587 panel_cb.private = &pprt;
1588
1589
1590 pprt = parport_register_dev_model(port, "panel", &panel_cb, 0);
1591 if (!pprt) {
1592 pr_err("%s: port->number=%d parport=%d, parport_register_device() failed\n",
1593 __func__, port->number, parport);
1594 return;
1595 }
1596
1597 if (parport_claim(pprt)) {
1598 pr_err("could not claim access to parport%d. Aborting.\n",
1599 parport);
1600 goto err_unreg_device;
1601 }
1602
1603
1604
1605
1606 if (lcd.enabled) {
1607 lcd_init();
1608 if (!lcd.charlcd || charlcd_register(lcd.charlcd))
1609 goto err_unreg_device;
1610 }
1611
1612 if (keypad.enabled) {
1613 keypad_init();
1614 if (misc_register(&keypad_dev))
1615 goto err_lcd_unreg;
1616 }
1617 return;
1618
1619 err_lcd_unreg:
1620 if (scan_timer.function)
1621 del_timer_sync(&scan_timer);
1622 if (lcd.enabled)
1623 charlcd_unregister(lcd.charlcd);
1624 err_unreg_device:
1625 charlcd_free(lcd.charlcd);
1626 lcd.charlcd = NULL;
1627 parport_unregister_device(pprt);
1628 pprt = NULL;
1629 }
1630
1631 static void panel_detach(struct parport *port)
1632 {
1633 if (port->number != parport)
1634 return;
1635
1636 if (!pprt) {
1637 pr_err("%s: port->number=%d parport=%d, nothing to unregister.\n",
1638 __func__, port->number, parport);
1639 return;
1640 }
1641 if (scan_timer.function)
1642 del_timer_sync(&scan_timer);
1643
1644 if (keypad.enabled) {
1645 misc_deregister(&keypad_dev);
1646 keypad_initialized = 0;
1647 }
1648
1649 if (lcd.enabled) {
1650 charlcd_unregister(lcd.charlcd);
1651 lcd.initialized = false;
1652 charlcd_free(lcd.charlcd);
1653 lcd.charlcd = NULL;
1654 }
1655
1656
1657 parport_release(pprt);
1658 parport_unregister_device(pprt);
1659 pprt = NULL;
1660 }
1661
1662 static struct parport_driver panel_driver = {
1663 .name = "panel",
1664 .match_port = panel_attach,
1665 .detach = panel_detach,
1666 .devmodel = true,
1667 };
1668
1669
1670 static int __init panel_init_module(void)
1671 {
1672 int selected_keypad_type = NOT_SET, err;
1673
1674
1675 switch (profile) {
1676 case PANEL_PROFILE_CUSTOM:
1677
1678 selected_keypad_type = DEFAULT_KEYPAD_TYPE;
1679 selected_lcd_type = DEFAULT_LCD_TYPE;
1680 break;
1681 case PANEL_PROFILE_OLD:
1682
1683 selected_keypad_type = KEYPAD_TYPE_OLD;
1684 selected_lcd_type = LCD_TYPE_OLD;
1685
1686
1687 if (lcd_width == NOT_SET)
1688 lcd_width = 16;
1689 if (lcd_hwidth == NOT_SET)
1690 lcd_hwidth = 16;
1691 break;
1692 case PANEL_PROFILE_NEW:
1693
1694 selected_keypad_type = KEYPAD_TYPE_NEW;
1695 selected_lcd_type = LCD_TYPE_KS0074;
1696 break;
1697 case PANEL_PROFILE_HANTRONIX:
1698
1699 selected_keypad_type = KEYPAD_TYPE_NONE;
1700 selected_lcd_type = LCD_TYPE_HANTRONIX;
1701 break;
1702 case PANEL_PROFILE_NEXCOM:
1703
1704 selected_keypad_type = KEYPAD_TYPE_NEXCOM;
1705 selected_lcd_type = LCD_TYPE_NEXCOM;
1706 break;
1707 case PANEL_PROFILE_LARGE:
1708
1709 selected_keypad_type = KEYPAD_TYPE_OLD;
1710 selected_lcd_type = LCD_TYPE_OLD;
1711 break;
1712 }
1713
1714
1715
1716
1717
1718 if (keypad_enabled != NOT_SET)
1719 selected_keypad_type = keypad_enabled;
1720 if (keypad_type != NOT_SET)
1721 selected_keypad_type = keypad_type;
1722
1723 keypad.enabled = (selected_keypad_type > 0);
1724
1725 if (lcd_enabled != NOT_SET)
1726 selected_lcd_type = lcd_enabled;
1727 if (lcd_type != NOT_SET)
1728 selected_lcd_type = lcd_type;
1729
1730 lcd.enabled = (selected_lcd_type > 0);
1731
1732 if (lcd.enabled) {
1733
1734
1735
1736
1737 lcd.charset = lcd_charset;
1738 lcd.proto = lcd_proto;
1739 lcd.pins.e = lcd_e_pin;
1740 lcd.pins.rs = lcd_rs_pin;
1741 lcd.pins.rw = lcd_rw_pin;
1742 lcd.pins.cl = lcd_cl_pin;
1743 lcd.pins.da = lcd_da_pin;
1744 lcd.pins.bl = lcd_bl_pin;
1745 }
1746
1747 switch (selected_keypad_type) {
1748 case KEYPAD_TYPE_OLD:
1749 keypad_profile = old_keypad_profile;
1750 break;
1751 case KEYPAD_TYPE_NEW:
1752 keypad_profile = new_keypad_profile;
1753 break;
1754 case KEYPAD_TYPE_NEXCOM:
1755 keypad_profile = nexcom_keypad_profile;
1756 break;
1757 default:
1758 keypad_profile = NULL;
1759 break;
1760 }
1761
1762 if (!lcd.enabled && !keypad.enabled) {
1763
1764 pr_err("panel driver disabled.\n");
1765 return -ENODEV;
1766 }
1767
1768 err = parport_register_driver(&panel_driver);
1769 if (err) {
1770 pr_err("could not register with parport. Aborting.\n");
1771 return err;
1772 }
1773
1774 if (pprt)
1775 pr_info("panel driver registered on parport%d (io=0x%lx).\n",
1776 parport, pprt->port->base);
1777 else
1778 pr_info("panel driver not yet registered\n");
1779 return 0;
1780 }
1781
1782 static void __exit panel_cleanup_module(void)
1783 {
1784 parport_unregister_driver(&panel_driver);
1785 }
1786
1787 module_init(panel_init_module);
1788 module_exit(panel_cleanup_module);
1789 MODULE_AUTHOR("Willy Tarreau");
1790 MODULE_LICENSE("GPL");
1791
1792
1793
1794
1795
1796
1797