1/* 2 bpck.c (c) 1996-8 Grant R. Guenther <grant@torque.net> 3 Under the terms of the GNU General Public License. 4 5 bpck.c is a low-level protocol driver for the MicroSolutions 6 "backpack" parallel port IDE adapter. 7 8*/ 9 10/* Changes: 11 12 1.01 GRG 1998.05.05 init_proto, release_proto, pi->delay 13 1.02 GRG 1998.08.15 default pi->delay returned to 4 14 15*/ 16 17#define BPCK_VERSION "1.02" 18 19#include <linux/module.h> 20#include <linux/delay.h> 21#include <linux/kernel.h> 22#include <linux/types.h> 23#include <linux/wait.h> 24#include <asm/io.h> 25 26#include "paride.h" 27 28#undef r2 29#undef w2 30 31#define PC pi->private 32#define r2() (PC=(in_p(2) & 0xff)) 33#define w2(byte) {out_p(2,byte); PC = byte;} 34#define t2(pat) {PC ^= pat; out_p(2,PC);} 35#define e2() {PC &= 0xfe; out_p(2,PC);} 36#define o2() {PC |= 1; out_p(2,PC);} 37 38#define j44(l,h) (((l>>3)&0x7)|((l>>4)&0x8)|((h<<1)&0x70)|(h&0x80)) 39 40/* cont = 0 - access the IDE register file 41 cont = 1 - access the IDE command set 42 cont = 2 - use internal bpck register addressing 43*/ 44 45static int cont_map[3] = { 0x40, 0x48, 0 }; 46 47static int bpck_read_regr( PIA *pi, int cont, int regr ) 48 49{ int r, l, h; 50 51 r = regr + cont_map[cont]; 52 53 switch (pi->mode) { 54 55 case 0: w0(r & 0xf); w0(r); t2(2); t2(4); 56 l = r1(); 57 t2(4); 58 h = r1(); 59 return j44(l,h); 60 61 case 1: w0(r & 0xf); w0(r); t2(2); 62 e2(); t2(0x20); 63 t2(4); h = r0(); 64 t2(1); t2(0x20); 65 return h; 66 67 case 2: 68 case 3: 69 case 4: w0(r); w2(9); w2(0); w2(0x20); 70 h = r4(); 71 w2(0); 72 return h; 73 74 } 75 return -1; 76} 77 78static void bpck_write_regr( PIA *pi, int cont, int regr, int val ) 79 80{ int r; 81 82 r = regr + cont_map[cont]; 83 84 switch (pi->mode) { 85 86 case 0: 87 case 1: w0(r); 88 t2(2); 89 w0(val); 90 o2(); t2(4); t2(1); 91 break; 92 93 case 2: 94 case 3: 95 case 4: w0(r); w2(9); w2(0); 96 w0(val); w2(1); w2(3); w2(0); 97 break; 98 99 } 100} 101 102/* These macros access the bpck registers in native addressing */ 103 104#define WR(r,v) bpck_write_regr(pi,2,r,v) 105#define RR(r) (bpck_read_regr(pi,2,r)) 106 107static void bpck_write_block( PIA *pi, char * buf, int count ) 108 109{ int i; 110 111 switch (pi->mode) { 112 113 case 0: WR(4,0x40); 114 w0(0x40); t2(2); t2(1); 115 for (i=0;i<count;i++) { w0(buf[i]); t2(4); } 116 WR(4,0); 117 break; 118 119 case 1: WR(4,0x50); 120 w0(0x40); t2(2); t2(1); 121 for (i=0;i<count;i++) { w0(buf[i]); t2(4); } 122 WR(4,0x10); 123 break; 124 125 case 2: WR(4,0x48); 126 w0(0x40); w2(9); w2(0); w2(1); 127 for (i=0;i<count;i++) w4(buf[i]); 128 w2(0); 129 WR(4,8); 130 break; 131 132 case 3: WR(4,0x48); 133 w0(0x40); w2(9); w2(0); w2(1); 134 for (i=0;i<count/2;i++) w4w(((u16 *)buf)[i]); 135 w2(0); 136 WR(4,8); 137 break; 138 139 case 4: WR(4,0x48); 140 w0(0x40); w2(9); w2(0); w2(1); 141 for (i=0;i<count/4;i++) w4l(((u32 *)buf)[i]); 142 w2(0); 143 WR(4,8); 144 break; 145 } 146} 147 148static void bpck_read_block( PIA *pi, char * buf, int count ) 149 150{ int i, l, h; 151 152 switch (pi->mode) { 153 154 case 0: WR(4,0x40); 155 w0(0x40); t2(2); 156 for (i=0;i<count;i++) { 157 t2(4); l = r1(); 158 t2(4); h = r1(); 159 buf[i] = j44(l,h); 160 } 161 WR(4,0); 162 break; 163 164 case 1: WR(4,0x50); 165 w0(0x40); t2(2); t2(0x20); 166 for(i=0;i<count;i++) { t2(4); buf[i] = r0(); } 167 t2(1); t2(0x20); 168 WR(4,0x10); 169 break; 170 171 case 2: WR(4,0x48); 172 w0(0x40); w2(9); w2(0); w2(0x20); 173 for (i=0;i<count;i++) buf[i] = r4(); 174 w2(0); 175 WR(4,8); 176 break; 177 178 case 3: WR(4,0x48); 179 w0(0x40); w2(9); w2(0); w2(0x20); 180 for (i=0;i<count/2;i++) ((u16 *)buf)[i] = r4w(); 181 w2(0); 182 WR(4,8); 183 break; 184 185 case 4: WR(4,0x48); 186 w0(0x40); w2(9); w2(0); w2(0x20); 187 for (i=0;i<count/4;i++) ((u32 *)buf)[i] = r4l(); 188 w2(0); 189 WR(4,8); 190 break; 191 192 } 193} 194 195static int bpck_probe_unit ( PIA *pi ) 196 197{ int o1, o0, f7, id; 198 int t, s; 199 200 id = pi->unit; 201 s = 0; 202 w2(4); w2(0xe); r2(); t2(2); 203 o1 = r1()&0xf8; 204 o0 = r0(); 205 w0(255-id); w2(4); w0(id); 206 t2(8); t2(8); t2(8); 207 t2(2); t = r1()&0xf8; 208 f7 = ((id % 8) == 7); 209 if ((f7) || (t != o1)) { t2(2); s = r1()&0xf8; } 210 if ((t == o1) && ((!f7) || (s == o1))) { 211 w2(0x4c); w0(o0); 212 return 0; 213 } 214 t2(8); w0(0); t2(2); w2(0x4c); w0(o0); 215 return 1; 216} 217 218static void bpck_connect ( PIA *pi ) 219 220{ pi->saved_r0 = r0(); 221 w0(0xff-pi->unit); w2(4); w0(pi->unit); 222 t2(8); t2(8); t2(8); 223 t2(2); t2(2); 224 225 switch (pi->mode) { 226 227 case 0: t2(8); WR(4,0); 228 break; 229 230 case 1: t2(8); WR(4,0x10); 231 break; 232 233 case 2: 234 case 3: 235 case 4: w2(0); WR(4,8); 236 break; 237 238 } 239 240 WR(5,8); 241 242 if (pi->devtype == PI_PCD) { 243 WR(0x46,0x10); /* fiddle with ESS logic ??? */ 244 WR(0x4c,0x38); 245 WR(0x4d,0x88); 246 WR(0x46,0xa0); 247 WR(0x41,0); 248 WR(0x4e,8); 249 } 250} 251 252static void bpck_disconnect ( PIA *pi ) 253 254{ w0(0); 255 if (pi->mode >= 2) { w2(9); w2(0); } else t2(2); 256 w2(0x4c); w0(pi->saved_r0); 257} 258 259static void bpck_force_spp ( PIA *pi ) 260 261/* This fakes the EPP protocol to turn off EPP ... */ 262 263{ pi->saved_r0 = r0(); 264 w0(0xff-pi->unit); w2(4); w0(pi->unit); 265 t2(8); t2(8); t2(8); 266 t2(2); t2(2); 267 268 w2(0); 269 w0(4); w2(9); w2(0); 270 w0(0); w2(1); w2(3); w2(0); 271 w0(0); w2(9); w2(0); 272 w2(0x4c); w0(pi->saved_r0); 273} 274 275#define TEST_LEN 16 276 277static int bpck_test_proto( PIA *pi, char * scratch, int verbose ) 278 279{ int i, e, l, h, om; 280 char buf[TEST_LEN]; 281 282 bpck_force_spp(pi); 283 284 switch (pi->mode) { 285 286 case 0: bpck_connect(pi); 287 WR(0x13,0x7f); 288 w0(0x13); t2(2); 289 for(i=0;i<TEST_LEN;i++) { 290 t2(4); l = r1(); 291 t2(4); h = r1(); 292 buf[i] = j44(l,h); 293 } 294 bpck_disconnect(pi); 295 break; 296 297 case 1: bpck_connect(pi); 298 WR(0x13,0x7f); 299 w0(0x13); t2(2); t2(0x20); 300 for(i=0;i<TEST_LEN;i++) { t2(4); buf[i] = r0(); } 301 t2(1); t2(0x20); 302 bpck_disconnect(pi); 303 break; 304 305 case 2: 306 case 3: 307 case 4: om = pi->mode; 308 pi->mode = 0; 309 bpck_connect(pi); 310 WR(7,3); 311 WR(4,8); 312 bpck_disconnect(pi); 313 314 pi->mode = om; 315 bpck_connect(pi); 316 w0(0x13); w2(9); w2(1); w0(0); w2(3); w2(0); w2(0xe0); 317 318 switch (pi->mode) { 319 case 2: for (i=0;i<TEST_LEN;i++) buf[i] = r4(); 320 break; 321 case 3: for (i=0;i<TEST_LEN/2;i++) ((u16 *)buf)[i] = r4w(); 322 break; 323 case 4: for (i=0;i<TEST_LEN/4;i++) ((u32 *)buf)[i] = r4l(); 324 break; 325 } 326 327 w2(0); 328 WR(7,0); 329 bpck_disconnect(pi); 330 331 break; 332 333 } 334 335 if (verbose) { 336 printk("%s: bpck: 0x%x unit %d mode %d: ", 337 pi->device,pi->port,pi->unit,pi->mode); 338 for (i=0;i<TEST_LEN;i++) printk("%3d",buf[i]); 339 printk("\n"); 340 } 341 342 e = 0; 343 for (i=0;i<TEST_LEN;i++) if (buf[i] != (i+1)) e++; 344 return e; 345} 346 347static void bpck_read_eeprom ( PIA *pi, char * buf ) 348 349{ int i,j,k,n,p,v,f, om, od; 350 351 bpck_force_spp(pi); 352 353 om = pi->mode; od = pi->delay; 354 pi->mode = 0; pi->delay = 6; 355 356 bpck_connect(pi); 357 358 n = 0; 359 WR(4,0); 360 for (i=0;i<64;i++) { 361 WR(6,8); 362 WR(6,0xc); 363 p = 0x100; 364 for (k=0;k<9;k++) { 365 f = (((i + 0x180) & p) != 0) * 2; 366 WR(6,f+0xc); 367 WR(6,f+0xd); 368 WR(6,f+0xc); 369 p = (p >> 1); 370 } 371 for (j=0;j<2;j++) { 372 v = 0; 373 for (k=0;k<8;k++) { 374 WR(6,0xc); 375 WR(6,0xd); 376 WR(6,0xc); 377 f = RR(0); 378 v = 2*v + (f == 0x84); 379 } 380 buf[2*i+1-j] = v; 381 } 382 } 383 WR(6,8); 384 WR(6,0); 385 WR(5,8); 386 387 bpck_disconnect(pi); 388 389 if (om >= 2) { 390 bpck_connect(pi); 391 WR(7,3); 392 WR(4,8); 393 bpck_disconnect(pi); 394 } 395 396 pi->mode = om; pi->delay = od; 397} 398 399static int bpck_test_port ( PIA *pi ) /* check for 8-bit port */ 400 401{ int i, r, m; 402 403 w2(0x2c); i = r0(); w0(255-i); r = r0(); w0(i); 404 m = -1; 405 if (r == i) m = 2; 406 if (r == (255-i)) m = 0; 407 408 w2(0xc); i = r0(); w0(255-i); r = r0(); w0(i); 409 if (r != (255-i)) m = -1; 410 411 if (m == 0) { w2(6); w2(0xc); r = r0(); w0(0xaa); w0(r); w0(0xaa); } 412 if (m == 2) { w2(0x26); w2(0xc); } 413 414 if (m == -1) return 0; 415 return 5; 416} 417 418static void bpck_log_adapter( PIA *pi, char * scratch, int verbose ) 419 420{ char *mode_string[5] = { "4-bit","8-bit","EPP-8", 421 "EPP-16","EPP-32" }; 422 423#ifdef DUMP_EEPROM 424 int i; 425#endif 426 427 bpck_read_eeprom(pi,scratch); 428 429#ifdef DUMP_EEPROM 430 if (verbose) { 431 for(i=0;i<128;i++) 432 if ((scratch[i] < ' ') || (scratch[i] > '~')) 433 scratch[i] = '.'; 434 printk("%s: bpck EEPROM: %64.64s\n",pi->device,scratch); 435 printk("%s: %64.64s\n",pi->device,&scratch[64]); 436 } 437#endif 438 439 printk("%s: bpck %s, backpack %8.8s unit %d", 440 pi->device,BPCK_VERSION,&scratch[110],pi->unit); 441 printk(" at 0x%x, mode %d (%s), delay %d\n",pi->port, 442 pi->mode,mode_string[pi->mode],pi->delay); 443} 444 445static void bpck_init_proto( PIA *pi) 446 447{ MOD_INC_USE_COUNT; 448} 449 450static void bpck_release_proto( PIA *pi) 451 452{ MOD_DEC_USE_COUNT; 453} 454 455struct pi_protocol bpck = { "bpck",0,5,2,4,256, 456 bpck_write_regr, 457 bpck_read_regr, 458 bpck_write_block, 459 bpck_read_block, 460 bpck_connect, 461 bpck_disconnect, 462 bpck_test_port, 463 bpck_probe_unit, 464 bpck_test_proto, 465 bpck_log_adapter, 466 bpck_init_proto, 467 bpck_release_proto 468 }; 469 470#ifdef MODULE 471 472int init_module(void) 473 474{ return pi_register(&bpck) - 1; 475} 476 477void cleanup_module(void) 478 479{ pi_unregister(&bpck); 480} 481 482#endif 483 484/* end of bpck.c */ 485MODULE_LICENSE("GPL"); 486