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