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