release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/block/paride/epat.c

   1 /*
   2         epat.c  (c) 1997-8  Grant R. Guenther <grant@torque.net>
   3                             Under the terms of the GNU General Public License.
   4
   5         This is the low level protocol driver for the EPAT parallel
   6         to IDE adapter from Shuttle Technologies.  This adapter is
   7         used in many popular parallel port disk products such as the
   8         SyQuest EZ drives, the Avatar Shark and the Imation SuperDisk.
   9
  10 */
  11
  12 /* Changes:
  13
  14         1.01    GRG 1998.05.06 init_proto, release_proto
  15         1.02    Joshua b. Jore CPP(renamed), epat_connect, epat_disconnect
  16
  17 */
  18
  19 #define EPAT_VERSION      "1.02"
  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 "paride.h"
  30
  31 #define j44(a,b)                (((a>>4)&0x0f)+(b&0xf0))
  32 #define j53(a,b)                (((a>>3)&0x1f)+((b<<4)&0xe0))
  33
  34 static int epatc8;
  35
  36 module_param(epatc8, int, 0);
  37 MODULE_PARM_DESC(epatc8, "support for the Shuttle EP1284 chip, "
  38         "used in any recent Imation SuperDisk (LS-120) drive.");
  39
  40 /* cont =  0   IDE register file
  41    cont =  1   IDE control registers
  42    cont =  2   internal EPAT registers
  43 */
  44
  45 static int cont_map[3] = { 0x18, 0x10, 0 };
  46
  47 static void epat_write_regr( PIA *pi, int cont, int regr, int val)
  48
  49 {       int r;
  50
  51         r = regr + cont_map[cont];
  52
  53         switch (pi->mode) {
  54
  55         case 0:
  56         case 1:
  57         case 2: w0(0x60+r); w2(1); w0(val); w2(4);
  58                 break;
  59
  60         case 3:
  61         case 4:
  62         case 5: w3(0x40+r); w4(val);
  63                 break;
  64
  65         }
  66 }
  67
  68 static int epat_read_regr( PIA *pi, int cont, int regr )
  69
  70 {       int  a, b, r;
  71
  72         r = regr + cont_map[cont];
  73
  74         switch (pi->mode) {
  75
  76         case 0: w0(r); w2(1); w2(3);
  77                 a = r1(); w2(4); b = r1();
  78                 return j44(a,b);
  79
  80         case 1: w0(0x40+r); w2(1); w2(4);
  81                 a = r1(); b = r2(); w0(0xff);
  82                 return j53(a,b);
  83
  84         case 2: w0(0x20+r); w2(1); w2(0x25);
  85                 a = r0(); w2(4);
  86                 return a;
  87
  88         case 3:
  89         case 4:
  90         case 5: w3(r); w2(0x24); a = r4(); w2(4);
  91                 return a;
  92
  93         }
  94         return -1;      /* never gets here */
  95 }
  96
  97 static void epat_read_block( PIA *pi, char * buf, int count )
  98
  99 {       int  k, ph, a, b;
 100
 101         switch (pi->mode) {
 102
 103         case 0: w0(7); w2(1); w2(3); w0(0xff);
 104                 ph = 0;
 105                 for(k=0;k<count;k++) {
 106                         if (k == count-1) w0(0xfd);
 107                         w2(6+ph); a = r1();
 108                         if (a & 8) b = a;
 109                           else { w2(4+ph); b = r1(); }
 110                         buf[k] = j44(a,b);
 111                         ph =  1 - ph;
 112                 }
 113                 w0(0); w2(4);
 114                 break;
 115
 116         case 1: w0(0x47); w2(1); w2(5); w0(0xff);
 117                 ph = 0;
 118                 for(k=0;k<count;k++) {
 119                         if (k == count-1) w0(0xfd);
 120                         w2(4+ph);
 121                         a = r1(); b = r2();
 122                         buf[k] = j53(a,b);
 123                         ph = 1 - ph;
 124                 }
 125                 w0(0); w2(4);
 126                 break;
 127
 128         case 2: w0(0x27); w2(1); w2(0x25); w0(0);
 129                 ph = 0;
 130                 for(k=0;k<count-1;k++) {
 131                         w2(0x24+ph);
 132                         buf[k] = r0();
 133                         ph = 1 - ph;
 134                 }
 135                 w2(0x26); w2(0x27); buf[count-1] = r0();
 136                 w2(0x25); w2(4);
 137                 break;
 138
 139         case 3: w3(0x80); w2(0x24);
 140                 for(k=0;k<count-1;k++) buf[k] = r4();
 141                 w2(4); w3(0xa0); w2(0x24); buf[count-1] = r4();
 142                 w2(4);
 143                 break;
 144
 145         case 4: w3(0x80); w2(0x24);
 146                 for(k=0;k<(count/2)-1;k++) ((u16 *)buf)[k] = r4w();
 147                 buf[count-2] = r4();
 148                 w2(4); w3(0xa0); w2(0x24); buf[count-1] = r4();
 149                 w2(4);
 150                 break;
 151
 152         case 5: w3(0x80); w2(0x24);
 153                 for(k=0;k<(count/4)-1;k++) ((u32 *)buf)[k] = r4l();
 154                 for(k=count-4;k<count-1;k++) buf[k] = r4();
 155                 w2(4); w3(0xa0); w2(0x24); buf[count-1] = r4();
 156                 w2(4);
 157                 break;
 158
 159         }
 160 }
 161
 162 static void epat_write_block( PIA *pi, char * buf, int count )
 163
 164 {       int ph, k;
 165
 166         switch (pi->mode) {
 167
 168         case 0:
 169         case 1:
 170         case 2: w0(0x67); w2(1); w2(5);
 171                 ph = 0;
 172                 for(k=0;k<count;k++) {
 173                         w0(buf[k]);
 174                         w2(4+ph);
 175                         ph = 1 - ph;
 176                 }
 177                 w2(7); w2(4);
 178                 break;
 179
 180         case 3: w3(0xc0);
 181                 for(k=0;k<count;k++) w4(buf[k]);
 182                 w2(4);
 183                 break;
 184
 185         case 4: w3(0xc0);
 186                 for(k=0;k<(count/2);k++) w4w(((u16 *)buf)[k]);
 187                 w2(4);
 188                 break;
 189
 190         case 5: w3(0xc0);
 191                 for(k=0;k<(count/4);k++) w4l(((u32 *)buf)[k]);
 192                 w2(4);
 193                 break;
 194
 195         }
 196 }
 197
 198 /* these macros access the EPAT registers in native addressing */
 199
 200 #define WR(r,v)         epat_write_regr(pi,2,r,v)
 201 #define RR(r)           (epat_read_regr(pi,2,r))
 202
 203 /* and these access the IDE task file */
 204
 205 #define WRi(r,v)         epat_write_regr(pi,0,r,v)
 206 #define RRi(r)           (epat_read_regr(pi,0,r))
 207
 208
 209 #define CPP(x)  w2(4);w0(0x22);w0(0xaa);w0(0x55);w0(0);w0(0xff);\
 210                 w0(0x87);w0(0x78);w0(x);w2(4);w2(5);w2(4);w0(0xff);
 211
 212 static void epat_connect ( PIA *pi )
 213
 214 {       pi->saved_r0 = r0();
 215         pi->saved_r2 = r2();
 216
 217         /* Initialize the chip */
 218         CPP(0);
 219
 220         if (epatc8) {
 221                 CPP(0x40);CPP(0xe0);
 222                 w0(0);w2(1);w2(4);
 223                 WR(0x8,0x12);WR(0xc,0x14);WR(0x12,0x10);
 224                 WR(0xe,0xf);WR(0xf,4);
 225                 /* WR(0xe,0xa);WR(0xf,4); */
 226                 WR(0xe,0xd);WR(0xf,0);
 227                 /* CPP(0x30); */
 228         }
 229
 230         /* Connect to the chip */
 231         CPP(0xe0);
 232         w0(0);w2(1);w2(4); /* Idle into SPP */
 233         if (pi->mode >= 3) {
 234           w0(0);w2(1);w2(4);w2(0xc);
 235           /* Request EPP */
 236           w0(0x40);w2(6);w2(7);w2(4);w2(0xc);w2(4);
 237         }
 238
 239         if (!epatc8) {
 240                 WR(8,0x10); WR(0xc,0x14); WR(0xa,0x38); WR(0x12,0x10);
 241         }
 242 }
 243
 244 static void epat_disconnect (PIA *pi)
 245 {       CPP(0x30);
 246         w0(pi->saved_r0);
 247         w2(pi->saved_r2);
 248 }
 249
 250 static int epat_test_proto( PIA *pi, char * scratch, int verbose )
 251
 252 {       int     k, j, f, cc;
 253         int     e[2] = {0,0};
 254
 255         epat_connect(pi);
 256         cc = RR(0xd);
 257         epat_disconnect(pi);
 258
 259         epat_connect(pi);
 260         for (j=0;j<2;j++) {
 261             WRi(6,0xa0+j*0x10);
 262             for (k=0;k<256;k++) {
 263                 WRi(2,k^0xaa);
 264                 WRi(3,k^0x55);
 265                 if (RRi(2) != (k^0xaa)) e[j]++;
 266                 }
 267             }
 268         epat_disconnect(pi);
 269
 270         f = 0;
 271         epat_connect(pi);
 272         WR(0x13,1); WR(0x13,0); WR(0xa,0x11);
 273         epat_read_block(pi,scratch,512);
 274
 275         for (k=0;k<256;k++) {
 276             if ((scratch[2*k] & 0xff) != k) f++;
 277             if ((scratch[2*k+1] & 0xff) != (0xff-k)) f++;
 278         }
 279         epat_disconnect(pi);
 280
 281         if (verbose)  {
 282             printk("%s: epat: port 0x%x, mode %d, ccr %x, test=(%d,%d,%d)\n",
 283                    pi->device,pi->port,pi->mode,cc,e[0],e[1],f);
 284         }
 285
 286         return (e[0] && e[1]) || f;
 287 }
 288
 289 static void epat_log_adapter( PIA *pi, char * scratch, int verbose )
 290
 291 {       int     ver;
 292         char    *mode_string[6] =
 293                    {"4-bit","5/3","8-bit","EPP-8","EPP-16","EPP-32"};
 294
 295         epat_connect(pi);
 296         WR(0xa,0x38);           /* read the version code */
 297         ver = RR(0xb);
 298         epat_disconnect(pi);
 299
 300         printk("%s: epat %s, Shuttle EPAT chip %x at 0x%x, ",
 301                 pi->device,EPAT_VERSION,ver,pi->port);
 302         printk("mode %d (%s), delay %d\n",pi->mode,
 303                 mode_string[pi->mode],pi->delay);
 304
 305 }
 306
 307 static struct pi_protocol epat = {
 308         .owner          = THIS_MODULE,
 309         .name           = "epat",
 310         .max_mode       = 6,
 311         .epp_first      = 3,
 312         .default_delay  = 1,
 313         .max_units      = 1,
 314         .write_regr     = epat_write_regr,
 315         .read_regr      = epat_read_regr,
 316         .write_block    = epat_write_block,
 317         .read_block     = epat_read_block,
 318         .connect        = epat_connect,
 319         .disconnect     = epat_disconnect,
 320         .test_proto     = epat_test_proto,
 321         .log_adapter    = epat_log_adapter,
 322 };
 323
 324 static int __init epat_init(void)
 325 {
 326 #ifdef CONFIG_PARIDE_EPATC8
 327         epatc8 = 1;
 328 #endif
 329         return paride_register(&epat);
 330 }
 331
 332 static void __exit epat_exit(void)
 333 {
 334         paride_unregister(&epat);
 335 }
 336
 337 MODULE_LICENSE("GPL");
 338 module_init(epat_init)
 339 module_exit(epat_exit)