xref: /linux/drivers/ata/pata_parport/kbic.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * (c) 1997-1998  Grant R. Guenther <grant@torque.net>
4  *
5  * This is a low-level driver for the KBIC-951A and KBIC-971A
6  * parallel to IDE adapter chips from KingByte Information Systems.
7  *
8  * The chips are almost identical, however, the wakeup code
9  * required for the 971A interferes with the correct operation of
10  * the 951A, so this driver registers itself twice, once for
11  * each chip.
12  */
13 
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/wait.h>
20 #include <asm/io.h>
21 #include "pata_parport.h"
22 
23 #define r12w()		(delay_p, inw(pi->port + 1) & 0xffff)
24 
25 #define j44(a, b)	((((a >> 4) & 0x0f) | (b & 0xf0)) ^ 0x88)
26 #define j53(w)		(((w >> 3) & 0x1f) | ((w >> 4) & 0xe0))
27 
28 
29 /*
30  * cont = 0 - access the IDE register file
31  * cont = 1 - access the IDE command set
32  */
33 static int cont_map[2] = { 0x80, 0x40 };
34 
kbic_read_regr(struct pi_adapter * pi,int cont,int regr)35 static int kbic_read_regr(struct pi_adapter *pi, int cont, int regr)
36 {
37 	int a, b, s;
38 
39 	s = cont_map[cont];
40 
41 	switch (pi->mode) {
42 	case 0:
43 		w0(regr | 0x18 | s); w2(4); w2(6); w2(4); w2(1); w0(8);
44 		a = r1(); w0(0x28); b = r1(); w2(4);
45 		return j44(a, b);
46 	case 1:
47 		w0(regr|0x38 | s); w2(4); w2(6); w2(4); w2(5); w0(8);
48 		a = r12w(); w2(4);
49 		return j53(a);
50 	case 2:
51 		w0(regr | 0x08 | s); w2(4); w2(6); w2(4); w2(0xa5); w2(0xa1);
52 		a = r0(); w2(4);
53 		return a;
54 	case 3:
55 	case 4:
56 	case 5:
57 		w0(0x20 | s); w2(4); w2(6); w2(4); w3(regr);
58 		a = r4(); b = r4(); w2(4); w2(0); w2(4);
59 		return a;
60 	}
61 
62 	return -1;
63 }
64 
kbic_write_regr(struct pi_adapter * pi,int cont,int regr,int val)65 static void kbic_write_regr(struct pi_adapter *pi, int cont, int regr, int val)
66 {
67 	int s = cont_map[cont];
68 
69 	switch (pi->mode) {
70 	case 0:
71 	case 1:
72 	case 2:
73 		w0(regr | 0x10 | s); w2(4); w2(6); w2(4);
74 		w0(val); w2(5); w2(4);
75 		break;
76 	case 3:
77 	case 4:
78 	case 5:
79 		w0(0x20 | s); w2(4); w2(6); w2(4); w3(regr);
80 		w4(val); w4(val);
81 		w2(4); w2(0); w2(4);
82 		break;
83 	}
84 }
85 
k951_connect(struct pi_adapter * pi)86 static void k951_connect(struct pi_adapter *pi)
87 {
88 	pi->saved_r0 = r0();
89 	pi->saved_r2 = r2();
90 	w2(4);
91 }
92 
k951_disconnect(struct pi_adapter * pi)93 static void k951_disconnect(struct pi_adapter *pi)
94 {
95 	w0(pi->saved_r0);
96 	w2(pi->saved_r2);
97 }
98 
99 #define	CCP(x)						\
100 	do {						\
101 		w2(0xc4); w0(0xaa); w0(0x55);		\
102 		w0(0); w0(0xff); w0(0x87);		\
103 		w0(0x78); w0(x); w2(0xc5);		\
104 		w2(0xc4); w0(0xff);			\
105 	} while (0)
106 
k971_connect(struct pi_adapter * pi)107 static void k971_connect(struct pi_adapter *pi)
108 {
109 	pi->saved_r0 = r0();
110 	pi->saved_r2 = r2();
111 	CCP(0x20);
112 	w2(4);
113 }
114 
k971_disconnect(struct pi_adapter * pi)115 static void k971_disconnect(struct pi_adapter *pi)
116 {
117 	CCP(0x30);
118 	w0(pi->saved_r0);
119 	w2(pi->saved_r2);
120 }
121 
122 /*
123  * count must be congruent to 0 MOD 4, but all known applications
124  *have this property.
125  */
kbic_read_block(struct pi_adapter * pi,char * buf,int count)126 static void kbic_read_block(struct pi_adapter *pi, char *buf, int count)
127 {
128 	int k, a, b;
129 
130 	switch (pi->mode) {
131 	case 0:
132 		w0(0x98); w2(4); w2(6); w2(4);
133 		for (k = 0; k < count / 2; k++) {
134 			w2(1); w0(8);
135 			a = r1();
136 			w0(0x28);
137 			b = r1();
138 			buf[2 * k] = j44(a, b);
139 			w2(5);
140 			b = r1();
141 			w0(8);
142 			a = r1();
143 			buf[2 * k + 1] = j44(a, b);
144 			w2(4);
145 		}
146 		break;
147 	case 1:
148 		w0(0xb8); w2(4); w2(6); w2(4);
149 		for (k = 0; k < count / 4; k++) {
150 			w0(0xb8);
151 			w2(4); w2(5);
152 			w0(8);
153 			buf[4 * k] = j53(r12w());
154 			w0(0xb8);
155 			buf[4 * k + 1] = j53(r12w());
156 			w2(4); w2(5);
157 			buf[4 * k + 3] = j53(r12w());
158 			w0(8);
159 			buf[4 * k + 2] = j53(r12w());
160 		}
161 		w2(4);
162 		break;
163 	case 2:
164 		w0(0x88); w2(4); w2(6); w2(4);
165 		for (k = 0; k < count / 2; k++) {
166 			w2(0xa0); w2(0xa1);
167 			buf[2 * k] = r0();
168 			w2(0xa5);
169 			buf[2 * k + 1] = r0();
170 		}
171 		w2(4);
172 		break;
173 	case 3:
174 		w0(0xa0); w2(4); w2(6); w2(4); w3(0);
175 		for (k = 0; k < count; k++)
176 			buf[k] = r4();
177 		w2(4); w2(0); w2(4);
178 		break;
179 	case 4:
180 		w0(0xa0); w2(4); w2(6); w2(4); w3(0);
181 		for (k = 0; k < count / 2; k++)
182 			((u16 *)buf)[k] = r4w();
183 		w2(4); w2(0); w2(4);
184 		break;
185 	case 5:
186 		w0(0xa0); w2(4); w2(6); w2(4); w3(0);
187 		for (k = 0; k < count / 4; k++)
188 			((u32 *)buf)[k] = r4l();
189 		w2(4); w2(0); w2(4);
190 		break;
191 	}
192 }
193 
kbic_write_block(struct pi_adapter * pi,char * buf,int count)194 static void kbic_write_block(struct pi_adapter *pi, char *buf, int count)
195 {
196 	int k;
197 
198 	switch (pi->mode) {
199 	case 0:
200 	case 1:
201 	case 2:
202 		w0(0x90); w2(4); w2(6); w2(4);
203 		for (k = 0; k < count / 2; k++) {
204 			w0(buf[2 * k + 1]);
205 			w2(0); w2(4);
206 			w0(buf[2 * k]);
207 			w2(5); w2(4);
208 		}
209 		break;
210 	case 3:
211 		w0(0xa0); w2(4); w2(6); w2(4); w3(0);
212 		for (k = 0; k < count / 2; k++) {
213 			w4(buf[2 * k + 1]);
214 			w4(buf[2 * k]);
215 		}
216 		w2(4); w2(0); w2(4);
217 		break;
218 	case 4:
219 		w0(0xa0); w2(4); w2(6); w2(4); w3(0);
220 		for (k = 0; k < count / 2; k++)
221 			w4w(swab16(((u16 *)buf)[k]));
222 		w2(4); w2(0); w2(4);
223 		break;
224 	case 5:
225 		w0(0xa0); w2(4); w2(6); w2(4); w3(0);
226 		for (k = 0; k < count / 4; k++)
227 			w4l(swab16(((u16 *)buf)[2 * k]) |
228 			    swab16(((u16 *)buf)[2 * k + 1]) << 16);
229 		w2(4); w2(0); w2(4);
230 		break;
231 	}
232 }
233 
kbic_log_adapter(struct pi_adapter * pi,char * chip)234 static void kbic_log_adapter(struct pi_adapter *pi, char *chip)
235 {
236 	char *mode[6] = { "4-bit", "5/3", "8-bit", "EPP-8", "EPP_16", "EPP-32"};
237 
238 	dev_info(&pi->dev, "KingByte %s at 0x%x, mode %d (%s), delay %d\n",
239 		 chip, pi->port, pi->mode, mode[pi->mode], pi->delay);
240 }
241 
k951_log_adapter(struct pi_adapter * pi)242 static void k951_log_adapter(struct pi_adapter *pi)
243 {
244 	kbic_log_adapter(pi, "KBIC-951A");
245 }
246 
k971_log_adapter(struct pi_adapter * pi)247 static void k971_log_adapter(struct pi_adapter *pi)
248 {
249 	kbic_log_adapter(pi, "KBIC-971A");
250 }
251 
252 static struct pi_protocol k951 = {
253 	.owner		= THIS_MODULE,
254 	.name		= "k951",
255 	.max_mode	= 6,
256 	.epp_first	= 3,
257 	.default_delay	= 1,
258 	.max_units	= 1,
259 	.write_regr	= kbic_write_regr,
260 	.read_regr	= kbic_read_regr,
261 	.write_block	= kbic_write_block,
262 	.read_block	= kbic_read_block,
263 	.connect	= k951_connect,
264 	.disconnect	= k951_disconnect,
265 	.log_adapter	= k951_log_adapter,
266 };
267 
268 static struct pi_protocol k971 = {
269 	.owner		= THIS_MODULE,
270 	.name		= "k971",
271 	.max_mode	= 6,
272 	.epp_first	= 3,
273 	.default_delay	= 1,
274 	.max_units	= 1,
275 	.write_regr	= kbic_write_regr,
276 	.read_regr	= kbic_read_regr,
277 	.write_block	= kbic_write_block,
278 	.read_block	= kbic_read_block,
279 	.connect	= k971_connect,
280 	.disconnect	= k971_disconnect,
281 	.log_adapter	= k971_log_adapter,
282 };
283 
kbic_init(void)284 static int __init kbic_init(void)
285 {
286 	int rv;
287 
288 	rv = pata_parport_register_driver(&k951);
289 	if (rv < 0)
290 		return rv;
291 	rv = pata_parport_register_driver(&k971);
292 	if (rv < 0)
293 		pata_parport_unregister_driver(&k951);
294 	return rv;
295 }
296 
kbic_exit(void)297 static void __exit kbic_exit(void)
298 {
299 	pata_parport_unregister_driver(&k951);
300 	pata_parport_unregister_driver(&k971);
301 }
302 
303 MODULE_LICENSE("GPL");
304 MODULE_AUTHOR("Grant R. Guenther <grant@torque.net>");
305 MODULE_DESCRIPTION("KingByte Information Systems KBIC-951A and KBIC-971A "
306 		   "parallel port IDE adapter protocol driver");
307 module_init(kbic_init)
308 module_exit(kbic_exit)
309