diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/tc |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/tc')
-rw-r--r-- | drivers/tc/Makefile | 23 | ||||
-rw-r--r-- | drivers/tc/lk201-map.c_shipped | 265 | ||||
-rw-r--r-- | drivers/tc/lk201-map.map | 356 | ||||
-rw-r--r-- | drivers/tc/lk201-remap.c | 172 | ||||
-rw-r--r-- | drivers/tc/lk201.c | 441 | ||||
-rw-r--r-- | drivers/tc/lk201.h | 125 | ||||
-rw-r--r-- | drivers/tc/tc.c | 260 | ||||
-rw-r--r-- | drivers/tc/zs.c | 2253 | ||||
-rw-r--r-- | drivers/tc/zs.h | 405 |
9 files changed, 4300 insertions, 0 deletions
diff --git a/drivers/tc/Makefile b/drivers/tc/Makefile new file mode 100644 index 000000000000..83b5bd75ce26 --- /dev/null +++ b/drivers/tc/Makefile | |||
@@ -0,0 +1,23 @@ | |||
1 | # | ||
2 | # Makefile for the linux kernel. | ||
3 | # | ||
4 | |||
5 | # Object file lists. | ||
6 | |||
7 | obj-$(CONFIG_TC) += tc.o | ||
8 | obj-$(CONFIG_ZS) += zs.o | ||
9 | obj-$(CONFIG_VT) += lk201.o lk201-map.o lk201-remap.o | ||
10 | |||
11 | $(obj)/lk201-map.o: $(obj)/lk201-map.c | ||
12 | |||
13 | # Uncomment if you're changing the keymap and have an appropriate | ||
14 | # loadkeys version for the map. By default, we'll use the shipped | ||
15 | # versions. | ||
16 | # GENERATE_KEYMAP := 1 | ||
17 | |||
18 | ifdef GENERATE_KEYMAP | ||
19 | |||
20 | $(obj)/lk201-map.c: $(obj)/%.c: $(src)/%.map | ||
21 | loadkeys --mktable $< > $@ | ||
22 | |||
23 | endif | ||
diff --git a/drivers/tc/lk201-map.c_shipped b/drivers/tc/lk201-map.c_shipped new file mode 100644 index 000000000000..a9df8f5bf62b --- /dev/null +++ b/drivers/tc/lk201-map.c_shipped | |||
@@ -0,0 +1,265 @@ | |||
1 | |||
2 | /* Do not edit this file! It was automatically generated by */ | ||
3 | /* loadkeys --mktable defkeymap.map > defkeymap.c */ | ||
4 | |||
5 | #include <linux/types.h> | ||
6 | #include <linux/keyboard.h> | ||
7 | #include <linux/kd.h> | ||
8 | |||
9 | u_short plain_map[NR_KEYS] = { | ||
10 | 0xf200, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, | ||
11 | 0xf107, 0xf108, 0xf109, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf11b, | ||
12 | 0xf11c, 0xf110, 0xf111, 0xf112, 0xf113, 0xf060, 0xf031, 0xf032, | ||
13 | 0xf033, 0xf034, 0xf035, 0xf036, 0xf037, 0xf038, 0xf039, 0xf030, | ||
14 | 0xf02d, 0xf03d, 0xf07f, 0xf114, 0xf115, 0xf116, 0xf200, 0xf200, | ||
15 | 0xf200, 0xf200, 0xf009, 0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, | ||
16 | 0xfb79, 0xfb75, 0xfb69, 0xfb6f, 0xfb70, 0xf05b, 0xf05d, 0xf201, | ||
17 | 0xf117, 0xf118, 0xf119, 0xf307, 0xf308, 0xf309, 0xf30b, 0xf702, | ||
18 | 0xf207, 0xfb61, 0xfb73, 0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, | ||
19 | 0xfb6b, 0xfb6c, 0xf03b, 0xf027, 0xf05c, 0xf603, 0xf304, 0xf305, | ||
20 | 0xf306, 0xf200, 0xf700, 0xf03e, 0xfb7a, 0xfb78, 0xfb63, 0xfb76, | ||
21 | 0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f, 0xf200, 0xf601, | ||
22 | 0xf600, 0xf602, 0xf301, 0xf302, 0xf303, 0xf30e, 0xf200, 0xf703, | ||
23 | 0xf020, 0xf200, 0xf200, 0xf300, 0xf310, 0xf200, 0xf200, 0xf200, | ||
24 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
25 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
26 | }; | ||
27 | |||
28 | static u_short shift_map[NR_KEYS] = { | ||
29 | 0xf200, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, | ||
30 | 0xf107, 0xf108, 0xf109, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf203, | ||
31 | 0xf11c, 0xf110, 0xf111, 0xf112, 0xf113, 0xf07e, 0xf021, 0xf040, | ||
32 | 0xf023, 0xf024, 0xf025, 0xf05e, 0xf026, 0xf02a, 0xf028, 0xf029, | ||
33 | 0xf05f, 0xf02b, 0xf07f, 0xf114, 0xf115, 0xf116, 0xf200, 0xf200, | ||
34 | 0xf200, 0xf200, 0xf009, 0xfb51, 0xfb57, 0xfb45, 0xfb52, 0xfb54, | ||
35 | 0xfb59, 0xfb55, 0xfb49, 0xfb4f, 0xfb50, 0xf07b, 0xf07d, 0xf201, | ||
36 | 0xf117, 0xf20b, 0xf20a, 0xf307, 0xf308, 0xf309, 0xf30b, 0xf702, | ||
37 | 0xf207, 0xfb41, 0xfb53, 0xfb44, 0xfb46, 0xfb47, 0xfb48, 0xfb4a, | ||
38 | 0xfb4b, 0xfb4c, 0xf03a, 0xf022, 0xf07c, 0xf603, 0xf304, 0xf305, | ||
39 | 0xf306, 0xf200, 0xf700, 0xf03c, 0xfb5a, 0xfb58, 0xfb43, 0xfb56, | ||
40 | 0xfb42, 0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf03f, 0xf200, 0xf601, | ||
41 | 0xf600, 0xf602, 0xf301, 0xf302, 0xf303, 0xf30e, 0xf200, 0xf703, | ||
42 | 0xf020, 0xf200, 0xf200, 0xf300, 0xf310, 0xf200, 0xf200, 0xf200, | ||
43 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
44 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
45 | }; | ||
46 | |||
47 | static u_short altgr_map[NR_KEYS] = { | ||
48 | 0xf200, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, | ||
49 | 0xf107, 0xf108, 0xf109, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf202, | ||
50 | 0xf11c, 0xf110, 0xf111, 0xf112, 0xf113, 0xf200, 0xf200, 0xf040, | ||
51 | 0xf200, 0xf024, 0xf200, 0xf200, 0xf07b, 0xf05b, 0xf05d, 0xf07d, | ||
52 | 0xf05c, 0xf200, 0xf200, 0xf114, 0xf115, 0xf116, 0xf200, 0xf200, | ||
53 | 0xf200, 0xf200, 0xf200, 0xfb71, 0xfb77, 0xf918, 0xfb72, 0xfb74, | ||
54 | 0xfb79, 0xfb75, 0xfb69, 0xfb6f, 0xfb70, 0xf200, 0xf07e, 0xf201, | ||
55 | 0xf117, 0xf118, 0xf119, 0xf911, 0xf912, 0xf913, 0xf30b, 0xf702, | ||
56 | 0xf207, 0xf914, 0xfb73, 0xf917, 0xf919, 0xfb67, 0xfb68, 0xfb6a, | ||
57 | 0xfb6b, 0xfb6c, 0xf200, 0xf200, 0xf200, 0xf603, 0xf90e, 0xf90f, | ||
58 | 0xf910, 0xf200, 0xf700, 0xf200, 0xfb7a, 0xfb78, 0xf916, 0xfb76, | ||
59 | 0xf915, 0xfb6e, 0xfb6d, 0xf200, 0xf200, 0xf200, 0xf200, 0xf601, | ||
60 | 0xf600, 0xf602, 0xf90b, 0xf90c, 0xf90d, 0xf30e, 0xf200, 0xf703, | ||
61 | 0xf200, 0xf200, 0xf200, 0xf90a, 0xf310, 0xf200, 0xf200, 0xf200, | ||
62 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
63 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
64 | }; | ||
65 | |||
66 | static u_short ctrl_map[NR_KEYS] = { | ||
67 | 0xf200, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, | ||
68 | 0xf107, 0xf108, 0xf109, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf204, | ||
69 | 0xf11c, 0xf110, 0xf111, 0xf112, 0xf113, 0xf81b, 0xf200, 0xf000, | ||
70 | 0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f, 0xf07f, 0xf200, 0xf200, | ||
71 | 0xf01f, 0xf200, 0xf008, 0xf114, 0xf115, 0xf116, 0xf200, 0xf200, | ||
72 | 0xf200, 0xf200, 0xf200, 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, | ||
73 | 0xf019, 0xf015, 0xf009, 0xf00f, 0xf010, 0xf01b, 0xf01d, 0xf201, | ||
74 | 0xf117, 0xf118, 0xf119, 0xf307, 0xf308, 0xf309, 0xf30b, 0xf702, | ||
75 | 0xf207, 0xf001, 0xf013, 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, | ||
76 | 0xf00b, 0xf00c, 0xf200, 0xf007, 0xf01c, 0xf603, 0xf304, 0xf305, | ||
77 | 0xf306, 0xf200, 0xf700, 0xf200, 0xf01a, 0xf018, 0xf003, 0xf016, | ||
78 | 0xf002, 0xf00e, 0xf00d, 0xf200, 0xf20e, 0xf07f, 0xf200, 0xf601, | ||
79 | 0xf600, 0xf602, 0xf301, 0xf302, 0xf303, 0xf30e, 0xf200, 0xf703, | ||
80 | 0xf000, 0xf200, 0xf200, 0xf300, 0xf310, 0xf200, 0xf200, 0xf200, | ||
81 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
82 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
83 | }; | ||
84 | |||
85 | static u_short shift_ctrl_map[NR_KEYS] = { | ||
86 | 0xf200, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, | ||
87 | 0xf107, 0xf108, 0xf109, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf200, | ||
88 | 0xf11c, 0xf110, 0xf111, 0xf112, 0xf113, 0xf200, 0xf200, 0xf000, | ||
89 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
90 | 0xf01f, 0xf200, 0xf200, 0xf114, 0xf115, 0xf116, 0xf200, 0xf200, | ||
91 | 0xf200, 0xf200, 0xf200, 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, | ||
92 | 0xf019, 0xf015, 0xf009, 0xf00f, 0xf010, 0xf200, 0xf200, 0xf201, | ||
93 | 0xf117, 0xf118, 0xf119, 0xf307, 0xf308, 0xf309, 0xf30b, 0xf702, | ||
94 | 0xf207, 0xf001, 0xf013, 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, | ||
95 | 0xf00b, 0xf00c, 0xf200, 0xf200, 0xf200, 0xf603, 0xf304, 0xf305, | ||
96 | 0xf306, 0xf200, 0xf700, 0xf200, 0xf01a, 0xf018, 0xf003, 0xf016, | ||
97 | 0xf002, 0xf00e, 0xf00d, 0xf200, 0xf200, 0xf200, 0xf200, 0xf601, | ||
98 | 0xf600, 0xf602, 0xf301, 0xf302, 0xf303, 0xf30e, 0xf200, 0xf703, | ||
99 | 0xf200, 0xf200, 0xf200, 0xf300, 0xf310, 0xf200, 0xf200, 0xf200, | ||
100 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
101 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
102 | }; | ||
103 | |||
104 | static u_short alt_map[NR_KEYS] = { | ||
105 | 0xf200, 0xf500, 0xf501, 0xf502, 0xf503, 0xf504, 0xf505, 0xf506, | ||
106 | 0xf507, 0xf508, 0xf509, 0xf50a, 0xf50b, 0xf50c, 0xf50d, 0xf200, | ||
107 | 0xf11c, 0xf510, 0xf511, 0xf512, 0xf513, 0xf01b, 0xf831, 0xf832, | ||
108 | 0xf833, 0xf834, 0xf835, 0xf836, 0xf837, 0xf838, 0xf839, 0xf830, | ||
109 | 0xf82d, 0xf83d, 0xf87f, 0xf114, 0xf115, 0xf116, 0xf200, 0xf200, | ||
110 | 0xf200, 0xf200, 0xf809, 0xf871, 0xf877, 0xf865, 0xf872, 0xf874, | ||
111 | 0xf879, 0xf875, 0xf869, 0xf86f, 0xf870, 0xf85b, 0xf85d, 0xf80d, | ||
112 | 0xf117, 0xf118, 0xf119, 0xf907, 0xf908, 0xf909, 0xf30b, 0xf702, | ||
113 | 0xf207, 0xf861, 0xf873, 0xf864, 0xf866, 0xf867, 0xf868, 0xf86a, | ||
114 | 0xf86b, 0xf86c, 0xf83b, 0xf827, 0xf85c, 0xf603, 0xf904, 0xf905, | ||
115 | 0xf906, 0xf200, 0xf700, 0xf200, 0xf87a, 0xf878, 0xf863, 0xf876, | ||
116 | 0xf862, 0xf86e, 0xf86d, 0xf82c, 0xf82e, 0xf82f, 0xf200, 0xf210, | ||
117 | 0xf600, 0xf211, 0xf901, 0xf902, 0xf903, 0xf30e, 0xf200, 0xf703, | ||
118 | 0xf820, 0xf200, 0xf200, 0xf900, 0xf310, 0xf200, 0xf200, 0xf200, | ||
119 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
120 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
121 | }; | ||
122 | |||
123 | static u_short ctrl_alt_map[NR_KEYS] = { | ||
124 | 0xf200, 0xf500, 0xf501, 0xf502, 0xf503, 0xf504, 0xf505, 0xf506, | ||
125 | 0xf507, 0xf508, 0xf509, 0xf50a, 0xf50b, 0xf50c, 0xf50d, 0xf200, | ||
126 | 0xf11c, 0xf510, 0xf511, 0xf512, 0xf513, 0xf200, 0xf200, 0xf200, | ||
127 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
128 | 0xf200, 0xf200, 0xf200, 0xf114, 0xf115, 0xf20c, 0xf200, 0xf200, | ||
129 | 0xf200, 0xf200, 0xf200, 0xf811, 0xf817, 0xf805, 0xf812, 0xf814, | ||
130 | 0xf819, 0xf815, 0xf809, 0xf80f, 0xf810, 0xf200, 0xf200, 0xf201, | ||
131 | 0xf117, 0xf118, 0xf119, 0xf307, 0xf308, 0xf309, 0xf30b, 0xf702, | ||
132 | 0xf207, 0xf801, 0xf813, 0xf804, 0xf806, 0xf807, 0xf808, 0xf80a, | ||
133 | 0xf80b, 0xf80c, 0xf200, 0xf200, 0xf200, 0xf603, 0xf304, 0xf305, | ||
134 | 0xf306, 0xf200, 0xf700, 0xf200, 0xf81a, 0xf818, 0xf803, 0xf816, | ||
135 | 0xf802, 0xf80e, 0xf80d, 0xf200, 0xf200, 0xf200, 0xf200, 0xf601, | ||
136 | 0xf600, 0xf602, 0xf301, 0xf302, 0xf303, 0xf30e, 0xf200, 0xf703, | ||
137 | 0xf200, 0xf200, 0xf200, 0xf300, 0xf20c, 0xf200, 0xf200, 0xf200, | ||
138 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
139 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
140 | }; | ||
141 | |||
142 | ushort *key_maps[MAX_NR_KEYMAPS] = { | ||
143 | plain_map, shift_map, altgr_map, 0, | ||
144 | ctrl_map, shift_ctrl_map, 0, 0, | ||
145 | alt_map, 0, 0, 0, | ||
146 | ctrl_alt_map, 0 | ||
147 | }; | ||
148 | |||
149 | unsigned int keymap_count = 7; | ||
150 | |||
151 | |||
152 | /* | ||
153 | * Philosophy: most people do not define more strings, but they who do | ||
154 | * often want quite a lot of string space. So, we statically allocate | ||
155 | * the default and allocate dynamically in chunks of 512 bytes. | ||
156 | */ | ||
157 | |||
158 | char func_buf[] = { | ||
159 | '\033', '[', '[', 'A', 0, | ||
160 | '\033', '[', '[', 'B', 0, | ||
161 | '\033', '[', '[', 'C', 0, | ||
162 | '\033', '[', '[', 'D', 0, | ||
163 | '\033', '[', '[', 'E', 0, | ||
164 | '\033', '[', '1', '7', '~', 0, | ||
165 | '\033', '[', '1', '8', '~', 0, | ||
166 | '\033', '[', '1', '9', '~', 0, | ||
167 | '\033', '[', '2', '0', '~', 0, | ||
168 | '\033', '[', '2', '1', '~', 0, | ||
169 | '\033', '[', '2', '3', '~', 0, | ||
170 | '\033', '[', '2', '4', '~', 0, | ||
171 | '\033', '[', '2', '5', '~', 0, | ||
172 | '\033', '[', '2', '6', '~', 0, | ||
173 | '\033', '[', '2', '8', '~', 0, | ||
174 | '\033', '[', '2', '9', '~', 0, | ||
175 | '\033', '[', '3', '1', '~', 0, | ||
176 | '\033', '[', '3', '2', '~', 0, | ||
177 | '\033', '[', '3', '3', '~', 0, | ||
178 | '\033', '[', '3', '4', '~', 0, | ||
179 | '\033', '[', '1', '~', 0, | ||
180 | '\033', '[', '2', '~', 0, | ||
181 | '\033', '[', '3', '~', 0, | ||
182 | '\033', '[', '4', '~', 0, | ||
183 | '\033', '[', '5', '~', 0, | ||
184 | '\033', '[', '6', '~', 0, | ||
185 | '\033', '[', 'M', 0, | ||
186 | '\033', '[', 'P', 0, | ||
187 | }; | ||
188 | |||
189 | |||
190 | char *funcbufptr = func_buf; | ||
191 | int funcbufsize = sizeof(func_buf); | ||
192 | int funcbufleft = 0; /* space left */ | ||
193 | |||
194 | char *func_table[MAX_NR_FUNC] = { | ||
195 | func_buf + 0, | ||
196 | func_buf + 5, | ||
197 | func_buf + 10, | ||
198 | func_buf + 15, | ||
199 | func_buf + 20, | ||
200 | func_buf + 25, | ||
201 | func_buf + 31, | ||
202 | func_buf + 37, | ||
203 | func_buf + 43, | ||
204 | func_buf + 49, | ||
205 | func_buf + 55, | ||
206 | func_buf + 61, | ||
207 | func_buf + 67, | ||
208 | func_buf + 73, | ||
209 | func_buf + 79, | ||
210 | func_buf + 85, | ||
211 | func_buf + 91, | ||
212 | func_buf + 97, | ||
213 | func_buf + 103, | ||
214 | func_buf + 109, | ||
215 | func_buf + 115, | ||
216 | func_buf + 120, | ||
217 | func_buf + 125, | ||
218 | func_buf + 130, | ||
219 | func_buf + 135, | ||
220 | func_buf + 140, | ||
221 | func_buf + 145, | ||
222 | 0, | ||
223 | 0, | ||
224 | func_buf + 149, | ||
225 | 0, | ||
226 | }; | ||
227 | |||
228 | struct kbdiacr accent_table[MAX_DIACR] = { | ||
229 | {'`', 'A', 'À'}, {'`', 'a', 'à'}, | ||
230 | {'\'', 'A', 'Á'}, {'\'', 'a', 'á'}, | ||
231 | {'^', 'A', 'Â'}, {'^', 'a', 'â'}, | ||
232 | {'~', 'A', 'Ã'}, {'~', 'a', 'ã'}, | ||
233 | {'"', 'A', 'Ä'}, {'"', 'a', 'ä'}, | ||
234 | {'O', 'A', 'Å'}, {'o', 'a', 'å'}, | ||
235 | {'0', 'A', 'Å'}, {'0', 'a', 'å'}, | ||
236 | {'A', 'A', 'Å'}, {'a', 'a', 'å'}, | ||
237 | {'A', 'E', 'Æ'}, {'a', 'e', 'æ'}, | ||
238 | {',', 'C', 'Ç'}, {',', 'c', 'ç'}, | ||
239 | {'`', 'E', 'È'}, {'`', 'e', 'è'}, | ||
240 | {'\'', 'E', 'É'}, {'\'', 'e', 'é'}, | ||
241 | {'^', 'E', 'Ê'}, {'^', 'e', 'ê'}, | ||
242 | {'"', 'E', 'Ë'}, {'"', 'e', 'ë'}, | ||
243 | {'`', 'I', 'Ì'}, {'`', 'i', 'ì'}, | ||
244 | {'\'', 'I', 'Í'}, {'\'', 'i', 'í'}, | ||
245 | {'^', 'I', 'Î'}, {'^', 'i', 'î'}, | ||
246 | {'"', 'I', 'Ï'}, {'"', 'i', 'ï'}, | ||
247 | {'-', 'D', 'Ð'}, {'-', 'd', 'ð'}, | ||
248 | {'~', 'N', 'Ñ'}, {'~', 'n', 'ñ'}, | ||
249 | {'`', 'O', 'Ò'}, {'`', 'o', 'ò'}, | ||
250 | {'\'', 'O', 'Ó'}, {'\'', 'o', 'ó'}, | ||
251 | {'^', 'O', 'Ô'}, {'^', 'o', 'ô'}, | ||
252 | {'~', 'O', 'Õ'}, {'~', 'o', 'õ'}, | ||
253 | {'"', 'O', 'Ö'}, {'"', 'o', 'ö'}, | ||
254 | {'/', 'O', 'Ø'}, {'/', 'o', 'ø'}, | ||
255 | {'`', 'U', 'Ù'}, {'`', 'u', 'ù'}, | ||
256 | {'\'', 'U', 'Ú'}, {'\'', 'u', 'ú'}, | ||
257 | {'^', 'U', 'Û'}, {'^', 'u', 'û'}, | ||
258 | {'"', 'U', 'Ü'}, {'"', 'u', 'ü'}, | ||
259 | {'\'', 'Y', 'Ý'}, {'\'', 'y', 'ý'}, | ||
260 | {'T', 'H', 'Þ'}, {'t', 'h', 'þ'}, | ||
261 | {'s', 's', 'ß'}, {'"', 'y', 'ÿ'}, | ||
262 | {'s', 'z', 'ß'}, {'i', 'j', 'ÿ'}, | ||
263 | }; | ||
264 | |||
265 | unsigned int accent_table_size = 68; | ||
diff --git a/drivers/tc/lk201-map.map b/drivers/tc/lk201-map.map new file mode 100644 index 000000000000..2c636b4b7823 --- /dev/null +++ b/drivers/tc/lk201-map.map | |||
@@ -0,0 +1,356 @@ | |||
1 | # Default kernel keymap. This uses 7 modifier combinations. | ||
2 | keymaps 0-2,4-5,8,12 | ||
3 | # Change the above line into | ||
4 | # keymaps 0-2,4-6,8,12 | ||
5 | # in case you want the entries | ||
6 | # altgr control keycode 83 = Boot | ||
7 | # altgr control keycode 111 = Boot | ||
8 | # below. | ||
9 | # | ||
10 | # In fact AltGr is used very little, and one more keymap can | ||
11 | # be saved by mapping AltGr to Alt (and adapting a few entries): | ||
12 | # keycode 100 = Alt | ||
13 | # | ||
14 | keycode 0x15 = grave tilde | ||
15 | alt keycode 0x15 = Escape | ||
16 | control keycode 0x15 = Meta_Escape | ||
17 | keycode 0x16 = one exclam | ||
18 | alt keycode 0x16 = Meta_one | ||
19 | keycode 0x17 = two at at | ||
20 | control keycode 0x17 = nul | ||
21 | shift control keycode 0x17 = nul | ||
22 | alt keycode 0x17 = Meta_two | ||
23 | keycode 0x18 = three numbersign | ||
24 | control keycode 0x18 = Escape | ||
25 | alt keycode 0x18 = Meta_three | ||
26 | keycode 0x19 = four dollar dollar | ||
27 | control keycode 0x19 = Control_backslash | ||
28 | alt keycode 0x19 = Meta_four | ||
29 | keycode 0x1a = five percent | ||
30 | control keycode 0x1a = Control_bracketright | ||
31 | alt keycode 0x1a = Meta_five | ||
32 | keycode 0x1b = six asciicircum | ||
33 | control keycode 0x1b = Control_asciicircum | ||
34 | alt keycode 0x1b = Meta_six | ||
35 | keycode 0x1c = seven ampersand braceleft | ||
36 | control keycode 0x1c = Control_underscore | ||
37 | alt keycode 0x1c = Meta_seven | ||
38 | keycode 0x1d = eight asterisk bracketleft | ||
39 | control keycode 0x1d = Delete | ||
40 | alt keycode 0x1d = Meta_eight | ||
41 | keycode 0x1e = nine parenleft bracketright | ||
42 | alt keycode 0x1e = Meta_nine | ||
43 | keycode 0x1f = zero parenright braceright | ||
44 | alt keycode 0x1f = Meta_zero | ||
45 | keycode 0x20 = minus underscore backslash | ||
46 | control keycode 0x20 = Control_underscore | ||
47 | shift control keycode 0x20 = Control_underscore | ||
48 | alt keycode 0x20 = Meta_minus | ||
49 | keycode 0x21 = equal plus | ||
50 | alt keycode 0x21 = Meta_equal | ||
51 | keycode 0x22 = Delete Delete | ||
52 | control keycode 0x22 = BackSpace | ||
53 | alt keycode 0x22 = Meta_Delete | ||
54 | keycode 0x2a = Tab Tab | ||
55 | alt keycode 0x2a = Meta_Tab | ||
56 | keycode 0x2b = q | ||
57 | keycode 0x2c = w | ||
58 | keycode 0x2d = e | ||
59 | altgr keycode 0x2d = Hex_E | ||
60 | keycode 0x2e = r | ||
61 | keycode 0x2f = t | ||
62 | keycode 0x30 = y | ||
63 | keycode 0x31 = u | ||
64 | keycode 0x32 = i | ||
65 | keycode 0x33 = o | ||
66 | keycode 0x34 = p | ||
67 | keycode 0x35 = bracketleft braceleft | ||
68 | control keycode 0x35 = Escape | ||
69 | alt keycode 0x35 = Meta_bracketleft | ||
70 | keycode 0x36 = bracketright braceright asciitilde | ||
71 | control keycode 0x36 = Control_bracketright | ||
72 | alt keycode 0x36 = Meta_bracketright | ||
73 | keycode 0x37 = Return | ||
74 | alt keycode 0x37 = Meta_Control_m | ||
75 | keycode 0x3f = Control | ||
76 | keycode 0x41 = a | ||
77 | altgr keycode 0x41 = Hex_A | ||
78 | keycode 0x42 = s | ||
79 | keycode 0x43 = d | ||
80 | altgr keycode 0x43 = Hex_D | ||
81 | keycode 0x44 = f | ||
82 | altgr keycode 0x44 = Hex_F | ||
83 | keycode 0x45 = g | ||
84 | keycode 0x46 = h | ||
85 | keycode 0x47 = j | ||
86 | keycode 0x48 = k | ||
87 | keycode 0x49 = l | ||
88 | keycode 0x4a = semicolon colon | ||
89 | alt keycode 0x4a = Meta_semicolon | ||
90 | keycode 0x4b = apostrophe quotedbl | ||
91 | control keycode 0x4b = Control_g | ||
92 | alt keycode 0x4b = Meta_apostrophe | ||
93 | # keycode 41 = grave asciitilde | ||
94 | # control keycode 41 = nul | ||
95 | # alt keycode 41 = Meta_grave | ||
96 | keycode 0x52 = Shift | ||
97 | keycode 0x4c = backslash bar | ||
98 | control keycode 0x4c = Control_backslash | ||
99 | alt keycode 0x4c = Meta_backslash | ||
100 | keycode 0x53 = greater less | ||
101 | keycode 0x54 = z | ||
102 | keycode 0x55 = x | ||
103 | keycode 0x56 = c | ||
104 | altgr keycode 0x56 = Hex_C | ||
105 | keycode 0x57 = v | ||
106 | keycode 0x58 = b | ||
107 | altgr keycode 0x58 = Hex_B | ||
108 | keycode 0x59 = n | ||
109 | keycode 0x5a = m | ||
110 | keycode 0x5b = comma less | ||
111 | alt keycode 0x5b = Meta_comma | ||
112 | keycode 0x5c = period greater | ||
113 | control keycode 0x5c = Compose | ||
114 | alt keycode 0x5c = Meta_period | ||
115 | keycode 0x5d = slash question | ||
116 | control keycode 0x5d = Delete | ||
117 | alt keycode 0x5d = Meta_slash | ||
118 | |||
119 | keycode 0x67 = Alt | ||
120 | keycode 0x68 = space space | ||
121 | control keycode 0x68 = nul | ||
122 | alt keycode 0x68 = Meta_space | ||
123 | keycode 0x40 = Caps_Lock | ||
124 | keycode 0x01 = F1 | ||
125 | control keycode 0x01 = F1 | ||
126 | alt keycode 0x01 = Console_1 | ||
127 | control alt keycode 0x01 = Console_1 | ||
128 | keycode 0x02 = F2 | ||
129 | control keycode 0x02 = F2 | ||
130 | alt keycode 0x02 = Console_2 | ||
131 | control alt keycode 0x02 = Console_2 | ||
132 | keycode 0x03 = F3 | ||
133 | control keycode 0x03 = F3 | ||
134 | alt keycode 0x03 = Console_3 | ||
135 | control alt keycode 0x03 = Console_3 | ||
136 | keycode 0x04 = F4 | ||
137 | control keycode 0x04 = F4 | ||
138 | alt keycode 0x04 = Console_4 | ||
139 | control alt keycode 0x04 = Console_4 | ||
140 | keycode 0x05 = F5 | ||
141 | control keycode 0x05 = F5 | ||
142 | alt keycode 0x05 = Console_5 | ||
143 | control alt keycode 0x05 = Console_5 | ||
144 | keycode 0x06 = F6 | ||
145 | control keycode 0x06 = F6 | ||
146 | alt keycode 0x06 = Console_6 | ||
147 | control alt keycode 0x06 = Console_6 | ||
148 | keycode 0x07 = F7 | ||
149 | control keycode 0x07 = F7 | ||
150 | alt keycode 0x07 = Console_7 | ||
151 | control alt keycode 0x07 = Console_7 | ||
152 | keycode 0x08 = F8 | ||
153 | control keycode 0x08 = F8 | ||
154 | alt keycode 0x08 = Console_8 | ||
155 | control alt keycode 0x08 = Console_8 | ||
156 | keycode 0x09 = F9 | ||
157 | control keycode 0x09 = F9 | ||
158 | alt keycode 0x09 = Console_9 | ||
159 | control alt keycode 0x09 = Console_9 | ||
160 | keycode 0x0a = F10 | ||
161 | control keycode 0x0a = F10 | ||
162 | alt keycode 0x0a = Console_10 | ||
163 | control alt keycode 0x0a = Console_10 | ||
164 | keycode 0x0b = F11 | ||
165 | control keycode 0x0b = F11 | ||
166 | alt keycode 0x0b = Console_11 | ||
167 | control alt keycode 0x0b = Console_11 | ||
168 | keycode 0x0c = F12 | ||
169 | control keycode 0x0c = F12 | ||
170 | alt keycode 0x0c = Console_12 | ||
171 | control alt keycode 0x0c = Console_12 | ||
172 | keycode 0x0d = F13 | ||
173 | control keycode 0x0d = F13 | ||
174 | alt keycode 0x0d = Console_13 | ||
175 | control alt keycode 0x0d = Console_13 | ||
176 | keycode 0x0e = F14 | ||
177 | control keycode 0x0e = F14 | ||
178 | alt keycode 0x0e = Console_14 | ||
179 | control alt keycode 0x0e = Console_14 | ||
180 | |||
181 | keycode 0x11 = F17 | ||
182 | control keycode 0x11 = F17 | ||
183 | alt keycode 0x11 = Console_17 | ||
184 | control alt keycode 0x11 = Console_17 | ||
185 | keycode 0x12 = F18 | ||
186 | control keycode 0x12 = F18 | ||
187 | alt keycode 0x12 = Console_18 | ||
188 | control alt keycode 0x12 = Console_18 | ||
189 | keycode 0x13 = F19 | ||
190 | control keycode 0x13 = F19 | ||
191 | alt keycode 0x13 = Console_19 | ||
192 | control alt keycode 0x13 = Console_19 | ||
193 | keycode 0x14 = F20 | ||
194 | control keycode 0x14 = F20 | ||
195 | alt keycode 0x14 = Console_20 | ||
196 | control alt keycode 0x14 = Console_20 | ||
197 | |||
198 | |||
199 | keycode 0x3b = KP_7 | ||
200 | alt keycode 0x3b = Ascii_7 | ||
201 | altgr keycode 0x3b = Hex_7 | ||
202 | keycode 0x3c = KP_8 | ||
203 | alt keycode 0x3c = Ascii_8 | ||
204 | altgr keycode 0x3c = Hex_8 | ||
205 | keycode 0x3d = KP_9 | ||
206 | alt keycode 0x3d = Ascii_9 | ||
207 | altgr keycode 0x3d = Hex_9 | ||
208 | keycode 0x3e = KP_Subtract | ||
209 | keycode 0x4e = KP_4 | ||
210 | alt keycode 0x4e = Ascii_4 | ||
211 | altgr keycode 0x4e = Hex_4 | ||
212 | keycode 0x4f = KP_5 | ||
213 | alt keycode 0x4f = Ascii_5 | ||
214 | altgr keycode 0x4f = Hex_5 | ||
215 | keycode 0x50 = KP_6 | ||
216 | alt keycode 0x50 = Ascii_6 | ||
217 | altgr keycode 0x50 = Hex_6 | ||
218 | keycode 0x62 = KP_1 | ||
219 | alt keycode 0x62 = Ascii_1 | ||
220 | altgr keycode 0x62 = Hex_1 | ||
221 | keycode 0x63 = KP_2 | ||
222 | alt keycode 0x63 = Ascii_2 | ||
223 | altgr keycode 0x63 = Hex_2 | ||
224 | keycode 0x64 = KP_3 | ||
225 | alt keycode 0x64 = Ascii_3 | ||
226 | altgr keycode 0x64 = Hex_3 | ||
227 | keycode 0x6b = KP_0 | ||
228 | alt keycode 0x6b = Ascii_0 | ||
229 | altgr keycode 0x6b = Hex_0 | ||
230 | keycode 0x6c = KP_Period | ||
231 | # altgr control keycode 0x6c = Boot | ||
232 | control alt keycode 0x6c = Boot | ||
233 | keycode 0x65 = KP_Enter | ||
234 | |||
235 | keycode 0x3f = Control | ||
236 | |||
237 | # keycode 100 = AltGr | ||
238 | |||
239 | keycode 0x23 = Find | ||
240 | keycode 0x4d = Up | ||
241 | keycode 0x39 = Prior | ||
242 | shift keycode 0x39 = Scroll_Backward | ||
243 | keycode 0x5f = Left | ||
244 | alt keycode 0x5f = Decr_Console | ||
245 | keycode 0x61 = Right | ||
246 | alt keycode 0x61 = Incr_Console | ||
247 | keycode 0x38 = Select | ||
248 | keycode 0x60 = Down | ||
249 | keycode 0x3a = Next | ||
250 | shift keycode 0x3a = Scroll_Forward | ||
251 | keycode 0x24 = Insert | ||
252 | keycode 0x25 = Remove | ||
253 | # altgr control keycode 0x25 = Boot | ||
254 | control alt keycode 0x25 = Boot | ||
255 | |||
256 | keycode 0x0f = Help Show_Memory Show_Registers | ||
257 | control keycode 0x0f = Show_State | ||
258 | |||
259 | keycode 0x10 = Do | ||
260 | |||
261 | string F1 = "\033[[A" | ||
262 | string F2 = "\033[[B" | ||
263 | string F3 = "\033[[C" | ||
264 | string F4 = "\033[[D" | ||
265 | string F5 = "\033[[E" | ||
266 | string F6 = "\033[17~" | ||
267 | string F7 = "\033[18~" | ||
268 | string F8 = "\033[19~" | ||
269 | string F9 = "\033[20~" | ||
270 | string F10 = "\033[21~" | ||
271 | string F11 = "\033[23~" | ||
272 | string F12 = "\033[24~" | ||
273 | string F13 = "\033[25~" | ||
274 | string F14 = "\033[26~" | ||
275 | string F15 = "\033[28~" | ||
276 | string F16 = "\033[29~" | ||
277 | string F17 = "\033[31~" | ||
278 | string F18 = "\033[32~" | ||
279 | string F19 = "\033[33~" | ||
280 | string F20 = "\033[34~" | ||
281 | string Find = "\033[1~" | ||
282 | string Insert = "\033[2~" | ||
283 | string Remove = "\033[3~" | ||
284 | string Select = "\033[4~" | ||
285 | string Prior = "\033[5~" | ||
286 | string Next = "\033[6~" | ||
287 | string Macro = "\033[M" | ||
288 | string Pause = "\033[P" | ||
289 | compose '`' 'A' to 'À' | ||
290 | compose '`' 'a' to 'à' | ||
291 | compose '\'' 'A' to 'Á' | ||
292 | compose '\'' 'a' to 'á' | ||
293 | compose '^' 'A' to 'Â' | ||
294 | compose '^' 'a' to 'â' | ||
295 | compose '~' 'A' to 'Ã' | ||
296 | compose '~' 'a' to 'ã' | ||
297 | compose '"' 'A' to 'Ä' | ||
298 | compose '"' 'a' to 'ä' | ||
299 | compose 'O' 'A' to 'Å' | ||
300 | compose 'o' 'a' to 'å' | ||
301 | compose '0' 'A' to 'Å' | ||
302 | compose '0' 'a' to 'å' | ||
303 | compose 'A' 'A' to 'Å' | ||
304 | compose 'a' 'a' to 'å' | ||
305 | compose 'A' 'E' to 'Æ' | ||
306 | compose 'a' 'e' to 'æ' | ||
307 | compose ',' 'C' to 'Ç' | ||
308 | compose ',' 'c' to 'ç' | ||
309 | compose '`' 'E' to 'È' | ||
310 | compose '`' 'e' to 'è' | ||
311 | compose '\'' 'E' to 'É' | ||
312 | compose '\'' 'e' to 'é' | ||
313 | compose '^' 'E' to 'Ê' | ||
314 | compose '^' 'e' to 'ê' | ||
315 | compose '"' 'E' to 'Ë' | ||
316 | compose '"' 'e' to 'ë' | ||
317 | compose '`' 'I' to 'Ì' | ||
318 | compose '`' 'i' to 'ì' | ||
319 | compose '\'' 'I' to 'Í' | ||
320 | compose '\'' 'i' to 'í' | ||
321 | compose '^' 'I' to 'Î' | ||
322 | compose '^' 'i' to 'î' | ||
323 | compose '"' 'I' to 'Ï' | ||
324 | compose '"' 'i' to 'ï' | ||
325 | compose '-' 'D' to 'Ð' | ||
326 | compose '-' 'd' to 'ð' | ||
327 | compose '~' 'N' to 'Ñ' | ||
328 | compose '~' 'n' to 'ñ' | ||
329 | compose '`' 'O' to 'Ò' | ||
330 | compose '`' 'o' to 'ò' | ||
331 | compose '\'' 'O' to 'Ó' | ||
332 | compose '\'' 'o' to 'ó' | ||
333 | compose '^' 'O' to 'Ô' | ||
334 | compose '^' 'o' to 'ô' | ||
335 | compose '~' 'O' to 'Õ' | ||
336 | compose '~' 'o' to 'õ' | ||
337 | compose '"' 'O' to 'Ö' | ||
338 | compose '"' 'o' to 'ö' | ||
339 | compose '/' 'O' to 'Ø' | ||
340 | compose '/' 'o' to 'ø' | ||
341 | compose '`' 'U' to 'Ù' | ||
342 | compose '`' 'u' to 'ù' | ||
343 | compose '\'' 'U' to 'Ú' | ||
344 | compose '\'' 'u' to 'ú' | ||
345 | compose '^' 'U' to 'Û' | ||
346 | compose '^' 'u' to 'û' | ||
347 | compose '"' 'U' to 'Ü' | ||
348 | compose '"' 'u' to 'ü' | ||
349 | compose '\'' 'Y' to 'Ý' | ||
350 | compose '\'' 'y' to 'ý' | ||
351 | compose 'T' 'H' to 'Þ' | ||
352 | compose 't' 'h' to 'þ' | ||
353 | compose 's' 's' to 'ß' | ||
354 | compose '"' 'y' to 'ÿ' | ||
355 | compose 's' 'z' to 'ß' | ||
356 | compose 'i' 'j' to 'ÿ' | ||
diff --git a/drivers/tc/lk201-remap.c b/drivers/tc/lk201-remap.c new file mode 100644 index 000000000000..d39098c2720e --- /dev/null +++ b/drivers/tc/lk201-remap.c | |||
@@ -0,0 +1,172 @@ | |||
1 | /* | ||
2 | * Keyboard mappings for DEC LK201/401/501 keyboards | ||
3 | * | ||
4 | * 17.05.99 Michael Engel (engel@unix-ag.org) | ||
5 | * | ||
6 | * DEC US keyboards generate keycodes in the range 0x55 - 0xfb | ||
7 | * | ||
8 | * This conflicts with Linux scancode conventions which define | ||
9 | * 0x00-0x7f as "normal" and 0x80-0xff as "shifted" scancodes, so we | ||
10 | * have to remap the keycodes to 0x00-0x7f with the scancodeRemap | ||
11 | * array. The generated scancode is simply the number of the key counted | ||
12 | * from the left upper to the right lower corner of the keyboard ... | ||
13 | * | ||
14 | * These scancodes are then being remapped (I hope ;-)) with the | ||
15 | * lk501*map[] arrays which define scancode -> Linux code mapping | ||
16 | * | ||
17 | * Oh man is this horrible ;-) | ||
18 | * | ||
19 | * Scancodes with dual labels exist for keyboards as follows: | ||
20 | * | ||
21 | * code: left label / right label | ||
22 | * | ||
23 | * 0x73: LKx01, LK421 / LK443, LK444 | ||
24 | * 0x74: LKx01, LK421 / LK443, LK444 | ||
25 | * 0x7c: LKx01, LK421 / LK443, LK444 | ||
26 | * 0x8a: LKx01, LK421 / LK443, LK444 | ||
27 | * 0x8b: LKx01, LK421 / LK443, LK444 | ||
28 | * 0x8c: LKx01, LK421 / LK443, LK444 | ||
29 | * 0x8d: LKx01, LK421 / LK443, LK444 | ||
30 | * 0x8e: LKx01, LK421 / LK443, LK444 | ||
31 | * 0x8f: LKx01, LK421 / LK443, LK444 | ||
32 | * 0x9c: LKx01, LK421 / LK443, LK444 | ||
33 | * 0xa1: LKx01, LK421 / LK443, LK444 | ||
34 | * 0xa2: LKx01, LK421 / LK443, LK444 | ||
35 | * 0xa3: LKx01, LK421 / LK443, LK444 | ||
36 | * 0xa4: LKx01, LK421 / LK443, LK444 | ||
37 | * 0xad: LK421 / LK443, LK444 | ||
38 | * 0xc9: LKx01, LK421, LK443 / LK444 | ||
39 | * 0xf7: LKx01, LK443 / LK444 | ||
40 | */ | ||
41 | |||
42 | unsigned char scancodeRemap[256] = { | ||
43 | /* ----- */ | ||
44 | /* 0 */ 0, 0, 0, 0, | ||
45 | /* ----- */ | ||
46 | /* 4 */ 0, 0, 0, 0, | ||
47 | /* ----- */ | ||
48 | /* 8 */ 0, 0, 0, 0, | ||
49 | /* ----- */ | ||
50 | /* c */ 0, 0, 0, 0, | ||
51 | /* ----- */ | ||
52 | /* 10 */ 0, 0, 0, 0, | ||
53 | /* ----- */ | ||
54 | /* 14 */ 0, 0, 0, 0, | ||
55 | /* ----- */ | ||
56 | /* 18 */ 0, 0, 0, 0, | ||
57 | /* ----- */ | ||
58 | /* 1c */ 0, 0, 0, 0, | ||
59 | /* ----- */ | ||
60 | /* 20 */ 0, 0, 0, 0, | ||
61 | /* ----- */ | ||
62 | /* 24 */ 0, 0, 0, 0, | ||
63 | /* ----- */ | ||
64 | /* 28 */ 0, 0, 0, 0, | ||
65 | /* ----- */ | ||
66 | /* 2c */ 0, 0, 0, 0, | ||
67 | /* ----- */ | ||
68 | /* 30 */ 0, 0, 0, 0, | ||
69 | /* ----- */ | ||
70 | /* 34 */ 0, 0, 0, 0, | ||
71 | /* ----- */ | ||
72 | /* 38 */ 0, 0, 0, 0, | ||
73 | /* ----- */ | ||
74 | /* 3c */ 0, 0, 0, 0, | ||
75 | /* ----- */ | ||
76 | /* 40 */ 0, 0, 0, 0, | ||
77 | /* ----- */ | ||
78 | /* 44 */ 0, 0, 0, 0, | ||
79 | /* ----- */ | ||
80 | /* 48 */ 0, 0, 0, 0, | ||
81 | /* ----- */ | ||
82 | /* 4c */ 0, 0, 0, 0, | ||
83 | /* ----- */ | ||
84 | /* 50 */ 0, 0, 0, 0, | ||
85 | /* ----- ESC F1 F2 */ | ||
86 | /* 54 */ 0, 0, 0x01, 0x02, | ||
87 | /* ----- F3 F4 F5 */ | ||
88 | /* 58 */ 0x03, 0x04, 0x05, 0, | ||
89 | /* ----- */ | ||
90 | /* 5c */ 0, 0, 0, 0, | ||
91 | /* ----- */ | ||
92 | /* 60 */ 0, 0, 0, 0, | ||
93 | /* ----- F6 F7 F8 F9 */ | ||
94 | /* 64 */ 0x06, 0x07, 0x08, 0x09, | ||
95 | /* ----- F10 */ | ||
96 | /* 68 */ 0x0a, 0, 0, 0, | ||
97 | /* ----- */ | ||
98 | /* 6c */ 0, 0, 0, 0, | ||
99 | /* ----- F11 F12 F13/PRNT SCRN */ | ||
100 | /* 70 */ 0, 0x0b, 0x0c, 0x0d, | ||
101 | /* ----- F14/SCRL LCK */ | ||
102 | /* 74 */ 0x0e, 0, 0, 0, | ||
103 | /* ----- */ | ||
104 | /* 78 */ 0, 0, 0, 0, | ||
105 | /* ----- HELP/PAUSE DO */ | ||
106 | /* 7c */ 0x0f, 0x10, 0, 0, | ||
107 | /* ----- F17 F18 F19 F20 */ | ||
108 | /* 80 */ 0x11, 0x12, 0x13, 0x14, | ||
109 | /* ----- */ | ||
110 | /* 84 */ 0, 0, 0, 0, | ||
111 | /* ----- FIND/INSERT INSERT/HOME */ | ||
112 | /* 88 */ 0, 0, 0x23, 0x24, | ||
113 | /* ----- REMOVE/PG UP SELECT/DELETE PREVIOUS/END NEXT/PG DN */ | ||
114 | /* 8c */ 0x25, 0x38, 0x39, 0x3a, | ||
115 | /* ----- KP 0 */ | ||
116 | /* 90 */ 0, 0, 0x6b, 0, | ||
117 | /* ----- KP . KP ENTER KP 1 KP 2 */ | ||
118 | /* 94 */ 0x6c, 0x65, 0x62, 0x63, | ||
119 | /* ----- KP 3 KP 4 KP 5 KP 6 */ | ||
120 | /* 98 */ 0x64, 0x4e, 0x4f, 0x50, | ||
121 | /* ----- KP ,/KP + KP 7 KP 8 KP 9 */ | ||
122 | /* 9c */ 0x51, 0x3b, 0x3c, 0x3d, | ||
123 | /* ----- KP - KP F1/NUM LCK KP F2/KP / KP F3/KP * */ | ||
124 | /* a0 */ 0x3e, 0x26, 0x27, 0x28, | ||
125 | /* ----- KP F4/KP - LEFT */ | ||
126 | /* a4 */ 0x29, 0, 0, 0x5f, | ||
127 | /* ----- RIGHT DOWN UP SHIFT Rt */ | ||
128 | /* a8 */ 0x61, 0x60, 0x4d, 0x5e, | ||
129 | /* ----- ALT COMP Rt/CTRL Rt SHIFT CONTROL */ | ||
130 | /* ac */ 0, 0, 0x52, 0x3f, | ||
131 | /* ----- CAPS COMPOSE ALT Rt */ | ||
132 | /* b0 */ 0x40, 0x67, 0, 0, | ||
133 | /* ----- */ | ||
134 | /* b4 */ 0, 0, 0, 0, | ||
135 | /* ----- */ | ||
136 | /* b8 */ 0, 0, 0, 0, | ||
137 | /* ----- BKSP RET TAB ` */ | ||
138 | /* bc */ 0x22, 0x37, 0x2a, 0x15, | ||
139 | /* ----- 1 q a z */ | ||
140 | /* c0 */ 0x16, 0x2b, 0x41, 0x54, | ||
141 | /* ----- 2 w s */ | ||
142 | /* c4 */ 0, 0x17, 0x2c, 0x42, | ||
143 | /* ----- x </\\ 3 */ | ||
144 | /* c8 */ 0x55, 0x53, 0, 0x18, | ||
145 | /* ----- e d c */ | ||
146 | /* cc */ 0x2d, 0x43, 0x56, 0, | ||
147 | /* ----- 4 r f v */ | ||
148 | /* d0 */ 0x19, 0x2e, 0x44, 0x57, | ||
149 | /* ----- SPACE 5 t */ | ||
150 | /* d4 */ 0x68, 0, 0x1a, 0x2f, | ||
151 | /* ----- g b 6 */ | ||
152 | /* d8 */ 0x45, 0x58, 0, 0x1b, | ||
153 | /* ----- y h n */ | ||
154 | /* dc */ 0x30, 0x46, 0x59, 0, | ||
155 | /* ----- 7 u j m */ | ||
156 | /* e0 */ 0x1c, 0x31, 0x47, 0x5a, | ||
157 | /* ----- 8 i k */ | ||
158 | /* e4 */ 0, 0x1d, 0x32, 0x48, | ||
159 | /* ----- , 9 o */ | ||
160 | /* e8 */ 0x5b, 0, 0x1e, 0x33, | ||
161 | /* ----- l . 0 */ | ||
162 | /* ec */ 0x49, 0x5c, 0, 0x1f, | ||
163 | /* ----- p ; / */ | ||
164 | /* f0 */ 0x34, 0, 0x4a, 0x5d, | ||
165 | /* ----- = ] \\/\' */ | ||
166 | /* f4 */ 0, 0x21, 0x36, 0x4c, | ||
167 | /* ----- - [ \' */ | ||
168 | /* f8 */ 0, 0x20, 0x35, 0x4b, | ||
169 | /* ----- */ | ||
170 | /* fc */ 0, 0, 0, 0, | ||
171 | }; | ||
172 | |||
diff --git a/drivers/tc/lk201.c b/drivers/tc/lk201.c new file mode 100644 index 000000000000..cf10d5cdfb93 --- /dev/null +++ b/drivers/tc/lk201.c | |||
@@ -0,0 +1,441 @@ | |||
1 | /* | ||
2 | * | ||
3 | * This file is subject to the terms and conditions of the GNU General Public | ||
4 | * License. See the file "COPYING" in the main directory of this archive | ||
5 | * for more details. | ||
6 | * | ||
7 | * Copyright (C) 1999-2002 Harald Koerfgen <hkoerfg@web.de> | ||
8 | * Copyright (C) 2001, 2002, 2003, 2004 Maciej W. Rozycki | ||
9 | */ | ||
10 | |||
11 | #include <linux/config.h> | ||
12 | |||
13 | #include <linux/errno.h> | ||
14 | #include <linux/sched.h> | ||
15 | #include <linux/tty.h> | ||
16 | #include <linux/kernel.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/delay.h> | ||
19 | #include <linux/kbd_ll.h> | ||
20 | #include <linux/kbd_kern.h> | ||
21 | #include <linux/vt_kern.h> | ||
22 | |||
23 | #include <asm/keyboard.h> | ||
24 | #include <asm/dec/tc.h> | ||
25 | #include <asm/dec/machtype.h> | ||
26 | #include <asm/dec/serial.h> | ||
27 | |||
28 | #include "lk201.h" | ||
29 | |||
30 | /* | ||
31 | * Only handle DECstations that have an LK201 interface. | ||
32 | * Maxine uses LK501 at the Access.Bus and various DECsystems | ||
33 | * have no keyboard interface at all. | ||
34 | */ | ||
35 | #define LK_IFACE (mips_machtype == MACH_DS23100 || \ | ||
36 | mips_machtype == MACH_DS5000_200 || \ | ||
37 | mips_machtype == MACH_DS5000_1XX || \ | ||
38 | mips_machtype == MACH_DS5000_2X0) | ||
39 | /* | ||
40 | * These use the Z8530 SCC. Others use the DZ11. | ||
41 | */ | ||
42 | #define LK_IFACE_ZS (mips_machtype == MACH_DS5000_1XX || \ | ||
43 | mips_machtype == MACH_DS5000_2X0) | ||
44 | |||
45 | /* Simple translation table for the SysRq keys */ | ||
46 | |||
47 | #ifdef CONFIG_MAGIC_SYSRQ | ||
48 | /* | ||
49 | * Actually no translation at all, at least until we figure out | ||
50 | * how to define SysRq for LK201 and friends. --macro | ||
51 | */ | ||
52 | unsigned char lk201_sysrq_xlate[128]; | ||
53 | unsigned char *kbd_sysrq_xlate = lk201_sysrq_xlate; | ||
54 | |||
55 | unsigned char kbd_sysrq_key = -1; | ||
56 | #endif | ||
57 | |||
58 | #define KEYB_LINE 3 | ||
59 | |||
60 | static int __init lk201_init(void *); | ||
61 | static void __init lk201_info(void *); | ||
62 | static void lk201_rx_char(unsigned char, unsigned char); | ||
63 | |||
64 | static struct dec_serial_hook lk201_hook = { | ||
65 | .init_channel = lk201_init, | ||
66 | .init_info = lk201_info, | ||
67 | .rx_char = NULL, | ||
68 | .poll_rx_char = NULL, | ||
69 | .poll_tx_char = NULL, | ||
70 | .cflags = B4800 | CS8 | CSTOPB | CLOCAL, | ||
71 | }; | ||
72 | |||
73 | /* | ||
74 | * This is used during keyboard initialisation | ||
75 | */ | ||
76 | static unsigned char lk201_reset_string[] = { | ||
77 | LK_CMD_SET_DEFAULTS, | ||
78 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 1), | ||
79 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 2), | ||
80 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 3), | ||
81 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 4), | ||
82 | LK_CMD_MODE(LK_MODE_DOWN_UP, 5), | ||
83 | LK_CMD_MODE(LK_MODE_DOWN_UP, 6), | ||
84 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 7), | ||
85 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 8), | ||
86 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 9), | ||
87 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 10), | ||
88 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 11), | ||
89 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 12), | ||
90 | LK_CMD_MODE(LK_MODE_DOWN, 13), | ||
91 | LK_CMD_MODE(LK_MODE_RPT_DOWN, 14), | ||
92 | LK_CMD_DIS_KEYCLK, | ||
93 | LK_CMD_ENB_BELL, LK_PARAM_VOLUME(4), | ||
94 | }; | ||
95 | |||
96 | static void *lk201_handle; | ||
97 | |||
98 | static int lk201_send(unsigned char ch) | ||
99 | { | ||
100 | if (lk201_hook.poll_tx_char(lk201_handle, ch)) { | ||
101 | printk(KERN_ERR "lk201: transmit timeout\n"); | ||
102 | return -EIO; | ||
103 | } | ||
104 | return 0; | ||
105 | } | ||
106 | |||
107 | static inline int lk201_get_id(void) | ||
108 | { | ||
109 | return lk201_send(LK_CMD_REQ_ID); | ||
110 | } | ||
111 | |||
112 | static int lk201_reset(void) | ||
113 | { | ||
114 | int i, r; | ||
115 | |||
116 | for (i = 0; i < sizeof(lk201_reset_string); i++) { | ||
117 | r = lk201_send(lk201_reset_string[i]); | ||
118 | if (r < 0) | ||
119 | return r; | ||
120 | } | ||
121 | return 0; | ||
122 | } | ||
123 | |||
124 | static void lk201_report(unsigned char id[6]) | ||
125 | { | ||
126 | char *report = "lk201: keyboard attached, "; | ||
127 | |||
128 | switch (id[2]) { | ||
129 | case LK_STAT_PWRUP_OK: | ||
130 | printk(KERN_INFO "%sself-test OK\n", report); | ||
131 | break; | ||
132 | case LK_STAT_PWRUP_KDOWN: | ||
133 | /* The keyboard will resend the power-up ID | ||
134 | after all keys are released, so we don't | ||
135 | bother handling the error specially. Still | ||
136 | there may be a short-circuit inside. | ||
137 | */ | ||
138 | printk(KERN_ERR "%skey down (stuck?), code: 0x%02x\n", | ||
139 | report, id[3]); | ||
140 | break; | ||
141 | case LK_STAT_PWRUP_ERROR: | ||
142 | printk(KERN_ERR "%sself-test failure\n", report); | ||
143 | break; | ||
144 | default: | ||
145 | printk(KERN_ERR "%sunknown error: 0x%02x\n", | ||
146 | report, id[2]); | ||
147 | } | ||
148 | } | ||
149 | |||
150 | static void lk201_id(unsigned char id[6]) | ||
151 | { | ||
152 | /* | ||
153 | * Report whether there is an LK201 or an LK401 | ||
154 | * The LK401 has ALT keys... | ||
155 | */ | ||
156 | switch (id[4]) { | ||
157 | case 1: | ||
158 | printk(KERN_INFO "lk201: LK201 detected\n"); | ||
159 | break; | ||
160 | case 2: | ||
161 | printk(KERN_INFO "lk201: LK401 detected\n"); | ||
162 | break; | ||
163 | case 3: | ||
164 | printk(KERN_INFO "lk201: LK443 detected\n"); | ||
165 | break; | ||
166 | case 4: | ||
167 | printk(KERN_INFO "lk201: LK421 detected\n"); | ||
168 | break; | ||
169 | default: | ||
170 | printk(KERN_WARNING | ||
171 | "lk201: unknown keyboard detected, ID %d\n", id[4]); | ||
172 | printk(KERN_WARNING "lk201: ... please report to " | ||
173 | "<linux-mips@linux-mips.org>\n"); | ||
174 | } | ||
175 | } | ||
176 | |||
177 | #define DEFAULT_KEYB_REP_DELAY (250/5) /* [5ms] */ | ||
178 | #define DEFAULT_KEYB_REP_RATE 30 /* [cps] */ | ||
179 | |||
180 | static struct kbd_repeat kbdrate = { | ||
181 | DEFAULT_KEYB_REP_DELAY, | ||
182 | DEFAULT_KEYB_REP_RATE | ||
183 | }; | ||
184 | |||
185 | static void parse_kbd_rate(struct kbd_repeat *r) | ||
186 | { | ||
187 | if (r->delay <= 0) | ||
188 | r->delay = kbdrate.delay; | ||
189 | if (r->rate <= 0) | ||
190 | r->rate = kbdrate.rate; | ||
191 | |||
192 | if (r->delay < 5) | ||
193 | r->delay = 5; | ||
194 | if (r->delay > 630) | ||
195 | r->delay = 630; | ||
196 | if (r->rate < 12) | ||
197 | r->rate = 12; | ||
198 | if (r->rate > 127) | ||
199 | r->rate = 127; | ||
200 | if (r->rate == 125) | ||
201 | r->rate = 124; | ||
202 | } | ||
203 | |||
204 | static int write_kbd_rate(struct kbd_repeat *rep) | ||
205 | { | ||
206 | int delay, rate; | ||
207 | int i; | ||
208 | |||
209 | delay = rep->delay / 5; | ||
210 | rate = rep->rate; | ||
211 | for (i = 0; i < 4; i++) { | ||
212 | if (lk201_hook.poll_tx_char(lk201_handle, | ||
213 | LK_CMD_RPT_RATE(i))) | ||
214 | return 1; | ||
215 | if (lk201_hook.poll_tx_char(lk201_handle, | ||
216 | LK_PARAM_DELAY(delay))) | ||
217 | return 1; | ||
218 | if (lk201_hook.poll_tx_char(lk201_handle, | ||
219 | LK_PARAM_RATE(rate))) | ||
220 | return 1; | ||
221 | } | ||
222 | return 0; | ||
223 | } | ||
224 | |||
225 | static int lk201_kbd_rate(struct kbd_repeat *rep) | ||
226 | { | ||
227 | if (rep == NULL) | ||
228 | return -EINVAL; | ||
229 | |||
230 | parse_kbd_rate(rep); | ||
231 | |||
232 | if (write_kbd_rate(rep)) { | ||
233 | memcpy(rep, &kbdrate, sizeof(struct kbd_repeat)); | ||
234 | return -EIO; | ||
235 | } | ||
236 | |||
237 | memcpy(&kbdrate, rep, sizeof(struct kbd_repeat)); | ||
238 | |||
239 | return 0; | ||
240 | } | ||
241 | |||
242 | static void lk201_kd_mksound(unsigned int hz, unsigned int ticks) | ||
243 | { | ||
244 | if (!ticks) | ||
245 | return; | ||
246 | |||
247 | /* | ||
248 | * Can't set frequency and we "approximate" | ||
249 | * duration by volume. ;-) | ||
250 | */ | ||
251 | ticks /= HZ / 32; | ||
252 | if (ticks > 7) | ||
253 | ticks = 7; | ||
254 | ticks = 7 - ticks; | ||
255 | |||
256 | if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_ENB_BELL)) | ||
257 | return; | ||
258 | if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_VOLUME(ticks))) | ||
259 | return; | ||
260 | if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_BELL)) | ||
261 | return; | ||
262 | } | ||
263 | |||
264 | void kbd_leds(unsigned char leds) | ||
265 | { | ||
266 | unsigned char l = 0; | ||
267 | |||
268 | if (!lk201_handle) /* FIXME */ | ||
269 | return; | ||
270 | |||
271 | /* FIXME -- Only Hold and Lock LEDs for now. --macro */ | ||
272 | if (leds & LED_SCR) | ||
273 | l |= LK_LED_HOLD; | ||
274 | if (leds & LED_CAP) | ||
275 | l |= LK_LED_LOCK; | ||
276 | |||
277 | if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_LEDS_ON)) | ||
278 | return; | ||
279 | if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_LED_MASK(l))) | ||
280 | return; | ||
281 | if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_LEDS_OFF)) | ||
282 | return; | ||
283 | if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_LED_MASK(~l))) | ||
284 | return; | ||
285 | } | ||
286 | |||
287 | int kbd_setkeycode(unsigned int scancode, unsigned int keycode) | ||
288 | { | ||
289 | return -EINVAL; | ||
290 | } | ||
291 | |||
292 | int kbd_getkeycode(unsigned int scancode) | ||
293 | { | ||
294 | return -EINVAL; | ||
295 | } | ||
296 | |||
297 | int kbd_translate(unsigned char scancode, unsigned char *keycode, | ||
298 | char raw_mode) | ||
299 | { | ||
300 | *keycode = scancode; | ||
301 | return 1; | ||
302 | } | ||
303 | |||
304 | char kbd_unexpected_up(unsigned char keycode) | ||
305 | { | ||
306 | return 0x80; | ||
307 | } | ||
308 | |||
309 | static void lk201_rx_char(unsigned char ch, unsigned char fl) | ||
310 | { | ||
311 | static unsigned char id[6]; | ||
312 | static int id_i; | ||
313 | |||
314 | static int shift_state = 0; | ||
315 | static int prev_scancode; | ||
316 | unsigned char c = scancodeRemap[ch]; | ||
317 | |||
318 | if (fl != TTY_NORMAL && fl != TTY_OVERRUN) { | ||
319 | printk(KERN_ERR "lk201: keyboard receive error: 0x%02x\n", fl); | ||
320 | return; | ||
321 | } | ||
322 | |||
323 | /* Assume this is a power-up ID. */ | ||
324 | if (ch == LK_STAT_PWRUP_ID && !id_i) { | ||
325 | id[id_i++] = ch; | ||
326 | return; | ||
327 | } | ||
328 | |||
329 | /* Handle the power-up sequence. */ | ||
330 | if (id_i) { | ||
331 | id[id_i++] = ch; | ||
332 | if (id_i == 4) { | ||
333 | /* OK, the power-up concluded. */ | ||
334 | lk201_report(id); | ||
335 | if (id[2] == LK_STAT_PWRUP_OK) | ||
336 | lk201_get_id(); | ||
337 | else { | ||
338 | id_i = 0; | ||
339 | printk(KERN_ERR "lk201: keyboard power-up " | ||
340 | "error, skipping initialization\n"); | ||
341 | } | ||
342 | } else if (id_i == 6) { | ||
343 | /* We got the ID; report it and start operation. */ | ||
344 | id_i = 0; | ||
345 | lk201_id(id); | ||
346 | lk201_reset(); | ||
347 | } | ||
348 | return; | ||
349 | } | ||
350 | |||
351 | /* Everything else is a scancode/status response. */ | ||
352 | id_i = 0; | ||
353 | switch (ch) { | ||
354 | case LK_STAT_RESUME_ERR: | ||
355 | case LK_STAT_ERROR: | ||
356 | case LK_STAT_INHIBIT_ACK: | ||
357 | case LK_STAT_TEST_ACK: | ||
358 | case LK_STAT_MODE_KEYDOWN: | ||
359 | case LK_STAT_MODE_ACK: | ||
360 | break; | ||
361 | case LK_KEY_LOCK: | ||
362 | shift_state ^= LK_LOCK; | ||
363 | handle_scancode(c, (shift_state & LK_LOCK) ? 1 : 0); | ||
364 | break; | ||
365 | case LK_KEY_SHIFT: | ||
366 | shift_state ^= LK_SHIFT; | ||
367 | handle_scancode(c, (shift_state & LK_SHIFT) ? 1 : 0); | ||
368 | break; | ||
369 | case LK_KEY_CTRL: | ||
370 | shift_state ^= LK_CTRL; | ||
371 | handle_scancode(c, (shift_state & LK_CTRL) ? 1 : 0); | ||
372 | break; | ||
373 | case LK_KEY_COMP: | ||
374 | shift_state ^= LK_COMP; | ||
375 | handle_scancode(c, (shift_state & LK_COMP) ? 1 : 0); | ||
376 | break; | ||
377 | case LK_KEY_RELEASE: | ||
378 | if (shift_state & LK_SHIFT) | ||
379 | handle_scancode(scancodeRemap[LK_KEY_SHIFT], 0); | ||
380 | if (shift_state & LK_CTRL) | ||
381 | handle_scancode(scancodeRemap[LK_KEY_CTRL], 0); | ||
382 | if (shift_state & LK_COMP) | ||
383 | handle_scancode(scancodeRemap[LK_KEY_COMP], 0); | ||
384 | if (shift_state & LK_LOCK) | ||
385 | handle_scancode(scancodeRemap[LK_KEY_LOCK], 0); | ||
386 | shift_state = 0; | ||
387 | break; | ||
388 | case LK_KEY_REPEAT: | ||
389 | handle_scancode(prev_scancode, 1); | ||
390 | break; | ||
391 | default: | ||
392 | prev_scancode = c; | ||
393 | handle_scancode(c, 1); | ||
394 | break; | ||
395 | } | ||
396 | tasklet_schedule(&keyboard_tasklet); | ||
397 | } | ||
398 | |||
399 | static void __init lk201_info(void *handle) | ||
400 | { | ||
401 | } | ||
402 | |||
403 | static int __init lk201_init(void *handle) | ||
404 | { | ||
405 | /* First install handlers. */ | ||
406 | lk201_handle = handle; | ||
407 | kbd_rate = lk201_kbd_rate; | ||
408 | kd_mksound = lk201_kd_mksound; | ||
409 | |||
410 | lk201_hook.rx_char = lk201_rx_char; | ||
411 | |||
412 | /* Then just issue a reset -- the handlers will do the rest. */ | ||
413 | lk201_send(LK_CMD_POWER_UP); | ||
414 | |||
415 | return 0; | ||
416 | } | ||
417 | |||
418 | void __init kbd_init_hw(void) | ||
419 | { | ||
420 | /* Maxine uses LK501 at the Access.Bus. */ | ||
421 | if (!LK_IFACE) | ||
422 | return; | ||
423 | |||
424 | printk(KERN_INFO "lk201: DECstation LK keyboard driver v0.05.\n"); | ||
425 | |||
426 | if (LK_IFACE_ZS) { | ||
427 | /* | ||
428 | * kbd_init_hw() is being called before | ||
429 | * rs_init() so just register the kbd hook | ||
430 | * and let zs_init do the rest :-) | ||
431 | */ | ||
432 | if (!register_dec_serial_hook(KEYB_LINE, &lk201_hook)) | ||
433 | unregister_dec_serial_hook(KEYB_LINE); | ||
434 | } else { | ||
435 | /* | ||
436 | * TODO: modify dz.c to allow similar hooks | ||
437 | * for LK201 handling on DS2100, DS3100, and DS5000/200 | ||
438 | */ | ||
439 | printk(KERN_ERR "lk201: support for DZ11 not yet ready.\n"); | ||
440 | } | ||
441 | } | ||
diff --git a/drivers/tc/lk201.h b/drivers/tc/lk201.h new file mode 100644 index 000000000000..99f3203c41b8 --- /dev/null +++ b/drivers/tc/lk201.h | |||
@@ -0,0 +1,125 @@ | |||
1 | /* | ||
2 | * Commands to the keyboard processor | ||
3 | */ | ||
4 | |||
5 | #define LK_PARAM 0x80 /* start/end parameter list */ | ||
6 | |||
7 | #define LK_CMD_RESUME 0x8b /* resume transmission to the host */ | ||
8 | #define LK_CMD_INHIBIT 0x89 /* stop transmission to the host */ | ||
9 | #define LK_CMD_LEDS_ON 0x13 /* light LEDs */ | ||
10 | /* 1st param: led bitmask */ | ||
11 | #define LK_CMD_LEDS_OFF 0x11 /* turn off LEDs */ | ||
12 | /* 1st param: led bitmask */ | ||
13 | #define LK_CMD_DIS_KEYCLK 0x99 /* disable the keyclick */ | ||
14 | #define LK_CMD_ENB_KEYCLK 0x1b /* enable the keyclick */ | ||
15 | /* 1st param: volume */ | ||
16 | #define LK_CMD_DIS_CTLCLK 0xb9 /* disable the Ctrl keyclick */ | ||
17 | #define LK_CMD_ENB_CTLCLK 0xbb /* enable the Ctrl keyclick */ | ||
18 | #define LK_CMD_SOUND_CLK 0x9f /* emit a keyclick */ | ||
19 | #define LK_CMD_DIS_BELL 0xa1 /* disable the bell */ | ||
20 | #define LK_CMD_ENB_BELL 0x23 /* enable the bell */ | ||
21 | /* 1st param: volume */ | ||
22 | #define LK_CMD_BELL 0xa7 /* emit a bell */ | ||
23 | #define LK_CMD_TMP_NORPT 0xd1 /* disable typematic */ | ||
24 | /* for the currently pressed key */ | ||
25 | #define LK_CMD_ENB_RPT 0xe3 /* enable typematic */ | ||
26 | /* for RPT_DOWN groups */ | ||
27 | #define LK_CMD_DIS_RPT 0xe1 /* disable typematic */ | ||
28 | /* for RPT_DOWN groups */ | ||
29 | #define LK_CMD_RPT_TO_DOWN 0xd9 /* set RPT_DOWN groups to DOWN */ | ||
30 | #define LK_CMD_REQ_ID 0xab /* request the keyboard ID */ | ||
31 | #define LK_CMD_POWER_UP 0xfd /* init power-up sequence */ | ||
32 | #define LK_CMD_TEST_MODE 0xcb /* enter the factory test mode */ | ||
33 | #define LK_CMD_TEST_EXIT 0x80 /* exit the factory test mode */ | ||
34 | #define LK_CMD_SET_DEFAULTS 0xd3 /* set power-up defaults */ | ||
35 | |||
36 | #define LK_CMD_MODE(m,div) (LK_PARAM|(((div)&0xf)<<3)|(((m)&0x3)<<1)) | ||
37 | /* select the repeat mode */ | ||
38 | /* for the selected key group */ | ||
39 | #define LK_CMD_MODE_AR(m,div) ((((div)&0xf)<<3)|(((m)&0x3)<<1)) | ||
40 | /* select the repeat mode */ | ||
41 | /* and the repeat register */ | ||
42 | /* for the selected key group */ | ||
43 | /* 1st param: register number */ | ||
44 | #define LK_CMD_RPT_RATE(r) (0x78|(((r)&0x3)<<1)) | ||
45 | /* set the delay and repeat rate */ | ||
46 | /* for the selected repeat register */ | ||
47 | /* 1st param: initial delay */ | ||
48 | /* 2nd param: repeat rate */ | ||
49 | |||
50 | /* there are 4 leds, represent them in the low 4 bits of a byte */ | ||
51 | #define LK_PARAM_LED_MASK(ledbmap) (LK_PARAM|((ledbmap)&0xf)) | ||
52 | #define LK_LED_WAIT 0x1 /* Wait LED */ | ||
53 | #define LK_LED_COMP 0x2 /* Compose LED */ | ||
54 | #define LK_LED_LOCK 0x4 /* Lock LED */ | ||
55 | #define LK_LED_HOLD 0x8 /* Hold Screen LED */ | ||
56 | |||
57 | /* max volume is 0, lowest is 0x7 */ | ||
58 | #define LK_PARAM_VOLUME(v) (LK_PARAM|((v)&0x7)) | ||
59 | |||
60 | /* mode set command details, div is a key group number */ | ||
61 | #define LK_MODE_DOWN 0x0 /* make only */ | ||
62 | #define LK_MODE_RPT_DOWN 0x1 /* make and typematic */ | ||
63 | #define LK_MODE_DOWN_UP 0x3 /* make and release */ | ||
64 | |||
65 | /* there are 4 repeat registers */ | ||
66 | #define LK_PARAM_AR(r) (LK_PARAM|((v)&0x3)) | ||
67 | |||
68 | /* | ||
69 | * Mappings between key groups and keycodes are as follows: | ||
70 | * | ||
71 | * 1: 0xbf - 0xff -- alphanumeric, | ||
72 | * 2: 0x91 - 0xa5 -- numeric keypad, | ||
73 | * 3: 0xbc -- Backspace, | ||
74 | * 4: 0xbd - 0xbe -- Tab, Return, | ||
75 | * 5: 0xb0 - 0xb2 -- Lock, Compose Character, | ||
76 | * 6: 0xad - 0xaf -- Ctrl, Shift, | ||
77 | * 7: 0xa6 - 0xa8 -- Left Arrow, Right Arrow, | ||
78 | * 8: 0xa9 - 0xac -- Up Arrow, Down Arrow, Right Shift, | ||
79 | * 9: 0x88 - 0x90 -- editor keypad, | ||
80 | * 10: 0x56 - 0x62 -- F1 - F5, | ||
81 | * 11: 0x63 - 0x6e -- F6 - F10, | ||
82 | * 12: 0x6f - 0x7a -- F11 - F14, | ||
83 | * 13: 0x7b - 0x7d -- Help, Do, | ||
84 | * 14: 0x7e - 0x87 -- F17 - F20. | ||
85 | * | ||
86 | * Notes: | ||
87 | * 1. Codes in the 0x00 - 0x40 range are reserved. | ||
88 | * 2. The assignment of the 0x41 - 0x55 range is undiscovered, probably 10. | ||
89 | */ | ||
90 | |||
91 | /* delay is 5 - 630 ms; 0x00 and 0x7f are reserved */ | ||
92 | #define LK_PARAM_DELAY(t) ((t)&0x7f) | ||
93 | |||
94 | /* rate is 12 - 127 Hz; 0x00 - 0x0b and 0x7d (power-up!) are reserved */ | ||
95 | #define LK_PARAM_RATE(r) (LK_PARAM|((r)&0x7f)) | ||
96 | |||
97 | #define LK_SHIFT 1<<0 | ||
98 | #define LK_CTRL 1<<1 | ||
99 | #define LK_LOCK 1<<2 | ||
100 | #define LK_COMP 1<<3 | ||
101 | |||
102 | #define LK_KEY_SHIFT 0xae | ||
103 | #define LK_KEY_CTRL 0xaf | ||
104 | #define LK_KEY_LOCK 0xb0 | ||
105 | #define LK_KEY_COMP 0xb1 | ||
106 | |||
107 | #define LK_KEY_RELEASE 0xb3 /* all keys released */ | ||
108 | #define LK_KEY_REPEAT 0xb4 /* repeat the last key */ | ||
109 | |||
110 | /* status responses */ | ||
111 | #define LK_STAT_RESUME_ERR 0xb5 /* keystrokes lost while inhibited */ | ||
112 | #define LK_STAT_ERROR 0xb6 /* an invalid command received */ | ||
113 | #define LK_STAT_INHIBIT_ACK 0xb7 /* transmission inhibited */ | ||
114 | #define LK_STAT_TEST_ACK 0xb8 /* the factory test mode entered */ | ||
115 | #define LK_STAT_MODE_KEYDOWN 0xb9 /* a key is down on a change */ | ||
116 | /* to the DOWN_UP mode; */ | ||
117 | /* the keycode follows */ | ||
118 | #define LK_STAT_MODE_ACK 0xba /* the mode command succeeded */ | ||
119 | |||
120 | #define LK_STAT_PWRUP_ID 0x01 /* the power-up response start mark */ | ||
121 | #define LK_STAT_PWRUP_OK 0x00 /* the power-up self test OK */ | ||
122 | #define LK_STAT_PWRUP_KDOWN 0x3d /* a key was down during the test */ | ||
123 | #define LK_STAT_PWRUP_ERROR 0x3e /* keyboard self test failure */ | ||
124 | |||
125 | extern unsigned char scancodeRemap[256]; | ||
diff --git a/drivers/tc/tc.c b/drivers/tc/tc.c new file mode 100644 index 000000000000..a89ef4df80c3 --- /dev/null +++ b/drivers/tc/tc.c | |||
@@ -0,0 +1,260 @@ | |||
1 | /* | ||
2 | * tc-init: We assume the TURBOchannel to be up and running so | ||
3 | * just probe for Modules and fill in the global data structure | ||
4 | * tc_bus. | ||
5 | * | ||
6 | * This file is subject to the terms and conditions of the GNU General Public | ||
7 | * License. See the file "COPYING" in the main directory of this archive | ||
8 | * for more details. | ||
9 | * | ||
10 | * Copyright (c) Harald Koerfgen, 1998 | ||
11 | * Copyright (c) 2001, 2003 Maciej W. Rozycki | ||
12 | */ | ||
13 | #include <linux/string.h> | ||
14 | #include <linux/init.h> | ||
15 | #include <linux/ioport.h> | ||
16 | #include <linux/kernel.h> | ||
17 | #include <linux/module.h> | ||
18 | |||
19 | #include <asm/addrspace.h> | ||
20 | #include <asm/errno.h> | ||
21 | #include <asm/dec/machtype.h> | ||
22 | #include <asm/dec/prom.h> | ||
23 | #include <asm/dec/tcinfo.h> | ||
24 | #include <asm/dec/tcmodule.h> | ||
25 | #include <asm/dec/interrupts.h> | ||
26 | #include <asm/paccess.h> | ||
27 | #include <asm/ptrace.h> | ||
28 | |||
29 | #define TC_DEBUG | ||
30 | |||
31 | MODULE_LICENSE("GPL"); | ||
32 | slot_info tc_bus[MAX_SLOT]; | ||
33 | static int num_tcslots; | ||
34 | static tcinfo *info; | ||
35 | |||
36 | unsigned long system_base; | ||
37 | |||
38 | /* | ||
39 | * Interface to the world. Read comment in include/asm-mips/tc.h. | ||
40 | */ | ||
41 | |||
42 | int search_tc_card(const char *name) | ||
43 | { | ||
44 | int slot; | ||
45 | slot_info *sip; | ||
46 | |||
47 | for (slot = 0; slot < num_tcslots; slot++) { | ||
48 | sip = &tc_bus[slot]; | ||
49 | if ((sip->flags & FREE) && | ||
50 | (strncmp(sip->name, name, strlen(name)) == 0)) { | ||
51 | return slot; | ||
52 | } | ||
53 | } | ||
54 | |||
55 | return -ENODEV; | ||
56 | } | ||
57 | |||
58 | void claim_tc_card(int slot) | ||
59 | { | ||
60 | if (tc_bus[slot].flags & IN_USE) { | ||
61 | printk("claim_tc_card: attempting to claim a card already in use\n"); | ||
62 | return; | ||
63 | } | ||
64 | tc_bus[slot].flags &= ~FREE; | ||
65 | tc_bus[slot].flags |= IN_USE; | ||
66 | } | ||
67 | |||
68 | void release_tc_card(int slot) | ||
69 | { | ||
70 | if (tc_bus[slot].flags & FREE) { | ||
71 | printk("release_tc_card: " | ||
72 | "attempting to release a card already free\n"); | ||
73 | return; | ||
74 | } | ||
75 | tc_bus[slot].flags &= ~IN_USE; | ||
76 | tc_bus[slot].flags |= FREE; | ||
77 | } | ||
78 | |||
79 | unsigned long get_tc_base_addr(int slot) | ||
80 | { | ||
81 | return tc_bus[slot].base_addr; | ||
82 | } | ||
83 | |||
84 | unsigned long get_tc_irq_nr(int slot) | ||
85 | { | ||
86 | return tc_bus[slot].interrupt; | ||
87 | } | ||
88 | |||
89 | unsigned long get_tc_speed(void) | ||
90 | { | ||
91 | return 100000 * (10000 / (unsigned long)info->clk_period); | ||
92 | } | ||
93 | |||
94 | /* | ||
95 | * Probing for TURBOchannel modules | ||
96 | */ | ||
97 | static void __init tc_probe(unsigned long startaddr, unsigned long size, | ||
98 | int slots) | ||
99 | { | ||
100 | int i, slot, err; | ||
101 | long offset; | ||
102 | unsigned char pattern[4]; | ||
103 | unsigned char *module; | ||
104 | |||
105 | for (slot = 0; slot < slots; slot++) { | ||
106 | module = (char *)(startaddr + slot * size); | ||
107 | |||
108 | offset = OLDCARD; | ||
109 | |||
110 | err = 0; | ||
111 | err |= get_dbe(pattern[0], module + OLDCARD + TC_PATTERN0); | ||
112 | err |= get_dbe(pattern[1], module + OLDCARD + TC_PATTERN1); | ||
113 | err |= get_dbe(pattern[2], module + OLDCARD + TC_PATTERN2); | ||
114 | err |= get_dbe(pattern[3], module + OLDCARD + TC_PATTERN3); | ||
115 | if (err) | ||
116 | continue; | ||
117 | |||
118 | if (pattern[0] != 0x55 || pattern[1] != 0x00 || | ||
119 | pattern[2] != 0xaa || pattern[3] != 0xff) { | ||
120 | offset = NEWCARD; | ||
121 | |||
122 | err = 0; | ||
123 | err |= get_dbe(pattern[0], module + TC_PATTERN0); | ||
124 | err |= get_dbe(pattern[1], module + TC_PATTERN1); | ||
125 | err |= get_dbe(pattern[2], module + TC_PATTERN2); | ||
126 | err |= get_dbe(pattern[3], module + TC_PATTERN3); | ||
127 | if (err) | ||
128 | continue; | ||
129 | } | ||
130 | |||
131 | if (pattern[0] != 0x55 || pattern[1] != 0x00 || | ||
132 | pattern[2] != 0xaa || pattern[3] != 0xff) | ||
133 | continue; | ||
134 | |||
135 | tc_bus[slot].base_addr = (unsigned long)module; | ||
136 | for(i = 0; i < 8; i++) { | ||
137 | tc_bus[slot].firmware[i] = | ||
138 | module[TC_FIRM_VER + offset + 4 * i]; | ||
139 | tc_bus[slot].vendor[i] = | ||
140 | module[TC_VENDOR + offset + 4 * i]; | ||
141 | tc_bus[slot].name[i] = | ||
142 | module[TC_MODULE + offset + 4 * i]; | ||
143 | } | ||
144 | tc_bus[slot].firmware[8] = 0; | ||
145 | tc_bus[slot].vendor[8] = 0; | ||
146 | tc_bus[slot].name[8] = 0; | ||
147 | /* | ||
148 | * Looks unneccesary, but we may change | ||
149 | * TC? in the future | ||
150 | */ | ||
151 | switch (slot) { | ||
152 | case 0: | ||
153 | tc_bus[slot].interrupt = dec_interrupt[DEC_IRQ_TC0]; | ||
154 | break; | ||
155 | case 1: | ||
156 | tc_bus[slot].interrupt = dec_interrupt[DEC_IRQ_TC1]; | ||
157 | break; | ||
158 | case 2: | ||
159 | tc_bus[slot].interrupt = dec_interrupt[DEC_IRQ_TC2]; | ||
160 | break; | ||
161 | /* | ||
162 | * Yuck! DS5000/200 onboard devices | ||
163 | */ | ||
164 | case 5: | ||
165 | tc_bus[slot].interrupt = dec_interrupt[DEC_IRQ_TC5]; | ||
166 | break; | ||
167 | case 6: | ||
168 | tc_bus[slot].interrupt = dec_interrupt[DEC_IRQ_TC6]; | ||
169 | break; | ||
170 | default: | ||
171 | tc_bus[slot].interrupt = -1; | ||
172 | break; | ||
173 | } | ||
174 | } | ||
175 | } | ||
176 | |||
177 | /* | ||
178 | * the main entry | ||
179 | */ | ||
180 | void __init tc_init(void) | ||
181 | { | ||
182 | int tc_clock; | ||
183 | int i; | ||
184 | unsigned long slot0addr; | ||
185 | unsigned long slot_size; | ||
186 | |||
187 | if (!TURBOCHANNEL) | ||
188 | return; | ||
189 | |||
190 | for (i = 0; i < MAX_SLOT; i++) { | ||
191 | tc_bus[i].base_addr = 0; | ||
192 | tc_bus[i].name[0] = 0; | ||
193 | tc_bus[i].vendor[0] = 0; | ||
194 | tc_bus[i].firmware[0] = 0; | ||
195 | tc_bus[i].interrupt = -1; | ||
196 | tc_bus[i].flags = FREE; | ||
197 | } | ||
198 | |||
199 | info = (tcinfo *) rex_gettcinfo(); | ||
200 | slot0addr = (unsigned long)KSEG1ADDR(rex_slot_address(0)); | ||
201 | |||
202 | switch (mips_machtype) { | ||
203 | case MACH_DS5000_200: | ||
204 | num_tcslots = 7; | ||
205 | break; | ||
206 | case MACH_DS5000_1XX: | ||
207 | case MACH_DS5000_2X0: | ||
208 | case MACH_DS5900: | ||
209 | num_tcslots = 3; | ||
210 | break; | ||
211 | case MACH_DS5000_XX: | ||
212 | default: | ||
213 | num_tcslots = 2; | ||
214 | break; | ||
215 | } | ||
216 | |||
217 | tc_clock = 10000 / info->clk_period; | ||
218 | |||
219 | if (TURBOCHANNEL && info->slot_size && slot0addr) { | ||
220 | printk("TURBOchannel rev. %1d at %2d.%1d MHz ", info->revision, | ||
221 | tc_clock / 10, tc_clock % 10); | ||
222 | printk("(with%s parity)\n", info->parity ? "" : "out"); | ||
223 | |||
224 | slot_size = info->slot_size << 20; | ||
225 | |||
226 | tc_probe(slot0addr, slot_size, num_tcslots); | ||
227 | |||
228 | /* | ||
229 | * All TURBOchannel DECstations have the onboard devices | ||
230 | * where the (num_tcslots + 0 or 1 on DS5k/xx) Option Module | ||
231 | * would be. | ||
232 | */ | ||
233 | if(mips_machtype == MACH_DS5000_XX) | ||
234 | i = 1; | ||
235 | else | ||
236 | i = 0; | ||
237 | |||
238 | system_base = slot0addr + slot_size * (num_tcslots + i); | ||
239 | |||
240 | #ifdef TC_DEBUG | ||
241 | for (i = 0; i < num_tcslots; i++) | ||
242 | if (tc_bus[i].base_addr) { | ||
243 | printk(" slot %d: ", i); | ||
244 | printk("%s %s %s\n", tc_bus[i].vendor, | ||
245 | tc_bus[i].name, tc_bus[i].firmware); | ||
246 | } | ||
247 | #endif | ||
248 | ioport_resource.end = KSEG2 - 1; | ||
249 | } | ||
250 | } | ||
251 | |||
252 | subsys_initcall(tc_init); | ||
253 | |||
254 | EXPORT_SYMBOL(search_tc_card); | ||
255 | EXPORT_SYMBOL(claim_tc_card); | ||
256 | EXPORT_SYMBOL(release_tc_card); | ||
257 | EXPORT_SYMBOL(get_tc_base_addr); | ||
258 | EXPORT_SYMBOL(get_tc_irq_nr); | ||
259 | EXPORT_SYMBOL(get_tc_speed); | ||
260 | EXPORT_SYMBOL(system_base); | ||
diff --git a/drivers/tc/zs.c b/drivers/tc/zs.c new file mode 100644 index 000000000000..4382ee60b6a8 --- /dev/null +++ b/drivers/tc/zs.c | |||
@@ -0,0 +1,2253 @@ | |||
1 | /* | ||
2 | * decserial.c: Serial port driver for IOASIC DECstations. | ||
3 | * | ||
4 | * Derived from drivers/sbus/char/sunserial.c by Paul Mackerras. | ||
5 | * Derived from drivers/macintosh/macserial.c by Harald Koerfgen. | ||
6 | * | ||
7 | * DECstation changes | ||
8 | * Copyright (C) 1998-2000 Harald Koerfgen | ||
9 | * Copyright (C) 2000, 2001, 2002, 2003, 2004 Maciej W. Rozycki | ||
10 | * | ||
11 | * For the rest of the code the original Copyright applies: | ||
12 | * Copyright (C) 1996 Paul Mackerras (Paul.Mackerras@cs.anu.edu.au) | ||
13 | * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) | ||
14 | * | ||
15 | * | ||
16 | * Note: for IOASIC systems the wiring is as follows: | ||
17 | * | ||
18 | * mouse/keyboard: | ||
19 | * DIN-7 MJ-4 signal SCC | ||
20 | * 2 1 TxD <- A.TxD | ||
21 | * 3 4 RxD -> A.RxD | ||
22 | * | ||
23 | * EIA-232/EIA-423: | ||
24 | * DB-25 MMJ-6 signal SCC | ||
25 | * 2 2 TxD <- B.TxD | ||
26 | * 3 5 RxD -> B.RxD | ||
27 | * 4 RTS <- ~A.RTS | ||
28 | * 5 CTS -> ~B.CTS | ||
29 | * 6 6 DSR -> ~A.SYNC | ||
30 | * 8 CD -> ~B.DCD | ||
31 | * 12 DSRS(DCE) -> ~A.CTS (*) | ||
32 | * 15 TxC -> B.TxC | ||
33 | * 17 RxC -> B.RxC | ||
34 | * 20 1 DTR <- ~A.DTR | ||
35 | * 22 RI -> ~A.DCD | ||
36 | * 23 DSRS(DTE) <- ~B.RTS | ||
37 | * | ||
38 | * (*) EIA-232 defines the signal at this pin to be SCD, while DSRS(DCE) | ||
39 | * is shared with DSRS(DTE) at pin 23. | ||
40 | */ | ||
41 | |||
42 | #include <linux/config.h> | ||
43 | #include <linux/errno.h> | ||
44 | #include <linux/signal.h> | ||
45 | #include <linux/sched.h> | ||
46 | #include <linux/timer.h> | ||
47 | #include <linux/interrupt.h> | ||
48 | #include <linux/tty.h> | ||
49 | #include <linux/tty_flip.h> | ||
50 | #include <linux/major.h> | ||
51 | #include <linux/string.h> | ||
52 | #include <linux/fcntl.h> | ||
53 | #include <linux/mm.h> | ||
54 | #include <linux/kernel.h> | ||
55 | #include <linux/delay.h> | ||
56 | #include <linux/init.h> | ||
57 | #include <linux/ioport.h> | ||
58 | #ifdef CONFIG_SERIAL_DEC_CONSOLE | ||
59 | #include <linux/console.h> | ||
60 | #endif | ||
61 | |||
62 | #include <asm/io.h> | ||
63 | #include <asm/pgtable.h> | ||
64 | #include <asm/irq.h> | ||
65 | #include <asm/system.h> | ||
66 | #include <asm/uaccess.h> | ||
67 | #include <asm/bootinfo.h> | ||
68 | #include <asm/dec/serial.h> | ||
69 | |||
70 | #ifdef CONFIG_MACH_DECSTATION | ||
71 | #include <asm/dec/interrupts.h> | ||
72 | #include <asm/dec/machtype.h> | ||
73 | #include <asm/dec/tc.h> | ||
74 | #include <asm/dec/ioasic_addrs.h> | ||
75 | #endif | ||
76 | #ifdef CONFIG_KGDB | ||
77 | #include <asm/kgdb.h> | ||
78 | #endif | ||
79 | #ifdef CONFIG_MAGIC_SYSRQ | ||
80 | #include <linux/sysrq.h> | ||
81 | #endif | ||
82 | |||
83 | #include "zs.h" | ||
84 | |||
85 | /* | ||
86 | * It would be nice to dynamically allocate everything that | ||
87 | * depends on NUM_SERIAL, so we could support any number of | ||
88 | * Z8530s, but for now... | ||
89 | */ | ||
90 | #define NUM_SERIAL 2 /* Max number of ZS chips supported */ | ||
91 | #define NUM_CHANNELS (NUM_SERIAL * 2) /* 2 channels per chip */ | ||
92 | #define CHANNEL_A_NR (zs_parms->channel_a_offset > zs_parms->channel_b_offset) | ||
93 | /* Number of channel A in the chip */ | ||
94 | #define ZS_CHAN_IO_SIZE 8 | ||
95 | #define ZS_CLOCK 7372800 /* Z8530 RTxC input clock rate */ | ||
96 | |||
97 | #define RECOVERY_DELAY udelay(2) | ||
98 | |||
99 | struct zs_parms { | ||
100 | unsigned long scc0; | ||
101 | unsigned long scc1; | ||
102 | int channel_a_offset; | ||
103 | int channel_b_offset; | ||
104 | int irq0; | ||
105 | int irq1; | ||
106 | int clock; | ||
107 | }; | ||
108 | |||
109 | static struct zs_parms *zs_parms; | ||
110 | |||
111 | #ifdef CONFIG_MACH_DECSTATION | ||
112 | static struct zs_parms ds_parms = { | ||
113 | scc0 : IOASIC_SCC0, | ||
114 | scc1 : IOASIC_SCC1, | ||
115 | channel_a_offset : 1, | ||
116 | channel_b_offset : 9, | ||
117 | irq0 : -1, | ||
118 | irq1 : -1, | ||
119 | clock : ZS_CLOCK | ||
120 | }; | ||
121 | #endif | ||
122 | |||
123 | #ifdef CONFIG_MACH_DECSTATION | ||
124 | #define DS_BUS_PRESENT (IOASIC) | ||
125 | #else | ||
126 | #define DS_BUS_PRESENT 0 | ||
127 | #endif | ||
128 | |||
129 | #define BUS_PRESENT (DS_BUS_PRESENT) | ||
130 | |||
131 | struct dec_zschannel zs_channels[NUM_CHANNELS]; | ||
132 | struct dec_serial zs_soft[NUM_CHANNELS]; | ||
133 | int zs_channels_found; | ||
134 | struct dec_serial *zs_chain; /* list of all channels */ | ||
135 | |||
136 | struct tty_struct zs_ttys[NUM_CHANNELS]; | ||
137 | |||
138 | #ifdef CONFIG_SERIAL_DEC_CONSOLE | ||
139 | static struct console sercons; | ||
140 | #endif | ||
141 | #if defined(CONFIG_SERIAL_DEC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) && \ | ||
142 | !defined(MODULE) | ||
143 | static unsigned long break_pressed; /* break, really ... */ | ||
144 | #endif | ||
145 | |||
146 | static unsigned char zs_init_regs[16] __initdata = { | ||
147 | 0, /* write 0 */ | ||
148 | 0, /* write 1 */ | ||
149 | 0, /* write 2 */ | ||
150 | 0, /* write 3 */ | ||
151 | (X16CLK), /* write 4 */ | ||
152 | 0, /* write 5 */ | ||
153 | 0, 0, 0, /* write 6, 7, 8 */ | ||
154 | (MIE | DLC | NV), /* write 9 */ | ||
155 | (NRZ), /* write 10 */ | ||
156 | (TCBR | RCBR), /* write 11 */ | ||
157 | 0, 0, /* BRG time constant, write 12 + 13 */ | ||
158 | (BRSRC | BRENABL), /* write 14 */ | ||
159 | 0 /* write 15 */ | ||
160 | }; | ||
161 | |||
162 | DECLARE_TASK_QUEUE(tq_zs_serial); | ||
163 | |||
164 | static struct tty_driver *serial_driver; | ||
165 | |||
166 | /* serial subtype definitions */ | ||
167 | #define SERIAL_TYPE_NORMAL 1 | ||
168 | |||
169 | /* number of characters left in xmit buffer before we ask for more */ | ||
170 | #define WAKEUP_CHARS 256 | ||
171 | |||
172 | /* | ||
173 | * Debugging. | ||
174 | */ | ||
175 | #undef SERIAL_DEBUG_OPEN | ||
176 | #undef SERIAL_DEBUG_FLOW | ||
177 | #undef SERIAL_DEBUG_THROTTLE | ||
178 | #undef SERIAL_PARANOIA_CHECK | ||
179 | |||
180 | #undef ZS_DEBUG_REGS | ||
181 | |||
182 | #ifdef SERIAL_DEBUG_THROTTLE | ||
183 | #define _tty_name(tty,buf) tty_name(tty,buf) | ||
184 | #endif | ||
185 | |||
186 | #define RS_STROBE_TIME 10 | ||
187 | #define RS_ISR_PASS_LIMIT 256 | ||
188 | |||
189 | #define _INLINE_ inline | ||
190 | |||
191 | static void probe_sccs(void); | ||
192 | static void change_speed(struct dec_serial *info); | ||
193 | static void rs_wait_until_sent(struct tty_struct *tty, int timeout); | ||
194 | |||
195 | /* | ||
196 | * tmp_buf is used as a temporary buffer by serial_write. We need to | ||
197 | * lock it in case the copy_from_user blocks while swapping in a page, | ||
198 | * and some other program tries to do a serial write at the same time. | ||
199 | * Since the lock will only come under contention when the system is | ||
200 | * swapping and available memory is low, it makes sense to share one | ||
201 | * buffer across all the serial ports, since it significantly saves | ||
202 | * memory if large numbers of serial ports are open. | ||
203 | */ | ||
204 | static unsigned char tmp_buf[4096]; /* This is cheating */ | ||
205 | static DECLARE_MUTEX(tmp_buf_sem); | ||
206 | |||
207 | static inline int serial_paranoia_check(struct dec_serial *info, | ||
208 | char *name, const char *routine) | ||
209 | { | ||
210 | #ifdef SERIAL_PARANOIA_CHECK | ||
211 | static const char *badmagic = | ||
212 | "Warning: bad magic number for serial struct %s in %s\n"; | ||
213 | static const char *badinfo = | ||
214 | "Warning: null mac_serial for %s in %s\n"; | ||
215 | |||
216 | if (!info) { | ||
217 | printk(badinfo, name, routine); | ||
218 | return 1; | ||
219 | } | ||
220 | if (info->magic != SERIAL_MAGIC) { | ||
221 | printk(badmagic, name, routine); | ||
222 | return 1; | ||
223 | } | ||
224 | #endif | ||
225 | return 0; | ||
226 | } | ||
227 | |||
228 | /* | ||
229 | * This is used to figure out the divisor speeds and the timeouts | ||
230 | */ | ||
231 | static int baud_table[] = { | ||
232 | 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, | ||
233 | 9600, 19200, 38400, 57600, 115200, 0 }; | ||
234 | |||
235 | /* | ||
236 | * Reading and writing Z8530 registers. | ||
237 | */ | ||
238 | static inline unsigned char read_zsreg(struct dec_zschannel *channel, | ||
239 | unsigned char reg) | ||
240 | { | ||
241 | unsigned char retval; | ||
242 | |||
243 | if (reg != 0) { | ||
244 | *channel->control = reg & 0xf; | ||
245 | fast_iob(); RECOVERY_DELAY; | ||
246 | } | ||
247 | retval = *channel->control; | ||
248 | RECOVERY_DELAY; | ||
249 | return retval; | ||
250 | } | ||
251 | |||
252 | static inline void write_zsreg(struct dec_zschannel *channel, | ||
253 | unsigned char reg, unsigned char value) | ||
254 | { | ||
255 | if (reg != 0) { | ||
256 | *channel->control = reg & 0xf; | ||
257 | fast_iob(); RECOVERY_DELAY; | ||
258 | } | ||
259 | *channel->control = value; | ||
260 | fast_iob(); RECOVERY_DELAY; | ||
261 | return; | ||
262 | } | ||
263 | |||
264 | static inline unsigned char read_zsdata(struct dec_zschannel *channel) | ||
265 | { | ||
266 | unsigned char retval; | ||
267 | |||
268 | retval = *channel->data; | ||
269 | RECOVERY_DELAY; | ||
270 | return retval; | ||
271 | } | ||
272 | |||
273 | static inline void write_zsdata(struct dec_zschannel *channel, | ||
274 | unsigned char value) | ||
275 | { | ||
276 | *channel->data = value; | ||
277 | fast_iob(); RECOVERY_DELAY; | ||
278 | return; | ||
279 | } | ||
280 | |||
281 | static inline void load_zsregs(struct dec_zschannel *channel, | ||
282 | unsigned char *regs) | ||
283 | { | ||
284 | /* ZS_CLEARERR(channel); | ||
285 | ZS_CLEARFIFO(channel); */ | ||
286 | /* Load 'em up */ | ||
287 | write_zsreg(channel, R3, regs[R3] & ~RxENABLE); | ||
288 | write_zsreg(channel, R5, regs[R5] & ~TxENAB); | ||
289 | write_zsreg(channel, R4, regs[R4]); | ||
290 | write_zsreg(channel, R9, regs[R9]); | ||
291 | write_zsreg(channel, R1, regs[R1]); | ||
292 | write_zsreg(channel, R2, regs[R2]); | ||
293 | write_zsreg(channel, R10, regs[R10]); | ||
294 | write_zsreg(channel, R11, regs[R11]); | ||
295 | write_zsreg(channel, R12, regs[R12]); | ||
296 | write_zsreg(channel, R13, regs[R13]); | ||
297 | write_zsreg(channel, R14, regs[R14]); | ||
298 | write_zsreg(channel, R15, regs[R15]); | ||
299 | write_zsreg(channel, R3, regs[R3]); | ||
300 | write_zsreg(channel, R5, regs[R5]); | ||
301 | return; | ||
302 | } | ||
303 | |||
304 | /* Sets or clears DTR/RTS on the requested line */ | ||
305 | static inline void zs_rtsdtr(struct dec_serial *info, int which, int set) | ||
306 | { | ||
307 | unsigned long flags; | ||
308 | |||
309 | |||
310 | save_flags(flags); cli(); | ||
311 | if (info->zs_channel != info->zs_chan_a) { | ||
312 | if (set) { | ||
313 | info->zs_chan_a->curregs[5] |= (which & (RTS | DTR)); | ||
314 | } else { | ||
315 | info->zs_chan_a->curregs[5] &= ~(which & (RTS | DTR)); | ||
316 | } | ||
317 | write_zsreg(info->zs_chan_a, 5, info->zs_chan_a->curregs[5]); | ||
318 | } | ||
319 | restore_flags(flags); | ||
320 | } | ||
321 | |||
322 | /* Utility routines for the Zilog */ | ||
323 | static inline int get_zsbaud(struct dec_serial *ss) | ||
324 | { | ||
325 | struct dec_zschannel *channel = ss->zs_channel; | ||
326 | int brg; | ||
327 | |||
328 | /* The baud rate is split up between two 8-bit registers in | ||
329 | * what is termed 'BRG time constant' format in my docs for | ||
330 | * the chip, it is a function of the clk rate the chip is | ||
331 | * receiving which happens to be constant. | ||
332 | */ | ||
333 | brg = (read_zsreg(channel, 13) << 8); | ||
334 | brg |= read_zsreg(channel, 12); | ||
335 | return BRG_TO_BPS(brg, (zs_parms->clock/(ss->clk_divisor))); | ||
336 | } | ||
337 | |||
338 | /* On receive, this clears errors and the receiver interrupts */ | ||
339 | static inline void rs_recv_clear(struct dec_zschannel *zsc) | ||
340 | { | ||
341 | write_zsreg(zsc, 0, ERR_RES); | ||
342 | write_zsreg(zsc, 0, RES_H_IUS); /* XXX this is unnecessary */ | ||
343 | } | ||
344 | |||
345 | /* | ||
346 | * ---------------------------------------------------------------------- | ||
347 | * | ||
348 | * Here starts the interrupt handling routines. All of the following | ||
349 | * subroutines are declared as inline and are folded into | ||
350 | * rs_interrupt(). They were separated out for readability's sake. | ||
351 | * | ||
352 | * - Ted Ts'o (tytso@mit.edu), 7-Mar-93 | ||
353 | * ----------------------------------------------------------------------- | ||
354 | */ | ||
355 | |||
356 | /* | ||
357 | * This routine is used by the interrupt handler to schedule | ||
358 | * processing in the software interrupt portion of the driver. | ||
359 | */ | ||
360 | static _INLINE_ void rs_sched_event(struct dec_serial *info, | ||
361 | int event) | ||
362 | { | ||
363 | info->event |= 1 << event; | ||
364 | queue_task(&info->tqueue, &tq_zs_serial); | ||
365 | mark_bh(SERIAL_BH); | ||
366 | } | ||
367 | |||
368 | static _INLINE_ void receive_chars(struct dec_serial *info, | ||
369 | struct pt_regs *regs) | ||
370 | { | ||
371 | struct tty_struct *tty = info->tty; | ||
372 | unsigned char ch, stat, flag; | ||
373 | |||
374 | while ((read_zsreg(info->zs_channel, R0) & Rx_CH_AV) != 0) { | ||
375 | |||
376 | stat = read_zsreg(info->zs_channel, R1); | ||
377 | ch = read_zsdata(info->zs_channel); | ||
378 | |||
379 | if (!tty && (!info->hook || !info->hook->rx_char)) | ||
380 | continue; | ||
381 | |||
382 | flag = TTY_NORMAL; | ||
383 | if (info->tty_break) { | ||
384 | info->tty_break = 0; | ||
385 | flag = TTY_BREAK; | ||
386 | if (info->flags & ZILOG_SAK) | ||
387 | do_SAK(tty); | ||
388 | /* Ignore the null char got when BREAK is removed. */ | ||
389 | if (ch == 0) | ||
390 | continue; | ||
391 | } else { | ||
392 | if (stat & Rx_OVR) { | ||
393 | flag = TTY_OVERRUN; | ||
394 | } else if (stat & FRM_ERR) { | ||
395 | flag = TTY_FRAME; | ||
396 | } else if (stat & PAR_ERR) { | ||
397 | flag = TTY_PARITY; | ||
398 | } | ||
399 | if (flag != TTY_NORMAL) | ||
400 | /* reset the error indication */ | ||
401 | write_zsreg(info->zs_channel, R0, ERR_RES); | ||
402 | } | ||
403 | |||
404 | #if defined(CONFIG_SERIAL_DEC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) && \ | ||
405 | !defined(MODULE) | ||
406 | if (break_pressed && info->line == sercons.index) { | ||
407 | /* Ignore the null char got when BREAK is removed. */ | ||
408 | if (ch == 0) | ||
409 | continue; | ||
410 | if (time_before(jiffies, break_pressed + HZ * 5)) { | ||
411 | handle_sysrq(ch, regs, NULL); | ||
412 | break_pressed = 0; | ||
413 | continue; | ||
414 | } | ||
415 | break_pressed = 0; | ||
416 | } | ||
417 | #endif | ||
418 | |||
419 | if (info->hook && info->hook->rx_char) { | ||
420 | (*info->hook->rx_char)(ch, flag); | ||
421 | return; | ||
422 | } | ||
423 | |||
424 | tty_insert_flip_char(tty, ch, flag); | ||
425 | } | ||
426 | if (tty) | ||
427 | tty_flip_buffer_push(tty); | ||
428 | } | ||
429 | |||
430 | static void transmit_chars(struct dec_serial *info) | ||
431 | { | ||
432 | if ((read_zsreg(info->zs_channel, R0) & Tx_BUF_EMP) == 0) | ||
433 | return; | ||
434 | info->tx_active = 0; | ||
435 | |||
436 | if (info->x_char) { | ||
437 | /* Send next char */ | ||
438 | write_zsdata(info->zs_channel, info->x_char); | ||
439 | info->x_char = 0; | ||
440 | info->tx_active = 1; | ||
441 | return; | ||
442 | } | ||
443 | |||
444 | if ((info->xmit_cnt <= 0) || (info->tty && info->tty->stopped) | ||
445 | || info->tx_stopped) { | ||
446 | write_zsreg(info->zs_channel, R0, RES_Tx_P); | ||
447 | return; | ||
448 | } | ||
449 | /* Send char */ | ||
450 | write_zsdata(info->zs_channel, info->xmit_buf[info->xmit_tail++]); | ||
451 | info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1); | ||
452 | info->xmit_cnt--; | ||
453 | info->tx_active = 1; | ||
454 | |||
455 | if (info->xmit_cnt < WAKEUP_CHARS) | ||
456 | rs_sched_event(info, RS_EVENT_WRITE_WAKEUP); | ||
457 | } | ||
458 | |||
459 | static _INLINE_ void status_handle(struct dec_serial *info) | ||
460 | { | ||
461 | unsigned char stat; | ||
462 | |||
463 | /* Get status from Read Register 0 */ | ||
464 | stat = read_zsreg(info->zs_channel, R0); | ||
465 | |||
466 | if ((stat & BRK_ABRT) && !(info->read_reg_zero & BRK_ABRT)) { | ||
467 | #if defined(CONFIG_SERIAL_DEC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) && \ | ||
468 | !defined(MODULE) | ||
469 | if (info->line == sercons.index) { | ||
470 | if (!break_pressed) | ||
471 | break_pressed = jiffies; | ||
472 | } else | ||
473 | #endif | ||
474 | info->tty_break = 1; | ||
475 | } | ||
476 | |||
477 | if (info->zs_channel != info->zs_chan_a) { | ||
478 | |||
479 | /* Check for DCD transitions */ | ||
480 | if (info->tty && !C_CLOCAL(info->tty) && | ||
481 | ((stat ^ info->read_reg_zero) & DCD) != 0 ) { | ||
482 | if (stat & DCD) { | ||
483 | wake_up_interruptible(&info->open_wait); | ||
484 | } else { | ||
485 | tty_hangup(info->tty); | ||
486 | } | ||
487 | } | ||
488 | |||
489 | /* Check for CTS transitions */ | ||
490 | if (info->tty && C_CRTSCTS(info->tty)) { | ||
491 | if ((stat & CTS) != 0) { | ||
492 | if (info->tx_stopped) { | ||
493 | info->tx_stopped = 0; | ||
494 | if (!info->tx_active) | ||
495 | transmit_chars(info); | ||
496 | } | ||
497 | } else { | ||
498 | info->tx_stopped = 1; | ||
499 | } | ||
500 | } | ||
501 | |||
502 | } | ||
503 | |||
504 | /* Clear status condition... */ | ||
505 | write_zsreg(info->zs_channel, R0, RES_EXT_INT); | ||
506 | info->read_reg_zero = stat; | ||
507 | } | ||
508 | |||
509 | /* | ||
510 | * This is the serial driver's generic interrupt routine | ||
511 | */ | ||
512 | void rs_interrupt(int irq, void *dev_id, struct pt_regs * regs) | ||
513 | { | ||
514 | struct dec_serial *info = (struct dec_serial *) dev_id; | ||
515 | unsigned char zs_intreg; | ||
516 | int shift; | ||
517 | |||
518 | /* NOTE: The read register 3, which holds the irq status, | ||
519 | * does so for both channels on each chip. Although | ||
520 | * the status value itself must be read from the A | ||
521 | * channel and is only valid when read from channel A. | ||
522 | * Yes... broken hardware... | ||
523 | */ | ||
524 | #define CHAN_IRQMASK (CHBRxIP | CHBTxIP | CHBEXT) | ||
525 | |||
526 | if (info->zs_chan_a == info->zs_channel) | ||
527 | shift = 3; /* Channel A */ | ||
528 | else | ||
529 | shift = 0; /* Channel B */ | ||
530 | |||
531 | for (;;) { | ||
532 | zs_intreg = read_zsreg(info->zs_chan_a, R3) >> shift; | ||
533 | if ((zs_intreg & CHAN_IRQMASK) == 0) | ||
534 | break; | ||
535 | |||
536 | if (zs_intreg & CHBRxIP) { | ||
537 | receive_chars(info, regs); | ||
538 | } | ||
539 | if (zs_intreg & CHBTxIP) { | ||
540 | transmit_chars(info); | ||
541 | } | ||
542 | if (zs_intreg & CHBEXT) { | ||
543 | status_handle(info); | ||
544 | } | ||
545 | } | ||
546 | |||
547 | /* Why do we need this ? */ | ||
548 | write_zsreg(info->zs_channel, 0, RES_H_IUS); | ||
549 | } | ||
550 | |||
551 | #ifdef ZS_DEBUG_REGS | ||
552 | void zs_dump (void) { | ||
553 | int i, j; | ||
554 | for (i = 0; i < zs_channels_found; i++) { | ||
555 | struct dec_zschannel *ch = &zs_channels[i]; | ||
556 | if ((long)ch->control == UNI_IO_BASE+UNI_SCC1A_CTRL) { | ||
557 | for (j = 0; j < 15; j++) { | ||
558 | printk("W%d = 0x%x\t", | ||
559 | j, (int)ch->curregs[j]); | ||
560 | } | ||
561 | for (j = 0; j < 15; j++) { | ||
562 | printk("R%d = 0x%x\t", | ||
563 | j, (int)read_zsreg(ch,j)); | ||
564 | } | ||
565 | printk("\n\n"); | ||
566 | } | ||
567 | } | ||
568 | } | ||
569 | #endif | ||
570 | |||
571 | /* | ||
572 | * ------------------------------------------------------------------- | ||
573 | * Here ends the serial interrupt routines. | ||
574 | * ------------------------------------------------------------------- | ||
575 | */ | ||
576 | |||
577 | /* | ||
578 | * ------------------------------------------------------------ | ||
579 | * rs_stop() and rs_start() | ||
580 | * | ||
581 | * This routines are called before setting or resetting tty->stopped. | ||
582 | * ------------------------------------------------------------ | ||
583 | */ | ||
584 | static void rs_stop(struct tty_struct *tty) | ||
585 | { | ||
586 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
587 | unsigned long flags; | ||
588 | |||
589 | if (serial_paranoia_check(info, tty->name, "rs_stop")) | ||
590 | return; | ||
591 | |||
592 | #if 1 | ||
593 | save_flags(flags); cli(); | ||
594 | if (info->zs_channel->curregs[5] & TxENAB) { | ||
595 | info->zs_channel->curregs[5] &= ~TxENAB; | ||
596 | write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]); | ||
597 | } | ||
598 | restore_flags(flags); | ||
599 | #endif | ||
600 | } | ||
601 | |||
602 | static void rs_start(struct tty_struct *tty) | ||
603 | { | ||
604 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
605 | unsigned long flags; | ||
606 | |||
607 | if (serial_paranoia_check(info, tty->name, "rs_start")) | ||
608 | return; | ||
609 | |||
610 | save_flags(flags); cli(); | ||
611 | #if 1 | ||
612 | if (info->xmit_cnt && info->xmit_buf && !(info->zs_channel->curregs[5] & TxENAB)) { | ||
613 | info->zs_channel->curregs[5] |= TxENAB; | ||
614 | write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]); | ||
615 | } | ||
616 | #else | ||
617 | if (info->xmit_cnt && info->xmit_buf && !info->tx_active) { | ||
618 | transmit_chars(info); | ||
619 | } | ||
620 | #endif | ||
621 | restore_flags(flags); | ||
622 | } | ||
623 | |||
624 | /* | ||
625 | * This routine is used to handle the "bottom half" processing for the | ||
626 | * serial driver, known also the "software interrupt" processing. | ||
627 | * This processing is done at the kernel interrupt level, after the | ||
628 | * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON. This | ||
629 | * is where time-consuming activities which can not be done in the | ||
630 | * interrupt driver proper are done; the interrupt driver schedules | ||
631 | * them using rs_sched_event(), and they get done here. | ||
632 | */ | ||
633 | static void do_serial_bh(void) | ||
634 | { | ||
635 | run_task_queue(&tq_zs_serial); | ||
636 | } | ||
637 | |||
638 | static void do_softint(void *private_) | ||
639 | { | ||
640 | struct dec_serial *info = (struct dec_serial *) private_; | ||
641 | struct tty_struct *tty; | ||
642 | |||
643 | tty = info->tty; | ||
644 | if (!tty) | ||
645 | return; | ||
646 | |||
647 | if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) { | ||
648 | tty_wakeup(tty); | ||
649 | } | ||
650 | } | ||
651 | |||
652 | int zs_startup(struct dec_serial * info) | ||
653 | { | ||
654 | unsigned long flags; | ||
655 | |||
656 | if (info->flags & ZILOG_INITIALIZED) | ||
657 | return 0; | ||
658 | |||
659 | if (!info->xmit_buf) { | ||
660 | info->xmit_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL); | ||
661 | if (!info->xmit_buf) | ||
662 | return -ENOMEM; | ||
663 | } | ||
664 | |||
665 | save_flags(flags); cli(); | ||
666 | |||
667 | #ifdef SERIAL_DEBUG_OPEN | ||
668 | printk("starting up ttyS%d (irq %d)...", info->line, info->irq); | ||
669 | #endif | ||
670 | |||
671 | /* | ||
672 | * Clear the receive FIFO. | ||
673 | */ | ||
674 | ZS_CLEARFIFO(info->zs_channel); | ||
675 | info->xmit_fifo_size = 1; | ||
676 | |||
677 | /* | ||
678 | * Clear the interrupt registers. | ||
679 | */ | ||
680 | write_zsreg(info->zs_channel, R0, ERR_RES); | ||
681 | write_zsreg(info->zs_channel, R0, RES_H_IUS); | ||
682 | |||
683 | /* | ||
684 | * Set the speed of the serial port | ||
685 | */ | ||
686 | change_speed(info); | ||
687 | |||
688 | /* | ||
689 | * Turn on RTS and DTR. | ||
690 | */ | ||
691 | zs_rtsdtr(info, RTS | DTR, 1); | ||
692 | |||
693 | /* | ||
694 | * Finally, enable sequencing and interrupts | ||
695 | */ | ||
696 | info->zs_channel->curregs[R1] &= ~RxINT_MASK; | ||
697 | info->zs_channel->curregs[R1] |= (RxINT_ALL | TxINT_ENAB | | ||
698 | EXT_INT_ENAB); | ||
699 | info->zs_channel->curregs[R3] |= RxENABLE; | ||
700 | info->zs_channel->curregs[R5] |= TxENAB; | ||
701 | info->zs_channel->curregs[R15] |= (DCDIE | CTSIE | TxUIE | BRKIE); | ||
702 | write_zsreg(info->zs_channel, R1, info->zs_channel->curregs[R1]); | ||
703 | write_zsreg(info->zs_channel, R3, info->zs_channel->curregs[R3]); | ||
704 | write_zsreg(info->zs_channel, R5, info->zs_channel->curregs[R5]); | ||
705 | write_zsreg(info->zs_channel, R15, info->zs_channel->curregs[R15]); | ||
706 | |||
707 | /* | ||
708 | * And clear the interrupt registers again for luck. | ||
709 | */ | ||
710 | write_zsreg(info->zs_channel, R0, ERR_RES); | ||
711 | write_zsreg(info->zs_channel, R0, RES_H_IUS); | ||
712 | |||
713 | /* Save the current value of RR0 */ | ||
714 | info->read_reg_zero = read_zsreg(info->zs_channel, R0); | ||
715 | |||
716 | if (info->tty) | ||
717 | clear_bit(TTY_IO_ERROR, &info->tty->flags); | ||
718 | info->xmit_cnt = info->xmit_head = info->xmit_tail = 0; | ||
719 | |||
720 | info->flags |= ZILOG_INITIALIZED; | ||
721 | restore_flags(flags); | ||
722 | return 0; | ||
723 | } | ||
724 | |||
725 | /* | ||
726 | * This routine will shutdown a serial port; interrupts are disabled, and | ||
727 | * DTR is dropped if the hangup on close termio flag is on. | ||
728 | */ | ||
729 | static void shutdown(struct dec_serial * info) | ||
730 | { | ||
731 | unsigned long flags; | ||
732 | |||
733 | if (!(info->flags & ZILOG_INITIALIZED)) | ||
734 | return; | ||
735 | |||
736 | #ifdef SERIAL_DEBUG_OPEN | ||
737 | printk("Shutting down serial port %d (irq %d)....", info->line, | ||
738 | info->irq); | ||
739 | #endif | ||
740 | |||
741 | save_flags(flags); cli(); /* Disable interrupts */ | ||
742 | |||
743 | if (info->xmit_buf) { | ||
744 | free_page((unsigned long) info->xmit_buf); | ||
745 | info->xmit_buf = 0; | ||
746 | } | ||
747 | |||
748 | info->zs_channel->curregs[1] = 0; | ||
749 | write_zsreg(info->zs_channel, 1, info->zs_channel->curregs[1]); /* no interrupts */ | ||
750 | |||
751 | info->zs_channel->curregs[3] &= ~RxENABLE; | ||
752 | write_zsreg(info->zs_channel, 3, info->zs_channel->curregs[3]); | ||
753 | |||
754 | info->zs_channel->curregs[5] &= ~TxENAB; | ||
755 | write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]); | ||
756 | if (!info->tty || C_HUPCL(info->tty)) { | ||
757 | zs_rtsdtr(info, RTS | DTR, 0); | ||
758 | } | ||
759 | |||
760 | if (info->tty) | ||
761 | set_bit(TTY_IO_ERROR, &info->tty->flags); | ||
762 | |||
763 | info->flags &= ~ZILOG_INITIALIZED; | ||
764 | restore_flags(flags); | ||
765 | } | ||
766 | |||
767 | /* | ||
768 | * This routine is called to set the UART divisor registers to match | ||
769 | * the specified baud rate for a serial port. | ||
770 | */ | ||
771 | static void change_speed(struct dec_serial *info) | ||
772 | { | ||
773 | unsigned cflag; | ||
774 | int i; | ||
775 | int brg, bits; | ||
776 | unsigned long flags; | ||
777 | |||
778 | if (!info->hook) { | ||
779 | if (!info->tty || !info->tty->termios) | ||
780 | return; | ||
781 | cflag = info->tty->termios->c_cflag; | ||
782 | if (!info->port) | ||
783 | return; | ||
784 | } else { | ||
785 | cflag = info->hook->cflags; | ||
786 | } | ||
787 | |||
788 | i = cflag & CBAUD; | ||
789 | if (i & CBAUDEX) { | ||
790 | i &= ~CBAUDEX; | ||
791 | if (i < 1 || i > 2) { | ||
792 | if (!info->hook) | ||
793 | info->tty->termios->c_cflag &= ~CBAUDEX; | ||
794 | else | ||
795 | info->hook->cflags &= ~CBAUDEX; | ||
796 | } else | ||
797 | i += 15; | ||
798 | } | ||
799 | |||
800 | save_flags(flags); cli(); | ||
801 | info->zs_baud = baud_table[i]; | ||
802 | if (info->zs_baud) { | ||
803 | brg = BPS_TO_BRG(info->zs_baud, zs_parms->clock/info->clk_divisor); | ||
804 | info->zs_channel->curregs[12] = (brg & 255); | ||
805 | info->zs_channel->curregs[13] = ((brg >> 8) & 255); | ||
806 | zs_rtsdtr(info, DTR, 1); | ||
807 | } else { | ||
808 | zs_rtsdtr(info, RTS | DTR, 0); | ||
809 | return; | ||
810 | } | ||
811 | |||
812 | /* byte size and parity */ | ||
813 | info->zs_channel->curregs[3] &= ~RxNBITS_MASK; | ||
814 | info->zs_channel->curregs[5] &= ~TxNBITS_MASK; | ||
815 | switch (cflag & CSIZE) { | ||
816 | case CS5: | ||
817 | bits = 7; | ||
818 | info->zs_channel->curregs[3] |= Rx5; | ||
819 | info->zs_channel->curregs[5] |= Tx5; | ||
820 | break; | ||
821 | case CS6: | ||
822 | bits = 8; | ||
823 | info->zs_channel->curregs[3] |= Rx6; | ||
824 | info->zs_channel->curregs[5] |= Tx6; | ||
825 | break; | ||
826 | case CS7: | ||
827 | bits = 9; | ||
828 | info->zs_channel->curregs[3] |= Rx7; | ||
829 | info->zs_channel->curregs[5] |= Tx7; | ||
830 | break; | ||
831 | case CS8: | ||
832 | default: /* defaults to 8 bits */ | ||
833 | bits = 10; | ||
834 | info->zs_channel->curregs[3] |= Rx8; | ||
835 | info->zs_channel->curregs[5] |= Tx8; | ||
836 | break; | ||
837 | } | ||
838 | |||
839 | info->timeout = ((info->xmit_fifo_size*HZ*bits) / info->zs_baud); | ||
840 | info->timeout += HZ/50; /* Add .02 seconds of slop */ | ||
841 | |||
842 | info->zs_channel->curregs[4] &= ~(SB_MASK | PAR_ENA | PAR_EVEN); | ||
843 | if (cflag & CSTOPB) { | ||
844 | info->zs_channel->curregs[4] |= SB2; | ||
845 | } else { | ||
846 | info->zs_channel->curregs[4] |= SB1; | ||
847 | } | ||
848 | if (cflag & PARENB) { | ||
849 | info->zs_channel->curregs[4] |= PAR_ENA; | ||
850 | } | ||
851 | if (!(cflag & PARODD)) { | ||
852 | info->zs_channel->curregs[4] |= PAR_EVEN; | ||
853 | } | ||
854 | |||
855 | if (!(cflag & CLOCAL)) { | ||
856 | if (!(info->zs_channel->curregs[15] & DCDIE)) | ||
857 | info->read_reg_zero = read_zsreg(info->zs_channel, 0); | ||
858 | info->zs_channel->curregs[15] |= DCDIE; | ||
859 | } else | ||
860 | info->zs_channel->curregs[15] &= ~DCDIE; | ||
861 | if (cflag & CRTSCTS) { | ||
862 | info->zs_channel->curregs[15] |= CTSIE; | ||
863 | if ((read_zsreg(info->zs_channel, 0) & CTS) == 0) | ||
864 | info->tx_stopped = 1; | ||
865 | } else { | ||
866 | info->zs_channel->curregs[15] &= ~CTSIE; | ||
867 | info->tx_stopped = 0; | ||
868 | } | ||
869 | |||
870 | /* Load up the new values */ | ||
871 | load_zsregs(info->zs_channel, info->zs_channel->curregs); | ||
872 | |||
873 | restore_flags(flags); | ||
874 | } | ||
875 | |||
876 | static void rs_flush_chars(struct tty_struct *tty) | ||
877 | { | ||
878 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
879 | unsigned long flags; | ||
880 | |||
881 | if (serial_paranoia_check(info, tty->name, "rs_flush_chars")) | ||
882 | return; | ||
883 | |||
884 | if (info->xmit_cnt <= 0 || tty->stopped || info->tx_stopped || | ||
885 | !info->xmit_buf) | ||
886 | return; | ||
887 | |||
888 | /* Enable transmitter */ | ||
889 | save_flags(flags); cli(); | ||
890 | transmit_chars(info); | ||
891 | restore_flags(flags); | ||
892 | } | ||
893 | |||
894 | static int rs_write(struct tty_struct * tty, | ||
895 | const unsigned char *buf, int count) | ||
896 | { | ||
897 | int c, total = 0; | ||
898 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
899 | unsigned long flags; | ||
900 | |||
901 | if (serial_paranoia_check(info, tty->name, "rs_write")) | ||
902 | return 0; | ||
903 | |||
904 | if (!tty || !info->xmit_buf) | ||
905 | return 0; | ||
906 | |||
907 | save_flags(flags); | ||
908 | while (1) { | ||
909 | cli(); | ||
910 | c = min(count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1, | ||
911 | SERIAL_XMIT_SIZE - info->xmit_head)); | ||
912 | if (c <= 0) | ||
913 | break; | ||
914 | |||
915 | if (from_user) { | ||
916 | down(&tmp_buf_sem); | ||
917 | copy_from_user(tmp_buf, buf, c); | ||
918 | c = min(c, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1, | ||
919 | SERIAL_XMIT_SIZE - info->xmit_head)); | ||
920 | memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c); | ||
921 | up(&tmp_buf_sem); | ||
922 | } else | ||
923 | memcpy(info->xmit_buf + info->xmit_head, buf, c); | ||
924 | info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1); | ||
925 | info->xmit_cnt += c; | ||
926 | restore_flags(flags); | ||
927 | buf += c; | ||
928 | count -= c; | ||
929 | total += c; | ||
930 | } | ||
931 | |||
932 | if (info->xmit_cnt && !tty->stopped && !info->tx_stopped | ||
933 | && !info->tx_active) | ||
934 | transmit_chars(info); | ||
935 | restore_flags(flags); | ||
936 | return total; | ||
937 | } | ||
938 | |||
939 | static int rs_write_room(struct tty_struct *tty) | ||
940 | { | ||
941 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
942 | int ret; | ||
943 | |||
944 | if (serial_paranoia_check(info, tty->name, "rs_write_room")) | ||
945 | return 0; | ||
946 | ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1; | ||
947 | if (ret < 0) | ||
948 | ret = 0; | ||
949 | return ret; | ||
950 | } | ||
951 | |||
952 | static int rs_chars_in_buffer(struct tty_struct *tty) | ||
953 | { | ||
954 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
955 | |||
956 | if (serial_paranoia_check(info, tty->name, "rs_chars_in_buffer")) | ||
957 | return 0; | ||
958 | return info->xmit_cnt; | ||
959 | } | ||
960 | |||
961 | static void rs_flush_buffer(struct tty_struct *tty) | ||
962 | { | ||
963 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
964 | |||
965 | if (serial_paranoia_check(info, tty->name, "rs_flush_buffer")) | ||
966 | return; | ||
967 | cli(); | ||
968 | info->xmit_cnt = info->xmit_head = info->xmit_tail = 0; | ||
969 | sti(); | ||
970 | tty_wakeup(tty); | ||
971 | } | ||
972 | |||
973 | /* | ||
974 | * ------------------------------------------------------------ | ||
975 | * rs_throttle() | ||
976 | * | ||
977 | * This routine is called by the upper-layer tty layer to signal that | ||
978 | * incoming characters should be throttled. | ||
979 | * ------------------------------------------------------------ | ||
980 | */ | ||
981 | static void rs_throttle(struct tty_struct * tty) | ||
982 | { | ||
983 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
984 | unsigned long flags; | ||
985 | |||
986 | #ifdef SERIAL_DEBUG_THROTTLE | ||
987 | char buf[64]; | ||
988 | |||
989 | printk("throttle %s: %d....\n", _tty_name(tty, buf), | ||
990 | tty->ldisc.chars_in_buffer(tty)); | ||
991 | #endif | ||
992 | |||
993 | if (serial_paranoia_check(info, tty->name, "rs_throttle")) | ||
994 | return; | ||
995 | |||
996 | if (I_IXOFF(tty)) { | ||
997 | save_flags(flags); cli(); | ||
998 | info->x_char = STOP_CHAR(tty); | ||
999 | if (!info->tx_active) | ||
1000 | transmit_chars(info); | ||
1001 | restore_flags(flags); | ||
1002 | } | ||
1003 | |||
1004 | if (C_CRTSCTS(tty)) { | ||
1005 | zs_rtsdtr(info, RTS, 0); | ||
1006 | } | ||
1007 | } | ||
1008 | |||
1009 | static void rs_unthrottle(struct tty_struct * tty) | ||
1010 | { | ||
1011 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
1012 | unsigned long flags; | ||
1013 | |||
1014 | #ifdef SERIAL_DEBUG_THROTTLE | ||
1015 | char buf[64]; | ||
1016 | |||
1017 | printk("unthrottle %s: %d....\n", _tty_name(tty, buf), | ||
1018 | tty->ldisc.chars_in_buffer(tty)); | ||
1019 | #endif | ||
1020 | |||
1021 | if (serial_paranoia_check(info, tty->name, "rs_unthrottle")) | ||
1022 | return; | ||
1023 | |||
1024 | if (I_IXOFF(tty)) { | ||
1025 | save_flags(flags); cli(); | ||
1026 | if (info->x_char) | ||
1027 | info->x_char = 0; | ||
1028 | else { | ||
1029 | info->x_char = START_CHAR(tty); | ||
1030 | if (!info->tx_active) | ||
1031 | transmit_chars(info); | ||
1032 | } | ||
1033 | restore_flags(flags); | ||
1034 | } | ||
1035 | |||
1036 | if (C_CRTSCTS(tty)) { | ||
1037 | zs_rtsdtr(info, RTS, 1); | ||
1038 | } | ||
1039 | } | ||
1040 | |||
1041 | /* | ||
1042 | * ------------------------------------------------------------ | ||
1043 | * rs_ioctl() and friends | ||
1044 | * ------------------------------------------------------------ | ||
1045 | */ | ||
1046 | |||
1047 | static int get_serial_info(struct dec_serial * info, | ||
1048 | struct serial_struct * retinfo) | ||
1049 | { | ||
1050 | struct serial_struct tmp; | ||
1051 | |||
1052 | if (!retinfo) | ||
1053 | return -EFAULT; | ||
1054 | memset(&tmp, 0, sizeof(tmp)); | ||
1055 | tmp.type = info->type; | ||
1056 | tmp.line = info->line; | ||
1057 | tmp.port = info->port; | ||
1058 | tmp.irq = info->irq; | ||
1059 | tmp.flags = info->flags; | ||
1060 | tmp.baud_base = info->baud_base; | ||
1061 | tmp.close_delay = info->close_delay; | ||
1062 | tmp.closing_wait = info->closing_wait; | ||
1063 | tmp.custom_divisor = info->custom_divisor; | ||
1064 | return copy_to_user(retinfo,&tmp,sizeof(*retinfo)) ? -EFAULT : 0; | ||
1065 | } | ||
1066 | |||
1067 | static int set_serial_info(struct dec_serial * info, | ||
1068 | struct serial_struct * new_info) | ||
1069 | { | ||
1070 | struct serial_struct new_serial; | ||
1071 | struct dec_serial old_info; | ||
1072 | int retval = 0; | ||
1073 | |||
1074 | if (!new_info) | ||
1075 | return -EFAULT; | ||
1076 | copy_from_user(&new_serial,new_info,sizeof(new_serial)); | ||
1077 | old_info = *info; | ||
1078 | |||
1079 | if (!capable(CAP_SYS_ADMIN)) { | ||
1080 | if ((new_serial.baud_base != info->baud_base) || | ||
1081 | (new_serial.type != info->type) || | ||
1082 | (new_serial.close_delay != info->close_delay) || | ||
1083 | ((new_serial.flags & ~ZILOG_USR_MASK) != | ||
1084 | (info->flags & ~ZILOG_USR_MASK))) | ||
1085 | return -EPERM; | ||
1086 | info->flags = ((info->flags & ~ZILOG_USR_MASK) | | ||
1087 | (new_serial.flags & ZILOG_USR_MASK)); | ||
1088 | info->custom_divisor = new_serial.custom_divisor; | ||
1089 | goto check_and_exit; | ||
1090 | } | ||
1091 | |||
1092 | if (info->count > 1) | ||
1093 | return -EBUSY; | ||
1094 | |||
1095 | /* | ||
1096 | * OK, past this point, all the error checking has been done. | ||
1097 | * At this point, we start making changes..... | ||
1098 | */ | ||
1099 | |||
1100 | info->baud_base = new_serial.baud_base; | ||
1101 | info->flags = ((info->flags & ~ZILOG_FLAGS) | | ||
1102 | (new_serial.flags & ZILOG_FLAGS)); | ||
1103 | info->type = new_serial.type; | ||
1104 | info->close_delay = new_serial.close_delay; | ||
1105 | info->closing_wait = new_serial.closing_wait; | ||
1106 | |||
1107 | check_and_exit: | ||
1108 | retval = zs_startup(info); | ||
1109 | return retval; | ||
1110 | } | ||
1111 | |||
1112 | /* | ||
1113 | * get_lsr_info - get line status register info | ||
1114 | * | ||
1115 | * Purpose: Let user call ioctl() to get info when the UART physically | ||
1116 | * is emptied. On bus types like RS485, the transmitter must | ||
1117 | * release the bus after transmitting. This must be done when | ||
1118 | * the transmit shift register is empty, not be done when the | ||
1119 | * transmit holding register is empty. This functionality | ||
1120 | * allows an RS485 driver to be written in user space. | ||
1121 | */ | ||
1122 | static int get_lsr_info(struct dec_serial * info, unsigned int *value) | ||
1123 | { | ||
1124 | unsigned char status; | ||
1125 | |||
1126 | cli(); | ||
1127 | status = read_zsreg(info->zs_channel, 0); | ||
1128 | sti(); | ||
1129 | put_user(status,value); | ||
1130 | return 0; | ||
1131 | } | ||
1132 | |||
1133 | static int rs_tiocmget(struct tty_struct *tty, struct file *file) | ||
1134 | { | ||
1135 | struct dec_serial * info = (struct dec_serial *)tty->driver_data; | ||
1136 | unsigned char control, status_a, status_b; | ||
1137 | unsigned int result; | ||
1138 | |||
1139 | if (info->hook) | ||
1140 | return -ENODEV; | ||
1141 | |||
1142 | if (serial_paranoia_check(info, tty->name, __FUNCTION__)) | ||
1143 | return -ENODEV; | ||
1144 | |||
1145 | if (tty->flags & (1 << TTY_IO_ERROR)) | ||
1146 | return -EIO; | ||
1147 | |||
1148 | if (info->zs_channel == info->zs_chan_a) | ||
1149 | result = 0; | ||
1150 | else { | ||
1151 | cli(); | ||
1152 | control = info->zs_chan_a->curregs[5]; | ||
1153 | status_a = read_zsreg(info->zs_chan_a, 0); | ||
1154 | status_b = read_zsreg(info->zs_channel, 0); | ||
1155 | sti(); | ||
1156 | result = ((control & RTS) ? TIOCM_RTS: 0) | ||
1157 | | ((control & DTR) ? TIOCM_DTR: 0) | ||
1158 | | ((status_b & DCD) ? TIOCM_CAR: 0) | ||
1159 | | ((status_a & DCD) ? TIOCM_RNG: 0) | ||
1160 | | ((status_a & SYNC_HUNT) ? TIOCM_DSR: 0) | ||
1161 | | ((status_b & CTS) ? TIOCM_CTS: 0); | ||
1162 | } | ||
1163 | return result; | ||
1164 | } | ||
1165 | |||
1166 | static int rs_tiocmset(struct tty_struct *tty, struct file *file, | ||
1167 | unsigned int set, unsigned int clear) | ||
1168 | { | ||
1169 | struct dec_serial * info = (struct dec_serial *)tty->driver_data; | ||
1170 | int error; | ||
1171 | unsigned int arg, bits; | ||
1172 | |||
1173 | if (info->hook) | ||
1174 | return -ENODEV; | ||
1175 | |||
1176 | if (serial_paranoia_check(info, tty->name, __FUNCTION__)) | ||
1177 | return -ENODEV; | ||
1178 | |||
1179 | if (tty->flags & (1 << TTY_IO_ERROR)) | ||
1180 | return -EIO; | ||
1181 | |||
1182 | if (info->zs_channel == info->zs_chan_a) | ||
1183 | return 0; | ||
1184 | |||
1185 | get_user(arg, value); | ||
1186 | cli(); | ||
1187 | if (set & TIOCM_RTS) | ||
1188 | info->zs_chan_a->curregs[5] |= RTS; | ||
1189 | if (set & TIOCM_DTR) | ||
1190 | info->zs_chan_a->curregs[5] |= DTR; | ||
1191 | if (clear & TIOCM_RTS) | ||
1192 | info->zs_chan_a->curregs[5] &= ~RTS; | ||
1193 | if (clear & TIOCM_DTR) | ||
1194 | info->zs_chan_a->curregs[5] &= ~DTR; | ||
1195 | write_zsreg(info->zs_chan_a, 5, info->zs_chan_a->curregs[5]); | ||
1196 | sti(); | ||
1197 | return 0; | ||
1198 | } | ||
1199 | |||
1200 | /* | ||
1201 | * rs_break - turn transmit break condition on/off | ||
1202 | */ | ||
1203 | static void rs_break(struct tty_struct *tty, int break_state) | ||
1204 | { | ||
1205 | struct dec_serial *info = (struct dec_serial *) tty->driver_data; | ||
1206 | unsigned long flags; | ||
1207 | |||
1208 | if (serial_paranoia_check(info, tty->name, "rs_break")) | ||
1209 | return; | ||
1210 | if (!info->port) | ||
1211 | return; | ||
1212 | |||
1213 | save_flags(flags); cli(); | ||
1214 | if (break_state == -1) | ||
1215 | info->zs_channel->curregs[5] |= SND_BRK; | ||
1216 | else | ||
1217 | info->zs_channel->curregs[5] &= ~SND_BRK; | ||
1218 | write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]); | ||
1219 | restore_flags(flags); | ||
1220 | } | ||
1221 | |||
1222 | static int rs_ioctl(struct tty_struct *tty, struct file * file, | ||
1223 | unsigned int cmd, unsigned long arg) | ||
1224 | { | ||
1225 | int error; | ||
1226 | struct dec_serial * info = (struct dec_serial *)tty->driver_data; | ||
1227 | |||
1228 | if (info->hook) | ||
1229 | return -ENODEV; | ||
1230 | |||
1231 | if (serial_paranoia_check(info, tty->name, "rs_ioctl")) | ||
1232 | return -ENODEV; | ||
1233 | |||
1234 | if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && | ||
1235 | (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD) && | ||
1236 | (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) { | ||
1237 | if (tty->flags & (1 << TTY_IO_ERROR)) | ||
1238 | return -EIO; | ||
1239 | } | ||
1240 | |||
1241 | switch (cmd) { | ||
1242 | case TIOCGSERIAL: | ||
1243 | if (!access_ok(VERIFY_WRITE, (void *)arg, | ||
1244 | sizeof(struct serial_struct))) | ||
1245 | return -EFAULT; | ||
1246 | return get_serial_info(info, (struct serial_struct *)arg); | ||
1247 | |||
1248 | case TIOCSSERIAL: | ||
1249 | return set_serial_info(info, (struct serial_struct *)arg); | ||
1250 | |||
1251 | case TIOCSERGETLSR: /* Get line status register */ | ||
1252 | if (!access_ok(VERIFY_WRITE, (void *)arg, | ||
1253 | sizeof(unsigned int))) | ||
1254 | return -EFAULT; | ||
1255 | return get_lsr_info(info, (unsigned int *)arg); | ||
1256 | |||
1257 | case TIOCSERGSTRUCT: | ||
1258 | if (!access_ok(VERIFY_WRITE, (void *)arg, | ||
1259 | sizeof(struct dec_serial))) | ||
1260 | return -EFAULT; | ||
1261 | copy_from_user((struct dec_serial *)arg, info, | ||
1262 | sizeof(struct dec_serial)); | ||
1263 | return 0; | ||
1264 | |||
1265 | default: | ||
1266 | return -ENOIOCTLCMD; | ||
1267 | } | ||
1268 | return 0; | ||
1269 | } | ||
1270 | |||
1271 | static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios) | ||
1272 | { | ||
1273 | struct dec_serial *info = (struct dec_serial *)tty->driver_data; | ||
1274 | int was_stopped; | ||
1275 | |||
1276 | if (tty->termios->c_cflag == old_termios->c_cflag) | ||
1277 | return; | ||
1278 | was_stopped = info->tx_stopped; | ||
1279 | |||
1280 | change_speed(info); | ||
1281 | |||
1282 | if (was_stopped && !info->tx_stopped) | ||
1283 | rs_start(tty); | ||
1284 | } | ||
1285 | |||
1286 | /* | ||
1287 | * ------------------------------------------------------------ | ||
1288 | * rs_close() | ||
1289 | * | ||
1290 | * This routine is called when the serial port gets closed. | ||
1291 | * Wait for the last remaining data to be sent. | ||
1292 | * ------------------------------------------------------------ | ||
1293 | */ | ||
1294 | static void rs_close(struct tty_struct *tty, struct file * filp) | ||
1295 | { | ||
1296 | struct dec_serial * info = (struct dec_serial *)tty->driver_data; | ||
1297 | unsigned long flags; | ||
1298 | |||
1299 | if (!info || serial_paranoia_check(info, tty->name, "rs_close")) | ||
1300 | return; | ||
1301 | |||
1302 | save_flags(flags); cli(); | ||
1303 | |||
1304 | if (tty_hung_up_p(filp)) { | ||
1305 | restore_flags(flags); | ||
1306 | return; | ||
1307 | } | ||
1308 | |||
1309 | #ifdef SERIAL_DEBUG_OPEN | ||
1310 | printk("rs_close ttyS%d, count = %d\n", info->line, info->count); | ||
1311 | #endif | ||
1312 | if ((tty->count == 1) && (info->count != 1)) { | ||
1313 | /* | ||
1314 | * Uh, oh. tty->count is 1, which means that the tty | ||
1315 | * structure will be freed. Info->count should always | ||
1316 | * be one in these conditions. If it's greater than | ||
1317 | * one, we've got real problems, since it means the | ||
1318 | * serial port won't be shutdown. | ||
1319 | */ | ||
1320 | printk("rs_close: bad serial port count; tty->count is 1, " | ||
1321 | "info->count is %d\n", info->count); | ||
1322 | info->count = 1; | ||
1323 | } | ||
1324 | if (--info->count < 0) { | ||
1325 | printk("rs_close: bad serial port count for ttyS%d: %d\n", | ||
1326 | info->line, info->count); | ||
1327 | info->count = 0; | ||
1328 | } | ||
1329 | if (info->count) { | ||
1330 | restore_flags(flags); | ||
1331 | return; | ||
1332 | } | ||
1333 | info->flags |= ZILOG_CLOSING; | ||
1334 | /* | ||
1335 | * Now we wait for the transmit buffer to clear; and we notify | ||
1336 | * the line discipline to only process XON/XOFF characters. | ||
1337 | */ | ||
1338 | tty->closing = 1; | ||
1339 | if (info->closing_wait != ZILOG_CLOSING_WAIT_NONE) | ||
1340 | tty_wait_until_sent(tty, info->closing_wait); | ||
1341 | /* | ||
1342 | * At this point we stop accepting input. To do this, we | ||
1343 | * disable the receiver and receive interrupts. | ||
1344 | */ | ||
1345 | info->zs_channel->curregs[3] &= ~RxENABLE; | ||
1346 | write_zsreg(info->zs_channel, 3, info->zs_channel->curregs[3]); | ||
1347 | info->zs_channel->curregs[1] = 0; /* disable any rx ints */ | ||
1348 | write_zsreg(info->zs_channel, 1, info->zs_channel->curregs[1]); | ||
1349 | ZS_CLEARFIFO(info->zs_channel); | ||
1350 | if (info->flags & ZILOG_INITIALIZED) { | ||
1351 | /* | ||
1352 | * Before we drop DTR, make sure the SCC transmitter | ||
1353 | * has completely drained. | ||
1354 | */ | ||
1355 | rs_wait_until_sent(tty, info->timeout); | ||
1356 | } | ||
1357 | |||
1358 | shutdown(info); | ||
1359 | if (tty->driver->flush_buffer) | ||
1360 | tty->driver->flush_buffer(tty); | ||
1361 | tty_ldisc_flush(tty); | ||
1362 | tty->closing = 0; | ||
1363 | info->event = 0; | ||
1364 | info->tty = 0; | ||
1365 | if (info->blocked_open) { | ||
1366 | if (info->close_delay) { | ||
1367 | msleep_interruptible(jiffies_to_msecs(info->close_delay)); | ||
1368 | } | ||
1369 | wake_up_interruptible(&info->open_wait); | ||
1370 | } | ||
1371 | info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CLOSING); | ||
1372 | wake_up_interruptible(&info->close_wait); | ||
1373 | restore_flags(flags); | ||
1374 | } | ||
1375 | |||
1376 | /* | ||
1377 | * rs_wait_until_sent() --- wait until the transmitter is empty | ||
1378 | */ | ||
1379 | static void rs_wait_until_sent(struct tty_struct *tty, int timeout) | ||
1380 | { | ||
1381 | struct dec_serial *info = (struct dec_serial *) tty->driver_data; | ||
1382 | unsigned long orig_jiffies; | ||
1383 | int char_time; | ||
1384 | |||
1385 | if (serial_paranoia_check(info, tty->name, "rs_wait_until_sent")) | ||
1386 | return; | ||
1387 | |||
1388 | orig_jiffies = jiffies; | ||
1389 | /* | ||
1390 | * Set the check interval to be 1/5 of the estimated time to | ||
1391 | * send a single character, and make it at least 1. The check | ||
1392 | * interval should also be less than the timeout. | ||
1393 | */ | ||
1394 | char_time = (info->timeout - HZ/50) / info->xmit_fifo_size; | ||
1395 | char_time = char_time / 5; | ||
1396 | if (char_time == 0) | ||
1397 | char_time = 1; | ||
1398 | if (timeout) | ||
1399 | char_time = min(char_time, timeout); | ||
1400 | while ((read_zsreg(info->zs_channel, 1) & Tx_BUF_EMP) == 0) { | ||
1401 | msleep_interruptible(jiffies_to_msecs(char_time)); | ||
1402 | if (signal_pending(current)) | ||
1403 | break; | ||
1404 | if (timeout && time_after(jiffies, orig_jiffies + timeout)) | ||
1405 | break; | ||
1406 | } | ||
1407 | current->state = TASK_RUNNING; | ||
1408 | } | ||
1409 | |||
1410 | /* | ||
1411 | * rs_hangup() --- called by tty_hangup() when a hangup is signaled. | ||
1412 | */ | ||
1413 | void rs_hangup(struct tty_struct *tty) | ||
1414 | { | ||
1415 | struct dec_serial * info = (struct dec_serial *)tty->driver_data; | ||
1416 | |||
1417 | if (serial_paranoia_check(info, tty->name, "rs_hangup")) | ||
1418 | return; | ||
1419 | |||
1420 | rs_flush_buffer(tty); | ||
1421 | shutdown(info); | ||
1422 | info->event = 0; | ||
1423 | info->count = 0; | ||
1424 | info->flags &= ~ZILOG_NORMAL_ACTIVE; | ||
1425 | info->tty = 0; | ||
1426 | wake_up_interruptible(&info->open_wait); | ||
1427 | } | ||
1428 | |||
1429 | /* | ||
1430 | * ------------------------------------------------------------ | ||
1431 | * rs_open() and friends | ||
1432 | * ------------------------------------------------------------ | ||
1433 | */ | ||
1434 | static int block_til_ready(struct tty_struct *tty, struct file * filp, | ||
1435 | struct dec_serial *info) | ||
1436 | { | ||
1437 | DECLARE_WAITQUEUE(wait, current); | ||
1438 | int retval; | ||
1439 | int do_clocal = 0; | ||
1440 | |||
1441 | /* | ||
1442 | * If the device is in the middle of being closed, then block | ||
1443 | * until it's done, and then try again. | ||
1444 | */ | ||
1445 | if (info->flags & ZILOG_CLOSING) { | ||
1446 | interruptible_sleep_on(&info->close_wait); | ||
1447 | #ifdef SERIAL_DO_RESTART | ||
1448 | return ((info->flags & ZILOG_HUP_NOTIFY) ? | ||
1449 | -EAGAIN : -ERESTARTSYS); | ||
1450 | #else | ||
1451 | return -EAGAIN; | ||
1452 | #endif | ||
1453 | } | ||
1454 | |||
1455 | /* | ||
1456 | * If non-blocking mode is set, or the port is not enabled, | ||
1457 | * then make the check up front and then exit. | ||
1458 | */ | ||
1459 | if ((filp->f_flags & O_NONBLOCK) || | ||
1460 | (tty->flags & (1 << TTY_IO_ERROR))) { | ||
1461 | info->flags |= ZILOG_NORMAL_ACTIVE; | ||
1462 | return 0; | ||
1463 | } | ||
1464 | |||
1465 | if (tty->termios->c_cflag & CLOCAL) | ||
1466 | do_clocal = 1; | ||
1467 | |||
1468 | /* | ||
1469 | * Block waiting for the carrier detect and the line to become | ||
1470 | * free (i.e., not in use by the callout). While we are in | ||
1471 | * this loop, info->count is dropped by one, so that | ||
1472 | * rs_close() knows when to free things. We restore it upon | ||
1473 | * exit, either normal or abnormal. | ||
1474 | */ | ||
1475 | retval = 0; | ||
1476 | add_wait_queue(&info->open_wait, &wait); | ||
1477 | #ifdef SERIAL_DEBUG_OPEN | ||
1478 | printk("block_til_ready before block: ttyS%d, count = %d\n", | ||
1479 | info->line, info->count); | ||
1480 | #endif | ||
1481 | cli(); | ||
1482 | if (!tty_hung_up_p(filp)) | ||
1483 | info->count--; | ||
1484 | sti(); | ||
1485 | info->blocked_open++; | ||
1486 | while (1) { | ||
1487 | cli(); | ||
1488 | if (tty->termios->c_cflag & CBAUD) | ||
1489 | zs_rtsdtr(info, RTS | DTR, 1); | ||
1490 | sti(); | ||
1491 | set_current_state(TASK_INTERRUPTIBLE); | ||
1492 | if (tty_hung_up_p(filp) || | ||
1493 | !(info->flags & ZILOG_INITIALIZED)) { | ||
1494 | #ifdef SERIAL_DO_RESTART | ||
1495 | if (info->flags & ZILOG_HUP_NOTIFY) | ||
1496 | retval = -EAGAIN; | ||
1497 | else | ||
1498 | retval = -ERESTARTSYS; | ||
1499 | #else | ||
1500 | retval = -EAGAIN; | ||
1501 | #endif | ||
1502 | break; | ||
1503 | } | ||
1504 | if (!(info->flags & ZILOG_CLOSING) && | ||
1505 | (do_clocal || (read_zsreg(info->zs_channel, 0) & DCD))) | ||
1506 | break; | ||
1507 | if (signal_pending(current)) { | ||
1508 | retval = -ERESTARTSYS; | ||
1509 | break; | ||
1510 | } | ||
1511 | #ifdef SERIAL_DEBUG_OPEN | ||
1512 | printk("block_til_ready blocking: ttyS%d, count = %d\n", | ||
1513 | info->line, info->count); | ||
1514 | #endif | ||
1515 | schedule(); | ||
1516 | } | ||
1517 | current->state = TASK_RUNNING; | ||
1518 | remove_wait_queue(&info->open_wait, &wait); | ||
1519 | if (!tty_hung_up_p(filp)) | ||
1520 | info->count++; | ||
1521 | info->blocked_open--; | ||
1522 | #ifdef SERIAL_DEBUG_OPEN | ||
1523 | printk("block_til_ready after blocking: ttyS%d, count = %d\n", | ||
1524 | info->line, info->count); | ||
1525 | #endif | ||
1526 | if (retval) | ||
1527 | return retval; | ||
1528 | info->flags |= ZILOG_NORMAL_ACTIVE; | ||
1529 | return 0; | ||
1530 | } | ||
1531 | |||
1532 | /* | ||
1533 | * This routine is called whenever a serial port is opened. It | ||
1534 | * enables interrupts for a serial port, linking in its ZILOG structure into | ||
1535 | * the IRQ chain. It also performs the serial-specific | ||
1536 | * initialization for the tty structure. | ||
1537 | */ | ||
1538 | int rs_open(struct tty_struct *tty, struct file * filp) | ||
1539 | { | ||
1540 | struct dec_serial *info; | ||
1541 | int retval, line; | ||
1542 | |||
1543 | line = tty->index; | ||
1544 | if ((line < 0) || (line >= zs_channels_found)) | ||
1545 | return -ENODEV; | ||
1546 | info = zs_soft + line; | ||
1547 | |||
1548 | if (info->hook) | ||
1549 | return -ENODEV; | ||
1550 | |||
1551 | if (serial_paranoia_check(info, tty->name, "rs_open")) | ||
1552 | return -ENODEV; | ||
1553 | #ifdef SERIAL_DEBUG_OPEN | ||
1554 | printk("rs_open %s, count = %d\n", tty->name, info->count); | ||
1555 | #endif | ||
1556 | |||
1557 | info->count++; | ||
1558 | tty->driver_data = info; | ||
1559 | info->tty = tty; | ||
1560 | |||
1561 | /* | ||
1562 | * If the port is the middle of closing, bail out now | ||
1563 | */ | ||
1564 | if (tty_hung_up_p(filp) || | ||
1565 | (info->flags & ZILOG_CLOSING)) { | ||
1566 | if (info->flags & ZILOG_CLOSING) | ||
1567 | interruptible_sleep_on(&info->close_wait); | ||
1568 | #ifdef SERIAL_DO_RESTART | ||
1569 | return ((info->flags & ZILOG_HUP_NOTIFY) ? | ||
1570 | -EAGAIN : -ERESTARTSYS); | ||
1571 | #else | ||
1572 | return -EAGAIN; | ||
1573 | #endif | ||
1574 | } | ||
1575 | |||
1576 | /* | ||
1577 | * Start up serial port | ||
1578 | */ | ||
1579 | retval = zs_startup(info); | ||
1580 | if (retval) | ||
1581 | return retval; | ||
1582 | |||
1583 | retval = block_til_ready(tty, filp, info); | ||
1584 | if (retval) { | ||
1585 | #ifdef SERIAL_DEBUG_OPEN | ||
1586 | printk("rs_open returning after block_til_ready with %d\n", | ||
1587 | retval); | ||
1588 | #endif | ||
1589 | return retval; | ||
1590 | } | ||
1591 | |||
1592 | #ifdef CONFIG_SERIAL_DEC_CONSOLE | ||
1593 | if (sercons.cflag && sercons.index == line) { | ||
1594 | tty->termios->c_cflag = sercons.cflag; | ||
1595 | sercons.cflag = 0; | ||
1596 | change_speed(info); | ||
1597 | } | ||
1598 | #endif | ||
1599 | |||
1600 | #ifdef SERIAL_DEBUG_OPEN | ||
1601 | printk("rs_open %s successful...", tty->name); | ||
1602 | #endif | ||
1603 | /* tty->low_latency = 1; */ | ||
1604 | return 0; | ||
1605 | } | ||
1606 | |||
1607 | /* Finally, routines used to initialize the serial driver. */ | ||
1608 | |||
1609 | static void __init show_serial_version(void) | ||
1610 | { | ||
1611 | printk("DECstation Z8530 serial driver version 0.09\n"); | ||
1612 | } | ||
1613 | |||
1614 | /* Initialize Z8530s zs_channels | ||
1615 | */ | ||
1616 | |||
1617 | static void __init probe_sccs(void) | ||
1618 | { | ||
1619 | struct dec_serial **pp; | ||
1620 | int i, n, n_chips = 0, n_channels, chip, channel; | ||
1621 | unsigned long flags; | ||
1622 | |||
1623 | /* | ||
1624 | * did we get here by accident? | ||
1625 | */ | ||
1626 | if(!BUS_PRESENT) { | ||
1627 | printk("Not on JUNKIO machine, skipping probe_sccs\n"); | ||
1628 | return; | ||
1629 | } | ||
1630 | |||
1631 | /* | ||
1632 | * When serial console is activated, tc_init has not been called yet | ||
1633 | * and system_base is undefined. Unfortunately we have to hardcode | ||
1634 | * system_base for this case :-(. HK | ||
1635 | */ | ||
1636 | switch(mips_machtype) { | ||
1637 | #ifdef CONFIG_MACH_DECSTATION | ||
1638 | case MACH_DS5000_2X0: | ||
1639 | case MACH_DS5900: | ||
1640 | system_base = KSEG1ADDR(0x1f800000); | ||
1641 | n_chips = 2; | ||
1642 | zs_parms = &ds_parms; | ||
1643 | zs_parms->irq0 = dec_interrupt[DEC_IRQ_SCC0]; | ||
1644 | zs_parms->irq1 = dec_interrupt[DEC_IRQ_SCC1]; | ||
1645 | break; | ||
1646 | case MACH_DS5000_1XX: | ||
1647 | system_base = KSEG1ADDR(0x1c000000); | ||
1648 | n_chips = 2; | ||
1649 | zs_parms = &ds_parms; | ||
1650 | zs_parms->irq0 = dec_interrupt[DEC_IRQ_SCC0]; | ||
1651 | zs_parms->irq1 = dec_interrupt[DEC_IRQ_SCC1]; | ||
1652 | break; | ||
1653 | case MACH_DS5000_XX: | ||
1654 | system_base = KSEG1ADDR(0x1c000000); | ||
1655 | n_chips = 1; | ||
1656 | zs_parms = &ds_parms; | ||
1657 | zs_parms->irq0 = dec_interrupt[DEC_IRQ_SCC0]; | ||
1658 | break; | ||
1659 | #endif | ||
1660 | default: | ||
1661 | panic("zs: unsupported bus"); | ||
1662 | } | ||
1663 | if (!zs_parms) | ||
1664 | panic("zs: uninitialized parms"); | ||
1665 | |||
1666 | pp = &zs_chain; | ||
1667 | |||
1668 | n_channels = 0; | ||
1669 | |||
1670 | for (chip = 0; chip < n_chips; chip++) { | ||
1671 | for (channel = 0; channel <= 1; channel++) { | ||
1672 | /* | ||
1673 | * The sccs reside on the high byte of the 16 bit IOBUS | ||
1674 | */ | ||
1675 | zs_channels[n_channels].control = | ||
1676 | (volatile unsigned char *)system_base + | ||
1677 | (0 == chip ? zs_parms->scc0 : zs_parms->scc1) + | ||
1678 | (0 == channel ? zs_parms->channel_a_offset : | ||
1679 | zs_parms->channel_b_offset); | ||
1680 | zs_channels[n_channels].data = | ||
1681 | zs_channels[n_channels].control + 4; | ||
1682 | |||
1683 | #ifndef CONFIG_SERIAL_DEC_CONSOLE | ||
1684 | /* | ||
1685 | * We're called early and memory managment isn't up, yet. | ||
1686 | * Thus check_region would fail. | ||
1687 | */ | ||
1688 | if (!request_region((unsigned long) | ||
1689 | zs_channels[n_channels].control, | ||
1690 | ZS_CHAN_IO_SIZE, "SCC")) | ||
1691 | panic("SCC I/O region is not free"); | ||
1692 | #endif | ||
1693 | zs_soft[n_channels].zs_channel = &zs_channels[n_channels]; | ||
1694 | /* HACK alert! */ | ||
1695 | if (!(chip & 1)) | ||
1696 | zs_soft[n_channels].irq = zs_parms->irq0; | ||
1697 | else | ||
1698 | zs_soft[n_channels].irq = zs_parms->irq1; | ||
1699 | |||
1700 | /* | ||
1701 | * Identification of channel A. Location of channel A | ||
1702 | * inside chip depends on mapping of internal address | ||
1703 | * the chip decodes channels by. | ||
1704 | * CHANNEL_A_NR returns either 0 (in case of | ||
1705 | * DECstations) or 1 (in case of Baget). | ||
1706 | */ | ||
1707 | if (CHANNEL_A_NR == channel) | ||
1708 | zs_soft[n_channels].zs_chan_a = | ||
1709 | &zs_channels[n_channels+1-2*CHANNEL_A_NR]; | ||
1710 | else | ||
1711 | zs_soft[n_channels].zs_chan_a = | ||
1712 | &zs_channels[n_channels]; | ||
1713 | |||
1714 | *pp = &zs_soft[n_channels]; | ||
1715 | pp = &zs_soft[n_channels].zs_next; | ||
1716 | n_channels++; | ||
1717 | } | ||
1718 | } | ||
1719 | |||
1720 | *pp = 0; | ||
1721 | zs_channels_found = n_channels; | ||
1722 | |||
1723 | for (n = 0; n < zs_channels_found; n++) { | ||
1724 | for (i = 0; i < 16; i++) { | ||
1725 | zs_soft[n].zs_channel->curregs[i] = zs_init_regs[i]; | ||
1726 | } | ||
1727 | } | ||
1728 | |||
1729 | save_and_cli(flags); | ||
1730 | for (n = 0; n < zs_channels_found; n++) { | ||
1731 | if (n % 2 == 0) { | ||
1732 | write_zsreg(zs_soft[n].zs_chan_a, R9, FHWRES); | ||
1733 | udelay(10); | ||
1734 | write_zsreg(zs_soft[n].zs_chan_a, R9, 0); | ||
1735 | } | ||
1736 | load_zsregs(zs_soft[n].zs_channel, | ||
1737 | zs_soft[n].zs_channel->curregs); | ||
1738 | } | ||
1739 | restore_flags(flags); | ||
1740 | } | ||
1741 | |||
1742 | static struct tty_operations serial_ops = { | ||
1743 | .open = rs_open, | ||
1744 | .close = rs_close, | ||
1745 | .write = rs_write, | ||
1746 | .flush_chars = rs_flush_chars, | ||
1747 | .write_room = rs_write_room, | ||
1748 | .chars_in_buffer = rs_chars_in_buffer, | ||
1749 | .flush_buffer = rs_flush_buffer, | ||
1750 | .ioctl = rs_ioctl, | ||
1751 | .throttle = rs_throttle, | ||
1752 | .unthrottle = rs_unthrottle, | ||
1753 | .set_termios = rs_set_termios, | ||
1754 | .stop = rs_stop, | ||
1755 | .start = rs_start, | ||
1756 | .hangup = rs_hangup, | ||
1757 | .break_ctl = rs_break, | ||
1758 | .wait_until_sent = rs_wait_until_sent, | ||
1759 | .tiocmget = rs_tiocmget, | ||
1760 | .tiocmset = rs_tiocmset, | ||
1761 | }; | ||
1762 | |||
1763 | /* zs_init inits the driver */ | ||
1764 | int __init zs_init(void) | ||
1765 | { | ||
1766 | int channel, i; | ||
1767 | struct dec_serial *info; | ||
1768 | |||
1769 | if(!BUS_PRESENT) | ||
1770 | return -ENODEV; | ||
1771 | |||
1772 | /* Setup base handler, and timer table. */ | ||
1773 | init_bh(SERIAL_BH, do_serial_bh); | ||
1774 | |||
1775 | /* Find out how many Z8530 SCCs we have */ | ||
1776 | if (zs_chain == 0) | ||
1777 | probe_sccs(); | ||
1778 | serial_driver = alloc_tty_driver(zs_channels_found); | ||
1779 | if (!serial_driver) | ||
1780 | return -ENOMEM; | ||
1781 | |||
1782 | show_serial_version(); | ||
1783 | |||
1784 | /* Initialize the tty_driver structure */ | ||
1785 | /* Not all of this is exactly right for us. */ | ||
1786 | |||
1787 | serial_driver->owner = THIS_MODULE; | ||
1788 | serial_driver->devfs_name = "tts/"; | ||
1789 | serial_driver->name = "ttyS"; | ||
1790 | serial_driver->major = TTY_MAJOR; | ||
1791 | serial_driver->minor_start = 64; | ||
1792 | serial_driver->type = TTY_DRIVER_TYPE_SERIAL; | ||
1793 | serial_driver->subtype = SERIAL_TYPE_NORMAL; | ||
1794 | serial_driver->init_termios = tty_std_termios; | ||
1795 | serial_driver->init_termios.c_cflag = | ||
1796 | B9600 | CS8 | CREAD | HUPCL | CLOCAL; | ||
1797 | serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS; | ||
1798 | tty_set_operations(serial_driver, &serial_ops); | ||
1799 | |||
1800 | if (tty_register_driver(serial_driver)) | ||
1801 | panic("Couldn't register serial driver"); | ||
1802 | |||
1803 | for (info = zs_chain, i = 0; info; info = info->zs_next, i++) { | ||
1804 | |||
1805 | /* Needed before interrupts are enabled. */ | ||
1806 | info->tty = 0; | ||
1807 | info->x_char = 0; | ||
1808 | |||
1809 | if (info->hook && info->hook->init_info) { | ||
1810 | (*info->hook->init_info)(info); | ||
1811 | continue; | ||
1812 | } | ||
1813 | |||
1814 | info->magic = SERIAL_MAGIC; | ||
1815 | info->port = (int) info->zs_channel->control; | ||
1816 | info->line = i; | ||
1817 | info->custom_divisor = 16; | ||
1818 | info->close_delay = 50; | ||
1819 | info->closing_wait = 3000; | ||
1820 | info->event = 0; | ||
1821 | info->count = 0; | ||
1822 | info->blocked_open = 0; | ||
1823 | info->tqueue.routine = do_softint; | ||
1824 | info->tqueue.data = info; | ||
1825 | init_waitqueue_head(&info->open_wait); | ||
1826 | init_waitqueue_head(&info->close_wait); | ||
1827 | printk("ttyS%02d at 0x%08x (irq = %d) is a Z85C30 SCC\n", | ||
1828 | info->line, info->port, info->irq); | ||
1829 | tty_register_device(serial_driver, info->line, NULL); | ||
1830 | |||
1831 | } | ||
1832 | |||
1833 | for (channel = 0; channel < zs_channels_found; ++channel) { | ||
1834 | zs_soft[channel].clk_divisor = 16; | ||
1835 | zs_soft[channel].zs_baud = get_zsbaud(&zs_soft[channel]); | ||
1836 | |||
1837 | if (request_irq(zs_soft[channel].irq, rs_interrupt, SA_SHIRQ, | ||
1838 | "scc", &zs_soft[channel])) | ||
1839 | printk(KERN_ERR "decserial: can't get irq %d\n", | ||
1840 | zs_soft[channel].irq); | ||
1841 | |||
1842 | if (zs_soft[channel].hook) { | ||
1843 | zs_startup(&zs_soft[channel]); | ||
1844 | if (zs_soft[channel].hook->init_channel) | ||
1845 | (*zs_soft[channel].hook->init_channel) | ||
1846 | (&zs_soft[channel]); | ||
1847 | } | ||
1848 | } | ||
1849 | |||
1850 | return 0; | ||
1851 | } | ||
1852 | |||
1853 | /* | ||
1854 | * polling I/O routines | ||
1855 | */ | ||
1856 | static int | ||
1857 | zs_poll_tx_char(void *handle, unsigned char ch) | ||
1858 | { | ||
1859 | struct dec_serial *info = handle; | ||
1860 | struct dec_zschannel *chan = info->zs_channel; | ||
1861 | int ret; | ||
1862 | |||
1863 | if(chan) { | ||
1864 | int loops = 10000; | ||
1865 | |||
1866 | while (loops && !(read_zsreg(chan, 0) & Tx_BUF_EMP)) | ||
1867 | loops--; | ||
1868 | |||
1869 | if (loops) { | ||
1870 | write_zsdata(chan, ch); | ||
1871 | ret = 0; | ||
1872 | } else | ||
1873 | ret = -EAGAIN; | ||
1874 | |||
1875 | return ret; | ||
1876 | } else | ||
1877 | return -ENODEV; | ||
1878 | } | ||
1879 | |||
1880 | static int | ||
1881 | zs_poll_rx_char(void *handle) | ||
1882 | { | ||
1883 | struct dec_serial *info = handle; | ||
1884 | struct dec_zschannel *chan = info->zs_channel; | ||
1885 | int ret; | ||
1886 | |||
1887 | if(chan) { | ||
1888 | int loops = 10000; | ||
1889 | |||
1890 | while (loops && !(read_zsreg(chan, 0) & Rx_CH_AV)) | ||
1891 | loops--; | ||
1892 | |||
1893 | if (loops) | ||
1894 | ret = read_zsdata(chan); | ||
1895 | else | ||
1896 | ret = -EAGAIN; | ||
1897 | |||
1898 | return ret; | ||
1899 | } else | ||
1900 | return -ENODEV; | ||
1901 | } | ||
1902 | |||
1903 | int register_zs_hook(unsigned int channel, struct dec_serial_hook *hook) | ||
1904 | { | ||
1905 | struct dec_serial *info = &zs_soft[channel]; | ||
1906 | |||
1907 | if (info->hook) { | ||
1908 | printk("%s: line %d has already a hook registered\n", | ||
1909 | __FUNCTION__, channel); | ||
1910 | |||
1911 | return 0; | ||
1912 | } else { | ||
1913 | hook->poll_rx_char = zs_poll_rx_char; | ||
1914 | hook->poll_tx_char = zs_poll_tx_char; | ||
1915 | info->hook = hook; | ||
1916 | |||
1917 | return 1; | ||
1918 | } | ||
1919 | } | ||
1920 | |||
1921 | int unregister_zs_hook(unsigned int channel) | ||
1922 | { | ||
1923 | struct dec_serial *info = &zs_soft[channel]; | ||
1924 | |||
1925 | if (info->hook) { | ||
1926 | info->hook = NULL; | ||
1927 | return 1; | ||
1928 | } else { | ||
1929 | printk("%s: trying to unregister hook on line %d," | ||
1930 | " but none is registered\n", __FUNCTION__, channel); | ||
1931 | return 0; | ||
1932 | } | ||
1933 | } | ||
1934 | |||
1935 | /* | ||
1936 | * ------------------------------------------------------------ | ||
1937 | * Serial console driver | ||
1938 | * ------------------------------------------------------------ | ||
1939 | */ | ||
1940 | #ifdef CONFIG_SERIAL_DEC_CONSOLE | ||
1941 | |||
1942 | |||
1943 | /* | ||
1944 | * Print a string to the serial port trying not to disturb | ||
1945 | * any possible real use of the port... | ||
1946 | */ | ||
1947 | static void serial_console_write(struct console *co, const char *s, | ||
1948 | unsigned count) | ||
1949 | { | ||
1950 | struct dec_serial *info; | ||
1951 | int i; | ||
1952 | |||
1953 | info = zs_soft + co->index; | ||
1954 | |||
1955 | for (i = 0; i < count; i++, s++) { | ||
1956 | if(*s == '\n') | ||
1957 | zs_poll_tx_char(info, '\r'); | ||
1958 | zs_poll_tx_char(info, *s); | ||
1959 | } | ||
1960 | } | ||
1961 | |||
1962 | static struct tty_driver *serial_console_device(struct console *c, int *index) | ||
1963 | { | ||
1964 | *index = c->index; | ||
1965 | return serial_driver; | ||
1966 | } | ||
1967 | |||
1968 | /* | ||
1969 | * Setup initial baud/bits/parity. We do two things here: | ||
1970 | * - construct a cflag setting for the first rs_open() | ||
1971 | * - initialize the serial port | ||
1972 | * Return non-zero if we didn't find a serial port. | ||
1973 | */ | ||
1974 | static int __init serial_console_setup(struct console *co, char *options) | ||
1975 | { | ||
1976 | struct dec_serial *info; | ||
1977 | int baud = 9600; | ||
1978 | int bits = 8; | ||
1979 | int parity = 'n'; | ||
1980 | int cflag = CREAD | HUPCL | CLOCAL; | ||
1981 | int clk_divisor = 16; | ||
1982 | int brg; | ||
1983 | char *s; | ||
1984 | unsigned long flags; | ||
1985 | |||
1986 | if(!BUS_PRESENT) | ||
1987 | return -ENODEV; | ||
1988 | |||
1989 | info = zs_soft + co->index; | ||
1990 | |||
1991 | if (zs_chain == 0) | ||
1992 | probe_sccs(); | ||
1993 | |||
1994 | info->is_cons = 1; | ||
1995 | |||
1996 | if (options) { | ||
1997 | baud = simple_strtoul(options, NULL, 10); | ||
1998 | s = options; | ||
1999 | while(*s >= '0' && *s <= '9') | ||
2000 | s++; | ||
2001 | if (*s) | ||
2002 | parity = *s++; | ||
2003 | if (*s) | ||
2004 | bits = *s - '0'; | ||
2005 | } | ||
2006 | |||
2007 | /* | ||
2008 | * Now construct a cflag setting. | ||
2009 | */ | ||
2010 | switch(baud) { | ||
2011 | case 1200: | ||
2012 | cflag |= B1200; | ||
2013 | break; | ||
2014 | case 2400: | ||
2015 | cflag |= B2400; | ||
2016 | break; | ||
2017 | case 4800: | ||
2018 | cflag |= B4800; | ||
2019 | break; | ||
2020 | case 19200: | ||
2021 | cflag |= B19200; | ||
2022 | break; | ||
2023 | case 38400: | ||
2024 | cflag |= B38400; | ||
2025 | break; | ||
2026 | case 57600: | ||
2027 | cflag |= B57600; | ||
2028 | break; | ||
2029 | case 115200: | ||
2030 | cflag |= B115200; | ||
2031 | break; | ||
2032 | case 9600: | ||
2033 | default: | ||
2034 | cflag |= B9600; | ||
2035 | /* | ||
2036 | * Set this to a sane value to prevent a divide error. | ||
2037 | */ | ||
2038 | baud = 9600; | ||
2039 | break; | ||
2040 | } | ||
2041 | switch(bits) { | ||
2042 | case 7: | ||
2043 | cflag |= CS7; | ||
2044 | break; | ||
2045 | default: | ||
2046 | case 8: | ||
2047 | cflag |= CS8; | ||
2048 | break; | ||
2049 | } | ||
2050 | switch(parity) { | ||
2051 | case 'o': case 'O': | ||
2052 | cflag |= PARODD; | ||
2053 | break; | ||
2054 | case 'e': case 'E': | ||
2055 | cflag |= PARENB; | ||
2056 | break; | ||
2057 | } | ||
2058 | co->cflag = cflag; | ||
2059 | |||
2060 | save_and_cli(flags); | ||
2061 | |||
2062 | /* | ||
2063 | * Set up the baud rate generator. | ||
2064 | */ | ||
2065 | brg = BPS_TO_BRG(baud, zs_parms->clock / clk_divisor); | ||
2066 | info->zs_channel->curregs[R12] = (brg & 255); | ||
2067 | info->zs_channel->curregs[R13] = ((brg >> 8) & 255); | ||
2068 | |||
2069 | /* | ||
2070 | * Set byte size and parity. | ||
2071 | */ | ||
2072 | if (bits == 7) { | ||
2073 | info->zs_channel->curregs[R3] |= Rx7; | ||
2074 | info->zs_channel->curregs[R5] |= Tx7; | ||
2075 | } else { | ||
2076 | info->zs_channel->curregs[R3] |= Rx8; | ||
2077 | info->zs_channel->curregs[R5] |= Tx8; | ||
2078 | } | ||
2079 | if (cflag & PARENB) { | ||
2080 | info->zs_channel->curregs[R4] |= PAR_ENA; | ||
2081 | } | ||
2082 | if (!(cflag & PARODD)) { | ||
2083 | info->zs_channel->curregs[R4] |= PAR_EVEN; | ||
2084 | } | ||
2085 | info->zs_channel->curregs[R4] |= SB1; | ||
2086 | |||
2087 | /* | ||
2088 | * Turn on RTS and DTR. | ||
2089 | */ | ||
2090 | zs_rtsdtr(info, RTS | DTR, 1); | ||
2091 | |||
2092 | /* | ||
2093 | * Finally, enable sequencing. | ||
2094 | */ | ||
2095 | info->zs_channel->curregs[R3] |= RxENABLE; | ||
2096 | info->zs_channel->curregs[R5] |= TxENAB; | ||
2097 | |||
2098 | /* | ||
2099 | * Clear the interrupt registers. | ||
2100 | */ | ||
2101 | write_zsreg(info->zs_channel, R0, ERR_RES); | ||
2102 | write_zsreg(info->zs_channel, R0, RES_H_IUS); | ||
2103 | |||
2104 | /* | ||
2105 | * Load up the new values. | ||
2106 | */ | ||
2107 | load_zsregs(info->zs_channel, info->zs_channel->curregs); | ||
2108 | |||
2109 | /* Save the current value of RR0 */ | ||
2110 | info->read_reg_zero = read_zsreg(info->zs_channel, R0); | ||
2111 | |||
2112 | zs_soft[co->index].clk_divisor = clk_divisor; | ||
2113 | zs_soft[co->index].zs_baud = get_zsbaud(&zs_soft[co->index]); | ||
2114 | |||
2115 | restore_flags(flags); | ||
2116 | |||
2117 | return 0; | ||
2118 | } | ||
2119 | |||
2120 | static struct console sercons = { | ||
2121 | .name = "ttyS", | ||
2122 | .write = serial_console_write, | ||
2123 | .device = serial_console_device, | ||
2124 | .setup = serial_console_setup, | ||
2125 | .flags = CON_PRINTBUFFER, | ||
2126 | .index = -1, | ||
2127 | }; | ||
2128 | |||
2129 | /* | ||
2130 | * Register console. | ||
2131 | */ | ||
2132 | void __init zs_serial_console_init(void) | ||
2133 | { | ||
2134 | register_console(&sercons); | ||
2135 | } | ||
2136 | #endif /* ifdef CONFIG_SERIAL_DEC_CONSOLE */ | ||
2137 | |||
2138 | #ifdef CONFIG_KGDB | ||
2139 | struct dec_zschannel *zs_kgdbchan; | ||
2140 | static unsigned char scc_inittab[] = { | ||
2141 | 9, 0x80, /* reset A side (CHRA) */ | ||
2142 | 13, 0, /* set baud rate divisor */ | ||
2143 | 12, 1, | ||
2144 | 14, 1, /* baud rate gen enable, src=rtxc (BRENABL) */ | ||
2145 | 11, 0x50, /* clocks = br gen (RCBR | TCBR) */ | ||
2146 | 5, 0x6a, /* tx 8 bits, assert RTS (Tx8 | TxENAB | RTS) */ | ||
2147 | 4, 0x44, /* x16 clock, 1 stop (SB1 | X16CLK)*/ | ||
2148 | 3, 0xc1, /* rx enable, 8 bits (RxENABLE | Rx8)*/ | ||
2149 | }; | ||
2150 | |||
2151 | /* These are for receiving and sending characters under the kgdb | ||
2152 | * source level kernel debugger. | ||
2153 | */ | ||
2154 | void putDebugChar(char kgdb_char) | ||
2155 | { | ||
2156 | struct dec_zschannel *chan = zs_kgdbchan; | ||
2157 | while ((read_zsreg(chan, 0) & Tx_BUF_EMP) == 0) | ||
2158 | RECOVERY_DELAY; | ||
2159 | write_zsdata(chan, kgdb_char); | ||
2160 | } | ||
2161 | char getDebugChar(void) | ||
2162 | { | ||
2163 | struct dec_zschannel *chan = zs_kgdbchan; | ||
2164 | while((read_zsreg(chan, 0) & Rx_CH_AV) == 0) | ||
2165 | eieio(); /*barrier();*/ | ||
2166 | return read_zsdata(chan); | ||
2167 | } | ||
2168 | void kgdb_interruptible(int yes) | ||
2169 | { | ||
2170 | struct dec_zschannel *chan = zs_kgdbchan; | ||
2171 | int one, nine; | ||
2172 | nine = read_zsreg(chan, 9); | ||
2173 | if (yes == 1) { | ||
2174 | one = EXT_INT_ENAB|RxINT_ALL; | ||
2175 | nine |= MIE; | ||
2176 | printk("turning serial ints on\n"); | ||
2177 | } else { | ||
2178 | one = RxINT_DISAB; | ||
2179 | nine &= ~MIE; | ||
2180 | printk("turning serial ints off\n"); | ||
2181 | } | ||
2182 | write_zsreg(chan, 1, one); | ||
2183 | write_zsreg(chan, 9, nine); | ||
2184 | } | ||
2185 | |||
2186 | static int kgdbhook_init_channel(void *handle) | ||
2187 | { | ||
2188 | return 0; | ||
2189 | } | ||
2190 | |||
2191 | static void kgdbhook_init_info(void *handle) | ||
2192 | { | ||
2193 | } | ||
2194 | |||
2195 | static void kgdbhook_rx_char(void *handle, unsigned char ch, unsigned char fl) | ||
2196 | { | ||
2197 | struct dec_serial *info = handle; | ||
2198 | |||
2199 | if (fl != TTY_NORMAL) | ||
2200 | return; | ||
2201 | if (ch == 0x03 || ch == '$') | ||
2202 | breakpoint(); | ||
2203 | } | ||
2204 | |||
2205 | /* This sets up the serial port we're using, and turns on | ||
2206 | * interrupts for that channel, so kgdb is usable once we're done. | ||
2207 | */ | ||
2208 | static inline void kgdb_chaninit(struct dec_zschannel *ms, int intson, int bps) | ||
2209 | { | ||
2210 | int brg; | ||
2211 | int i, x; | ||
2212 | volatile char *sccc = ms->control; | ||
2213 | brg = BPS_TO_BRG(bps, zs_parms->clock/16); | ||
2214 | printk("setting bps on kgdb line to %d [brg=%x]\n", bps, brg); | ||
2215 | for (i = 20000; i != 0; --i) { | ||
2216 | x = *sccc; eieio(); | ||
2217 | } | ||
2218 | for (i = 0; i < sizeof(scc_inittab); ++i) { | ||
2219 | write_zsreg(ms, scc_inittab[i], scc_inittab[i+1]); | ||
2220 | i++; | ||
2221 | } | ||
2222 | } | ||
2223 | /* This is called at boot time to prime the kgdb serial debugging | ||
2224 | * serial line. The 'tty_num' argument is 0 for /dev/ttya and 1 | ||
2225 | * for /dev/ttyb which is determined in setup_arch() from the | ||
2226 | * boot command line flags. | ||
2227 | */ | ||
2228 | struct dec_serial_hook zs_kgdbhook = { | ||
2229 | .init_channel = kgdbhook_init_channel, | ||
2230 | .init_info = kgdbhook_init_info, | ||
2231 | .rx_char = kgdbhook_rx_char, | ||
2232 | .cflags = B38400 | CS8 | CLOCAL, | ||
2233 | } | ||
2234 | |||
2235 | void __init zs_kgdb_hook(int tty_num) | ||
2236 | { | ||
2237 | /* Find out how many Z8530 SCCs we have */ | ||
2238 | if (zs_chain == 0) | ||
2239 | probe_sccs(); | ||
2240 | zs_soft[tty_num].zs_channel = &zs_channels[tty_num]; | ||
2241 | zs_kgdbchan = zs_soft[tty_num].zs_channel; | ||
2242 | zs_soft[tty_num].change_needed = 0; | ||
2243 | zs_soft[tty_num].clk_divisor = 16; | ||
2244 | zs_soft[tty_num].zs_baud = 38400; | ||
2245 | zs_soft[tty_num].hook = &zs_kgdbhook; /* This runs kgdb */ | ||
2246 | /* Turn on transmitter/receiver at 8-bits/char */ | ||
2247 | kgdb_chaninit(zs_soft[tty_num].zs_channel, 1, 38400); | ||
2248 | printk("KGDB: on channel %d initialized\n", tty_num); | ||
2249 | set_debug_traps(); /* init stub */ | ||
2250 | } | ||
2251 | #endif /* ifdef CONFIG_KGDB */ | ||
2252 | |||
2253 | |||
diff --git a/drivers/tc/zs.h b/drivers/tc/zs.h new file mode 100644 index 000000000000..c52edffa6049 --- /dev/null +++ b/drivers/tc/zs.h | |||
@@ -0,0 +1,405 @@ | |||
1 | /* | ||
2 | * drivers/tc/zs.h: Definitions for the DECstation Z85C30 serial driver. | ||
3 | * | ||
4 | * Adapted from drivers/sbus/char/sunserial.h by Paul Mackerras. | ||
5 | * Adapted from drivers/macintosh/macserial.h by Harald Koerfgen. | ||
6 | * | ||
7 | * Copyright (C) 1996 Paul Mackerras (Paul.Mackerras@cs.anu.edu.au) | ||
8 | * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) | ||
9 | * Copyright (C) 2004 Maciej W. Rozycki | ||
10 | */ | ||
11 | #ifndef _DECSERIAL_H | ||
12 | #define _DECSERIAL_H | ||
13 | |||
14 | #include <asm/dec/serial.h> | ||
15 | |||
16 | #define NUM_ZSREGS 16 | ||
17 | |||
18 | struct serial_struct { | ||
19 | int type; | ||
20 | int line; | ||
21 | int port; | ||
22 | int irq; | ||
23 | int flags; | ||
24 | int xmit_fifo_size; | ||
25 | int custom_divisor; | ||
26 | int baud_base; | ||
27 | unsigned short close_delay; | ||
28 | char reserved_char[2]; | ||
29 | int hub6; | ||
30 | unsigned short closing_wait; /* time to wait before closing */ | ||
31 | unsigned short closing_wait2; /* no longer used... */ | ||
32 | int reserved[4]; | ||
33 | }; | ||
34 | |||
35 | /* | ||
36 | * For the close wait times, 0 means wait forever for serial port to | ||
37 | * flush its output. 65535 means don't wait at all. | ||
38 | */ | ||
39 | #define ZILOG_CLOSING_WAIT_INF 0 | ||
40 | #define ZILOG_CLOSING_WAIT_NONE 65535 | ||
41 | |||
42 | /* | ||
43 | * Definitions for ZILOG_struct (and serial_struct) flags field | ||
44 | */ | ||
45 | #define ZILOG_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes | ||
46 | on the callout port */ | ||
47 | #define ZILOG_FOURPORT 0x0002 /* Set OU1, OUT2 per AST Fourport settings */ | ||
48 | #define ZILOG_SAK 0x0004 /* Secure Attention Key (Orange book) */ | ||
49 | #define ZILOG_SPLIT_TERMIOS 0x0008 /* Separate termios for dialin/callout */ | ||
50 | |||
51 | #define ZILOG_SPD_MASK 0x0030 | ||
52 | #define ZILOG_SPD_HI 0x0010 /* Use 56000 instead of 38400 bps */ | ||
53 | |||
54 | #define ZILOG_SPD_VHI 0x0020 /* Use 115200 instead of 38400 bps */ | ||
55 | #define ZILOG_SPD_CUST 0x0030 /* Use user-specified divisor */ | ||
56 | |||
57 | #define ZILOG_SKIP_TEST 0x0040 /* Skip UART test during autoconfiguration */ | ||
58 | #define ZILOG_AUTO_IRQ 0x0080 /* Do automatic IRQ during autoconfiguration */ | ||
59 | #define ZILOG_SESSION_LOCKOUT 0x0100 /* Lock out cua opens based on session */ | ||
60 | #define ZILOG_PGRP_LOCKOUT 0x0200 /* Lock out cua opens based on pgrp */ | ||
61 | #define ZILOG_CALLOUT_NOHUP 0x0400 /* Don't do hangups for cua device */ | ||
62 | |||
63 | #define ZILOG_FLAGS 0x0FFF /* Possible legal ZILOG flags */ | ||
64 | #define ZILOG_USR_MASK 0x0430 /* Legal flags that non-privileged | ||
65 | * users can set or reset */ | ||
66 | |||
67 | /* Internal flags used only by kernel/chr_drv/serial.c */ | ||
68 | #define ZILOG_INITIALIZED 0x80000000 /* Serial port was initialized */ | ||
69 | #define ZILOG_CALLOUT_ACTIVE 0x40000000 /* Call out device is active */ | ||
70 | #define ZILOG_NORMAL_ACTIVE 0x20000000 /* Normal device is active */ | ||
71 | #define ZILOG_BOOT_AUTOCONF 0x10000000 /* Autoconfigure port on bootup */ | ||
72 | #define ZILOG_CLOSING 0x08000000 /* Serial port is closing */ | ||
73 | #define ZILOG_CTS_FLOW 0x04000000 /* Do CTS flow control */ | ||
74 | #define ZILOG_CHECK_CD 0x02000000 /* i.e., CLOCAL */ | ||
75 | |||
76 | /* Software state per channel */ | ||
77 | |||
78 | #ifdef __KERNEL__ | ||
79 | /* | ||
80 | * This is our internal structure for each serial port's state. | ||
81 | * | ||
82 | * Many fields are paralleled by the structure used by the serial_struct | ||
83 | * structure. | ||
84 | * | ||
85 | * For definitions of the flags field, see tty.h | ||
86 | */ | ||
87 | |||
88 | struct dec_zschannel { | ||
89 | volatile unsigned char *control; | ||
90 | volatile unsigned char *data; | ||
91 | |||
92 | /* Current write register values */ | ||
93 | unsigned char curregs[NUM_ZSREGS]; | ||
94 | }; | ||
95 | |||
96 | struct dec_serial { | ||
97 | struct dec_serial *zs_next; /* For IRQ servicing chain. */ | ||
98 | struct dec_zschannel *zs_channel; /* Channel registers. */ | ||
99 | struct dec_zschannel *zs_chan_a; /* A side registers. */ | ||
100 | unsigned char read_reg_zero; | ||
101 | |||
102 | struct dec_serial_hook *hook; /* Hook on this channel. */ | ||
103 | int tty_break; /* Set on BREAK condition. */ | ||
104 | int is_cons; /* Is this our console. */ | ||
105 | int tx_active; /* Char is being xmitted. */ | ||
106 | int tx_stopped; /* Output is suspended. */ | ||
107 | |||
108 | /* | ||
109 | * We need to know the current clock divisor | ||
110 | * to read the bps rate the chip has currently loaded. | ||
111 | */ | ||
112 | int clk_divisor; /* May be 1, 16, 32, or 64. */ | ||
113 | int zs_baud; | ||
114 | |||
115 | char change_needed; | ||
116 | |||
117 | int magic; | ||
118 | int baud_base; | ||
119 | int port; | ||
120 | int irq; | ||
121 | int flags; /* Defined in tty.h. */ | ||
122 | int type; /* UART type. */ | ||
123 | struct tty_struct *tty; | ||
124 | int read_status_mask; | ||
125 | int ignore_status_mask; | ||
126 | int timeout; | ||
127 | int xmit_fifo_size; | ||
128 | int custom_divisor; | ||
129 | int x_char; /* XON/XOFF character. */ | ||
130 | int close_delay; | ||
131 | unsigned short closing_wait; | ||
132 | unsigned short closing_wait2; | ||
133 | unsigned long event; | ||
134 | unsigned long last_active; | ||
135 | int line; | ||
136 | int count; /* # of fds on device. */ | ||
137 | int blocked_open; /* # of blocked opens. */ | ||
138 | unsigned char *xmit_buf; | ||
139 | int xmit_head; | ||
140 | int xmit_tail; | ||
141 | int xmit_cnt; | ||
142 | struct tq_struct tqueue; | ||
143 | struct tq_struct tqueue_hangup; | ||
144 | wait_queue_head_t open_wait; | ||
145 | wait_queue_head_t close_wait; | ||
146 | }; | ||
147 | |||
148 | |||
149 | #define SERIAL_MAGIC 0x5301 | ||
150 | |||
151 | /* | ||
152 | * The size of the serial xmit buffer is 1 page, or 4096 bytes | ||
153 | */ | ||
154 | #define SERIAL_XMIT_SIZE 4096 | ||
155 | |||
156 | /* | ||
157 | * Events are used to schedule things to happen at timer-interrupt | ||
158 | * time, instead of at rs interrupt time. | ||
159 | */ | ||
160 | #define RS_EVENT_WRITE_WAKEUP 0 | ||
161 | |||
162 | #endif /* __KERNEL__ */ | ||
163 | |||
164 | /* Conversion routines to/from brg time constants from/to bits | ||
165 | * per second. | ||
166 | */ | ||
167 | #define BRG_TO_BPS(brg, freq) ((freq) / 2 / ((brg) + 2)) | ||
168 | #define BPS_TO_BRG(bps, freq) ((((freq) + (bps)) / (2 * (bps))) - 2) | ||
169 | |||
170 | /* The Zilog register set */ | ||
171 | |||
172 | #define FLAG 0x7e | ||
173 | |||
174 | /* Write Register 0 */ | ||
175 | #define R0 0 /* Register selects */ | ||
176 | #define R1 1 | ||
177 | #define R2 2 | ||
178 | #define R3 3 | ||
179 | #define R4 4 | ||
180 | #define R5 5 | ||
181 | #define R6 6 | ||
182 | #define R7 7 | ||
183 | #define R8 8 | ||
184 | #define R9 9 | ||
185 | #define R10 10 | ||
186 | #define R11 11 | ||
187 | #define R12 12 | ||
188 | #define R13 13 | ||
189 | #define R14 14 | ||
190 | #define R15 15 | ||
191 | |||
192 | #define NULLCODE 0 /* Null Code */ | ||
193 | #define POINT_HIGH 0x8 /* Select upper half of registers */ | ||
194 | #define RES_EXT_INT 0x10 /* Reset Ext. Status Interrupts */ | ||
195 | #define SEND_ABORT 0x18 /* HDLC Abort */ | ||
196 | #define RES_RxINT_FC 0x20 /* Reset RxINT on First Character */ | ||
197 | #define RES_Tx_P 0x28 /* Reset TxINT Pending */ | ||
198 | #define ERR_RES 0x30 /* Error Reset */ | ||
199 | #define RES_H_IUS 0x38 /* Reset highest IUS */ | ||
200 | |||
201 | #define RES_Rx_CRC 0x40 /* Reset Rx CRC Checker */ | ||
202 | #define RES_Tx_CRC 0x80 /* Reset Tx CRC Checker */ | ||
203 | #define RES_EOM_L 0xC0 /* Reset EOM latch */ | ||
204 | |||
205 | /* Write Register 1 */ | ||
206 | |||
207 | #define EXT_INT_ENAB 0x1 /* Ext Int Enable */ | ||
208 | #define TxINT_ENAB 0x2 /* Tx Int Enable */ | ||
209 | #define PAR_SPEC 0x4 /* Parity is special condition */ | ||
210 | |||
211 | #define RxINT_DISAB 0 /* Rx Int Disable */ | ||
212 | #define RxINT_FCERR 0x8 /* Rx Int on First Character Only or Error */ | ||
213 | #define RxINT_ALL 0x10 /* Int on all Rx Characters or error */ | ||
214 | #define RxINT_ERR 0x18 /* Int on error only */ | ||
215 | #define RxINT_MASK 0x18 | ||
216 | |||
217 | #define WT_RDY_RT 0x20 /* Wait/Ready on R/T */ | ||
218 | #define WT_FN_RDYFN 0x40 /* Wait/FN/Ready FN */ | ||
219 | #define WT_RDY_ENAB 0x80 /* Wait/Ready Enable */ | ||
220 | |||
221 | /* Write Register #2 (Interrupt Vector) */ | ||
222 | |||
223 | /* Write Register 3 */ | ||
224 | |||
225 | #define RxENABLE 0x1 /* Rx Enable */ | ||
226 | #define SYNC_L_INH 0x2 /* Sync Character Load Inhibit */ | ||
227 | #define ADD_SM 0x4 /* Address Search Mode (SDLC) */ | ||
228 | #define RxCRC_ENAB 0x8 /* Rx CRC Enable */ | ||
229 | #define ENT_HM 0x10 /* Enter Hunt Mode */ | ||
230 | #define AUTO_ENAB 0x20 /* Auto Enables */ | ||
231 | #define Rx5 0x0 /* Rx 5 Bits/Character */ | ||
232 | #define Rx7 0x40 /* Rx 7 Bits/Character */ | ||
233 | #define Rx6 0x80 /* Rx 6 Bits/Character */ | ||
234 | #define Rx8 0xc0 /* Rx 8 Bits/Character */ | ||
235 | #define RxNBITS_MASK 0xc0 | ||
236 | |||
237 | /* Write Register 4 */ | ||
238 | |||
239 | #define PAR_ENA 0x1 /* Parity Enable */ | ||
240 | #define PAR_EVEN 0x2 /* Parity Even/Odd* */ | ||
241 | |||
242 | #define SYNC_ENAB 0 /* Sync Modes Enable */ | ||
243 | #define SB1 0x4 /* 1 stop bit/char */ | ||
244 | #define SB15 0x8 /* 1.5 stop bits/char */ | ||
245 | #define SB2 0xc /* 2 stop bits/char */ | ||
246 | #define SB_MASK 0xc | ||
247 | |||
248 | #define MONSYNC 0 /* 8 Bit Sync character */ | ||
249 | #define BISYNC 0x10 /* 16 bit sync character */ | ||
250 | #define SDLC 0x20 /* SDLC Mode (01111110 Sync Flag) */ | ||
251 | #define EXTSYNC 0x30 /* External Sync Mode */ | ||
252 | |||
253 | #define X1CLK 0x0 /* x1 clock mode */ | ||
254 | #define X16CLK 0x40 /* x16 clock mode */ | ||
255 | #define X32CLK 0x80 /* x32 clock mode */ | ||
256 | #define X64CLK 0xC0 /* x64 clock mode */ | ||
257 | #define XCLK_MASK 0xC0 | ||
258 | |||
259 | /* Write Register 5 */ | ||
260 | |||
261 | #define TxCRC_ENAB 0x1 /* Tx CRC Enable */ | ||
262 | #define RTS 0x2 /* RTS */ | ||
263 | #define SDLC_CRC 0x4 /* SDLC/CRC-16 */ | ||
264 | #define TxENAB 0x8 /* Tx Enable */ | ||
265 | #define SND_BRK 0x10 /* Send Break */ | ||
266 | #define Tx5 0x0 /* Tx 5 bits (or less)/character */ | ||
267 | #define Tx7 0x20 /* Tx 7 bits/character */ | ||
268 | #define Tx6 0x40 /* Tx 6 bits/character */ | ||
269 | #define Tx8 0x60 /* Tx 8 bits/character */ | ||
270 | #define TxNBITS_MASK 0x60 | ||
271 | #define DTR 0x80 /* DTR */ | ||
272 | |||
273 | /* Write Register 6 (Sync bits 0-7/SDLC Address Field) */ | ||
274 | |||
275 | /* Write Register 7 (Sync bits 8-15/SDLC 01111110) */ | ||
276 | |||
277 | /* Write Register 8 (transmit buffer) */ | ||
278 | |||
279 | /* Write Register 9 (Master interrupt control) */ | ||
280 | #define VIS 1 /* Vector Includes Status */ | ||
281 | #define NV 2 /* No Vector */ | ||
282 | #define DLC 4 /* Disable Lower Chain */ | ||
283 | #define MIE 8 /* Master Interrupt Enable */ | ||
284 | #define STATHI 0x10 /* Status high */ | ||
285 | #define SOFTACK 0x20 /* Software Interrupt Acknowledge */ | ||
286 | #define NORESET 0 /* No reset on write to R9 */ | ||
287 | #define CHRB 0x40 /* Reset channel B */ | ||
288 | #define CHRA 0x80 /* Reset channel A */ | ||
289 | #define FHWRES 0xc0 /* Force hardware reset */ | ||
290 | |||
291 | /* Write Register 10 (misc control bits) */ | ||
292 | #define BIT6 1 /* 6 bit/8bit sync */ | ||
293 | #define LOOPMODE 2 /* SDLC Loop mode */ | ||
294 | #define ABUNDER 4 /* Abort/flag on SDLC xmit underrun */ | ||
295 | #define MARKIDLE 8 /* Mark/flag on idle */ | ||
296 | #define GAOP 0x10 /* Go active on poll */ | ||
297 | #define NRZ 0 /* NRZ mode */ | ||
298 | #define NRZI 0x20 /* NRZI mode */ | ||
299 | #define FM1 0x40 /* FM1 (transition = 1) */ | ||
300 | #define FM0 0x60 /* FM0 (transition = 0) */ | ||
301 | #define CRCPS 0x80 /* CRC Preset I/O */ | ||
302 | |||
303 | /* Write Register 11 (Clock Mode control) */ | ||
304 | #define TRxCXT 0 /* TRxC = Xtal output */ | ||
305 | #define TRxCTC 1 /* TRxC = Transmit clock */ | ||
306 | #define TRxCBR 2 /* TRxC = BR Generator Output */ | ||
307 | #define TRxCDP 3 /* TRxC = DPLL output */ | ||
308 | #define TRxCOI 4 /* TRxC O/I */ | ||
309 | #define TCRTxCP 0 /* Transmit clock = RTxC pin */ | ||
310 | #define TCTRxCP 8 /* Transmit clock = TRxC pin */ | ||
311 | #define TCBR 0x10 /* Transmit clock = BR Generator output */ | ||
312 | #define TCDPLL 0x18 /* Transmit clock = DPLL output */ | ||
313 | #define RCRTxCP 0 /* Receive clock = RTxC pin */ | ||
314 | #define RCTRxCP 0x20 /* Receive clock = TRxC pin */ | ||
315 | #define RCBR 0x40 /* Receive clock = BR Generator output */ | ||
316 | #define RCDPLL 0x60 /* Receive clock = DPLL output */ | ||
317 | #define RTxCX 0x80 /* RTxC Xtal/No Xtal */ | ||
318 | |||
319 | /* Write Register 12 (lower byte of baud rate generator time constant) */ | ||
320 | |||
321 | /* Write Register 13 (upper byte of baud rate generator time constant) */ | ||
322 | |||
323 | /* Write Register 14 (Misc control bits) */ | ||
324 | #define BRENABL 1 /* Baud rate generator enable */ | ||
325 | #define BRSRC 2 /* Baud rate generator source */ | ||
326 | #define DTRREQ 4 /* DTR/Request function */ | ||
327 | #define AUTOECHO 8 /* Auto Echo */ | ||
328 | #define LOOPBAK 0x10 /* Local loopback */ | ||
329 | #define SEARCH 0x20 /* Enter search mode */ | ||
330 | #define RMC 0x40 /* Reset missing clock */ | ||
331 | #define DISDPLL 0x60 /* Disable DPLL */ | ||
332 | #define SSBR 0x80 /* Set DPLL source = BR generator */ | ||
333 | #define SSRTxC 0xa0 /* Set DPLL source = RTxC */ | ||
334 | #define SFMM 0xc0 /* Set FM mode */ | ||
335 | #define SNRZI 0xe0 /* Set NRZI mode */ | ||
336 | |||
337 | /* Write Register 15 (external/status interrupt control) */ | ||
338 | #define ZCIE 2 /* Zero count IE */ | ||
339 | #define DCDIE 8 /* DCD IE */ | ||
340 | #define SYNCIE 0x10 /* Sync/hunt IE */ | ||
341 | #define CTSIE 0x20 /* CTS IE */ | ||
342 | #define TxUIE 0x40 /* Tx Underrun/EOM IE */ | ||
343 | #define BRKIE 0x80 /* Break/Abort IE */ | ||
344 | |||
345 | |||
346 | /* Read Register 0 */ | ||
347 | #define Rx_CH_AV 0x1 /* Rx Character Available */ | ||
348 | #define ZCOUNT 0x2 /* Zero count */ | ||
349 | #define Tx_BUF_EMP 0x4 /* Tx Buffer empty */ | ||
350 | #define DCD 0x8 /* DCD */ | ||
351 | #define SYNC_HUNT 0x10 /* Sync/hunt */ | ||
352 | #define CTS 0x20 /* CTS */ | ||
353 | #define TxEOM 0x40 /* Tx underrun */ | ||
354 | #define BRK_ABRT 0x80 /* Break/Abort */ | ||
355 | |||
356 | /* Read Register 1 */ | ||
357 | #define ALL_SNT 0x1 /* All sent */ | ||
358 | /* Residue Data for 8 Rx bits/char programmed */ | ||
359 | #define RES3 0x8 /* 0/3 */ | ||
360 | #define RES4 0x4 /* 0/4 */ | ||
361 | #define RES5 0xc /* 0/5 */ | ||
362 | #define RES6 0x2 /* 0/6 */ | ||
363 | #define RES7 0xa /* 0/7 */ | ||
364 | #define RES8 0x6 /* 0/8 */ | ||
365 | #define RES18 0xe /* 1/8 */ | ||
366 | #define RES28 0x0 /* 2/8 */ | ||
367 | /* Special Rx Condition Interrupts */ | ||
368 | #define PAR_ERR 0x10 /* Parity error */ | ||
369 | #define Rx_OVR 0x20 /* Rx Overrun Error */ | ||
370 | #define FRM_ERR 0x40 /* CRC/Framing Error */ | ||
371 | #define END_FR 0x80 /* End of Frame (SDLC) */ | ||
372 | |||
373 | /* Read Register 2 (channel b only) - Interrupt vector */ | ||
374 | |||
375 | /* Read Register 3 (interrupt pending register) ch a only */ | ||
376 | #define CHBEXT 0x1 /* Channel B Ext/Stat IP */ | ||
377 | #define CHBTxIP 0x2 /* Channel B Tx IP */ | ||
378 | #define CHBRxIP 0x4 /* Channel B Rx IP */ | ||
379 | #define CHAEXT 0x8 /* Channel A Ext/Stat IP */ | ||
380 | #define CHATxIP 0x10 /* Channel A Tx IP */ | ||
381 | #define CHARxIP 0x20 /* Channel A Rx IP */ | ||
382 | |||
383 | /* Read Register 8 (receive data register) */ | ||
384 | |||
385 | /* Read Register 10 (misc status bits) */ | ||
386 | #define ONLOOP 2 /* On loop */ | ||
387 | #define LOOPSEND 0x10 /* Loop sending */ | ||
388 | #define CLK2MIS 0x40 /* Two clocks missing */ | ||
389 | #define CLK1MIS 0x80 /* One clock missing */ | ||
390 | |||
391 | /* Read Register 12 (lower byte of baud rate generator constant) */ | ||
392 | |||
393 | /* Read Register 13 (upper byte of baud rate generator constant) */ | ||
394 | |||
395 | /* Read Register 15 (value of WR 15) */ | ||
396 | |||
397 | /* Misc macros */ | ||
398 | #define ZS_CLEARERR(channel) (write_zsreg(channel, 0, ERR_RES)) | ||
399 | #define ZS_CLEARFIFO(channel) do { volatile unsigned char garbage; \ | ||
400 | garbage = read_zsdata(channel); \ | ||
401 | garbage = read_zsdata(channel); \ | ||
402 | garbage = read_zsdata(channel); \ | ||
403 | } while(0) | ||
404 | |||
405 | #endif /* !(_DECSERIAL_H) */ | ||