[PATCH] paride_register(): shuffle return values
[linux-2.6.git] / drivers / block / paride / epia.c
1 /* 
2         epia.c    (c) 1997-8  Grant R. Guenther <grant@torque.net>
3                               Under the terms of the GNU General Public License.
4
5         epia.c is a low-level protocol driver for Shuttle Technologies 
6         EPIA parallel to IDE adapter chip.  This device is now obsolete
7         and has been replaced with the EPAT chip, which is supported
8         by epat.c, however, some devices based on EPIA are still
9         available.
10
11 */
12
13 /* Changes:
14
15         1.01    GRG 1998.05.06 init_proto, release_proto
16         1.02    GRG 1998.06.17 support older versions of EPIA
17
18 */
19
20 #define EPIA_VERSION      "1.02"
21
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/kernel.h>
26 #include <linux/types.h>
27 #include <linux/wait.h>
28 #include <asm/io.h>
29
30 #include "paride.h"
31
32 /* mode codes:  0  nybble reads on port 1, 8-bit writes
33                 1  5/3 reads on ports 1 & 2, 8-bit writes
34                 2  8-bit reads and writes
35                 3  8-bit EPP mode
36                 4  16-bit EPP
37                 5  32-bit EPP
38 */
39
40 #define j44(a,b)                (((a>>4)&0x0f)+(b&0xf0))
41 #define j53(a,b)                (((a>>3)&0x1f)+((b<<4)&0xe0))
42
43 /* cont =  0   IDE register file
44    cont =  1   IDE control registers
45 */
46
47 static int cont_map[2] = { 0, 0x80 };
48
49 static int epia_read_regr( PIA *pi, int cont, int regr )
50
51 {       int     a, b, r;
52
53         regr += cont_map[cont];
54
55         switch (pi->mode)  {
56
57         case 0: r = regr^0x39;
58                 w0(r); w2(1); w2(3); w0(r);
59                 a = r1(); w2(1); b = r1(); w2(4);
60                 return j44(a,b);
61
62         case 1: r = regr^0x31;
63                 w0(r); w2(1); w0(r&0x37); 
64                 w2(3); w2(5); w0(r|0xf0);
65                 a = r1(); b = r2(); w2(4);
66                 return j53(a,b);
67
68         case 2: r = regr^0x29;
69                 w0(r); w2(1); w2(0X21); w2(0x23); 
70                 a = r0(); w2(4);
71                 return a;
72
73         case 3:
74         case 4:
75         case 5: w3(regr); w2(0x24); a = r4(); w2(4);
76                 return a;
77
78         }
79         return -1;
80 }       
81
82 static void epia_write_regr( PIA *pi, int cont, int regr, int val)
83
84 {       int  r;
85
86         regr += cont_map[cont];
87
88         switch (pi->mode)  {
89
90         case 0:
91         case 1:
92         case 2: r = regr^0x19;
93                 w0(r); w2(1); w0(val); w2(3); w2(4);
94                 break;
95
96         case 3:
97         case 4:
98         case 5: r = regr^0x40;
99                 w3(r); w4(val); w2(4);
100                 break;
101         }
102 }
103
104 #define WR(r,v)         epia_write_regr(pi,0,r,v)
105 #define RR(r)           (epia_read_regr(pi,0,r))
106
107 /* The use of register 0x84 is entirely unclear - it seems to control
108    some EPP counters ...  currently we know about 3 different block
109    sizes:  the standard 512 byte reads and writes, 12 byte writes and 
110    2048 byte reads (the last two being used in the CDrom drivers.
111 */
112
113 static void epia_connect ( PIA *pi  )
114
115 {       pi->saved_r0 = r0();
116         pi->saved_r2 = r2();
117
118         w2(4); w0(0xa0); w0(0x50); w0(0xc0); w0(0x30); w0(0xa0); w0(0);
119         w2(1); w2(4);
120         if (pi->mode >= 3) { 
121                 w0(0xa); w2(1); w2(4); w0(0x82); w2(4); w2(0xc); w2(4);
122                 w2(0x24); w2(0x26); w2(4);
123         }
124         WR(0x86,8);  
125 }
126
127 static void epia_disconnect ( PIA *pi )
128
129 {       /* WR(0x84,0x10); */
130         w0(pi->saved_r0);
131         w2(1); w2(4);
132         w0(pi->saved_r0);
133         w2(pi->saved_r2);
134
135
136 static void epia_read_block( PIA *pi, char * buf, int count )
137
138 {       int     k, ph, a, b;
139
140         switch (pi->mode) {
141
142         case 0: w0(0x81); w2(1); w2(3); w0(0xc1);
143                 ph = 1;
144                 for (k=0;k<count;k++) {
145                         w2(2+ph); a = r1();
146                         w2(4+ph); b = r1();
147                         buf[k] = j44(a,b);
148                         ph = 1 - ph;
149                 } 
150                 w0(0); w2(4);
151                 break;
152
153         case 1: w0(0x91); w2(1); w0(0x10); w2(3); 
154                 w0(0x51); w2(5); w0(0xd1); 
155                 ph = 1;
156                 for (k=0;k<count;k++) {
157                         w2(4+ph);
158                         a = r1(); b = r2();
159                         buf[k] = j53(a,b);
160                         ph = 1 - ph;
161                 }
162                 w0(0); w2(4);
163                 break;
164
165         case 2: w0(0x89); w2(1); w2(0x23); w2(0x21); 
166                 ph = 1;
167                 for (k=0;k<count;k++) {
168                         w2(0x24+ph);
169                         buf[k] = r0();
170                         ph = 1 - ph;
171                 }
172                 w2(6); w2(4);
173                 break;
174
175         case 3: if (count > 512) WR(0x84,3);
176                 w3(0); w2(0x24);
177                 for (k=0;k<count;k++) buf[k] = r4();
178                 w2(4); WR(0x84,0);
179                 break;
180
181         case 4: if (count > 512) WR(0x84,3);
182                 w3(0); w2(0x24);
183                 for (k=0;k<count/2;k++) ((u16 *)buf)[k] = r4w();
184                 w2(4); WR(0x84,0);
185                 break;
186
187         case 5: if (count > 512) WR(0x84,3);
188                 w3(0); w2(0x24);
189                 for (k=0;k<count/4;k++) ((u32 *)buf)[k] = r4l();
190                 w2(4); WR(0x84,0);
191                 break;
192
193         }
194 }
195
196 static void epia_write_block( PIA *pi, char * buf, int count )
197
198 {       int     ph, k, last, d;
199
200         switch (pi->mode) {
201
202         case 0:
203         case 1:
204         case 2: w0(0xa1); w2(1); w2(3); w2(1); w2(5);
205                 ph = 0;  last = 0x8000;
206                 for (k=0;k<count;k++) {
207                         d = buf[k];
208                         if (d != last) { last = d; w0(d); }
209                         w2(4+ph);
210                         ph = 1 - ph;
211                 }
212                 w2(7); w2(4);
213                 break;
214
215         case 3: if (count < 512) WR(0x84,1);
216                 w3(0x40);
217                 for (k=0;k<count;k++) w4(buf[k]);
218                 if (count < 512) WR(0x84,0);
219                 break;
220
221         case 4: if (count < 512) WR(0x84,1);
222                 w3(0x40);
223                 for (k=0;k<count/2;k++) w4w(((u16 *)buf)[k]);
224                 if (count < 512) WR(0x84,0);
225                 break;
226
227         case 5: if (count < 512) WR(0x84,1);
228                 w3(0x40);
229                 for (k=0;k<count/4;k++) w4l(((u32 *)buf)[k]);
230                 if (count < 512) WR(0x84,0);
231                 break;
232
233         }
234
235 }
236
237 static int epia_test_proto( PIA *pi, char * scratch, int verbose )
238
239 {       int     j, k, f;
240         int     e[2] = {0,0};
241
242         epia_connect(pi);
243         for (j=0;j<2;j++) {
244             WR(6,0xa0+j*0x10);
245             for (k=0;k<256;k++) {
246                 WR(2,k^0xaa);
247                 WR(3,k^0x55);
248                 if (RR(2) != (k^0xaa)) e[j]++;
249                 }
250             WR(2,1); WR(3,1);
251             }
252         epia_disconnect(pi);
253
254         f = 0;
255         epia_connect(pi);
256         WR(0x84,8);
257         epia_read_block(pi,scratch,512);
258         for (k=0;k<256;k++) {
259             if ((scratch[2*k] & 0xff) != ((k+1) & 0xff)) f++;
260             if ((scratch[2*k+1] & 0xff) != ((-2-k) & 0xff)) f++;
261         }
262         WR(0x84,0);
263         epia_disconnect(pi);
264
265         if (verbose)  {
266             printk("%s: epia: port 0x%x, mode %d, test=(%d,%d,%d)\n",
267                    pi->device,pi->port,pi->mode,e[0],e[1],f);
268         }
269         
270         return (e[0] && e[1]) || f;
271
272 }
273
274
275 static void epia_log_adapter( PIA *pi, char * scratch, int verbose )
276
277 {       char    *mode_string[6] = {"4-bit","5/3","8-bit",
278                                    "EPP-8","EPP-16","EPP-32"};
279
280         printk("%s: epia %s, Shuttle EPIA at 0x%x, ",
281                 pi->device,EPIA_VERSION,pi->port);
282         printk("mode %d (%s), delay %d\n",pi->mode,
283                 mode_string[pi->mode],pi->delay);
284
285 }
286
287 static struct pi_protocol epia = {
288         .owner          = THIS_MODULE,
289         .name           = "epia",
290         .max_mode       = 6,
291         .epp_first      = 3,
292         .default_delay  = 1,
293         .max_units      = 1,
294         .write_regr     = epia_write_regr,
295         .read_regr      = epia_read_regr,
296         .write_block    = epia_write_block,
297         .read_block     = epia_read_block,
298         .connect        = epia_connect,
299         .disconnect     = epia_disconnect,
300         .test_proto     = epia_test_proto,
301         .log_adapter    = epia_log_adapter,
302 };
303
304 static int __init epia_init(void)
305 {
306         return paride_register(&epia);
307 }
308
309 static void __exit epia_exit(void)
310 {
311         paride_unregister(&epia);
312 }
313
314 MODULE_LICENSE("GPL");
315 module_init(epia_init)
316 module_exit(epia_exit)