block/paride/kbic.c

0001 /*
0002         kbic.c    (c) 1997-8  Grant R. Guenther <grant@torque.net>
0003                               Under the terms of the GNU General Public License.
0004
0005         This is a low-level driver for the KBIC-951A and KBIC-971A
0006         parallel to IDE adapter chips from KingByte Information Systems.
0007
0008     The chips are almost identical, however, the wakeup code
0009     required for the 971A interferes with the correct operation of
0010         the 951A, so this driver registers itself twice, once for
0011     each chip.
0012
0013 */
0014
0015 /* Changes:
0016
0017         1.01    GRG 1998.05.06 init_proto, release_proto
0018
0019 */
0020
0021 #define KBIC_VERSION      "1.01"
0022
0023 #include <linux/module.h>
0024 #include <linux/init.h>
0025 #include <linux/delay.h>
0026 #include <linux/kernel.h>
0027 #include <linux/types.h>
0028 #include <linux/wait.h>
0029 #include <asm/io.h>
0030
0031 #include "paride.h"
0032
0033 #define r12w()          (delay_p,inw(pi->port+1)&0xffff)
0034
0035 #define j44(a,b)                ((((a>>4)&0x0f)|(b&0xf0))^0x88)
0036 #define j53(w)                  (((w>>3)&0x1f)|((w>>4)&0xe0))
0037
0038
0039 /* cont = 0 - access the IDE register file
0040    cont = 1 - access the IDE command set
0041 */
0042
0043 static int  cont_map[2] = { 0x80, 0x40 };
0044
0045 static int kbic_read_regr( PIA *pi, int cont, int regr )
0046
0047 {       int     a, b, s;
0048
0049         s = cont_map[cont];
0050
0051     switch (pi->mode) {
0052
0053     case 0: w0(regr|0x18|s); w2(4); w2(6); w2(4); w2(1); w0(8);
0054             a = r1(); w0(0x28); b = r1(); w2(4);
0055         return j44(a,b);
0056
0057     case 1: w0(regr|0x38|s); w2(4); w2(6); w2(4); w2(5); w0(8);
0058         a = r12w(); w2(4);
0059         return j53(a);
0060
0061     case 2: w0(regr|0x08|s); w2(4); w2(6); w2(4); w2(0xa5); w2(0xa1);
0062         a = r0(); w2(4);
0063             return a;
0064
0065     case 3:
0066     case 4:
0067     case 5: w0(0x20|s); w2(4); w2(6); w2(4); w3(regr);
0068         a = r4(); b = r4(); w2(4); w2(0); w2(4);
0069         return a;
0070
0071     }
0072     return -1;
0073 }
0074
0075 static void  kbic_write_regr( PIA *pi, int cont, int regr, int val)
0076
0077 {       int  s;
0078
0079         s = cont_map[cont];
0080
0081         switch (pi->mode) {
0082
0083     case 0:
0084         case 1:
0085     case 2: w0(regr|0x10|s); w2(4); w2(6); w2(4);
0086         w0(val); w2(5); w2(4);
0087         break;
0088
0089     case 3:
0090     case 4:
0091     case 5: w0(0x20|s); w2(4); w2(6); w2(4); w3(regr);
0092         w4(val); w4(val);
0093         w2(4); w2(0); w2(4);
0094                 break;
0095
0096     }
0097 }
0098
0099 static void k951_connect ( PIA *pi  )
0100
0101 {   pi->saved_r0 = r0();
0102         pi->saved_r2 = r2();
0103         w2(4);
0104 }
0105
0106 static void k951_disconnect ( PIA *pi )
0107
0108 {       w0(pi->saved_r0);
0109         w2(pi->saved_r2);
0110 }
0111
0112 #define CCP(x)  w2(0xc4);w0(0xaa);w0(0x55);w0(0);w0(0xff);w0(0x87);\
0113         w0(0x78);w0(x);w2(0xc5);w2(0xc4);w0(0xff);
0114
0115 static void k971_connect ( PIA *pi  )
0116
0117 {   pi->saved_r0 = r0();
0118         pi->saved_r2 = r2();
0119     CCP(0x20);
0120         w2(4);
0121 }
0122
0123 static void k971_disconnect ( PIA *pi )
0124
0125 {       CCP(0x30);
0126     w0(pi->saved_r0);
0127         w2(pi->saved_r2);
0128 }
0129
0130 /* counts must be congruent to 0 MOD 4, but all known applications
0131    have this property.
0132 */
0133
0134 static void kbic_read_block( PIA *pi, char * buf, int count )
0135
0136 {       int     k, a, b;
0137
0138         switch (pi->mode) {
0139
0140         case 0: w0(0x98); w2(4); w2(6); w2(4);
0141                 for (k=0;k<count/2;k++) {
0142             w2(1); w0(8);    a = r1();
0143                    w0(0x28); b = r1();
0144             buf[2*k]   = j44(a,b);
0145             w2(5);           b = r1();
0146                    w0(8);    a = r1();
0147             buf[2*k+1] = j44(a,b);
0148             w2(4);
0149                 }
0150                 break;
0151
0152         case 1: w0(0xb8); w2(4); w2(6); w2(4);
0153                 for (k=0;k<count/4;k++) {
0154                         w0(0xb8);
0155             w2(4); w2(5);
0156                         w0(8);    buf[4*k]   = j53(r12w());
0157             w0(0xb8); buf[4*k+1] = j53(r12w());
0158             w2(4); w2(5);
0159                       buf[4*k+3] = j53(r12w());
0160             w0(8);    buf[4*k+2] = j53(r12w());
0161                 }
0162                 w2(4);
0163                 break;
0164
0165         case 2: w0(0x88); w2(4); w2(6); w2(4);
0166                 for (k=0;k<count/2;k++) {
0167                         w2(0xa0); w2(0xa1); buf[2*k] = r0();
0168                         w2(0xa5); buf[2*k+1] = r0();
0169                 }
0170                 w2(4);
0171                 break;
0172
0173         case 3: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
0174                 for (k=0;k<count;k++) buf[k] = r4();
0175                 w2(4); w2(0); w2(4);
0176                 break;
0177
0178     case 4: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
0179                 for (k=0;k<count/2;k++) ((u16 *)buf)[k] = r4w();
0180                 w2(4); w2(0); w2(4);
0181                 break;
0182
0183         case 5: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
0184                 for (k=0;k<count/4;k++) ((u32 *)buf)[k] = r4l();
0185                 w2(4); w2(0); w2(4);
0186                 break;
0187
0188
0189         }
0190 }
0191
0192 static void kbic_write_block( PIA *pi, char * buf, int count )
0193
0194 {       int     k;
0195
0196         switch (pi->mode) {
0197
0198         case 0:
0199         case 1:
0200         case 2: w0(0x90); w2(4); w2(6); w2(4);
0201         for(k=0;k<count/2;k++) {
0202             w0(buf[2*k+1]); w2(0); w2(4);
0203             w0(buf[2*k]);   w2(5); w2(4);
0204         }
0205         break;
0206
0207         case 3: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
0208         for(k=0;k<count/2;k++) {
0209             w4(buf[2*k+1]);
0210                         w4(buf[2*k]);
0211                 }
0212         w2(4); w2(0); w2(4);
0213         break;
0214
0215     case 4: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
0216                 for(k=0;k<count/2;k++) w4w(pi_swab16(buf,k));
0217                 w2(4); w2(0); w2(4);
0218                 break;
0219
0220         case 5: w0(0xa0); w2(4); w2(6); w2(4); w3(0);
0221                 for(k=0;k<count/4;k++) w4l(pi_swab32(buf,k));
0222                 w2(4); w2(0); w2(4);
0223                 break;
0224
0225         }
0226
0227 }
0228
0229 static void kbic_log_adapter( PIA *pi, char * scratch,
0230                   int verbose, char * chip )
0231
0232 {       char    *mode_string[6] = {"4-bit","5/3","8-bit",
0233                    "EPP-8","EPP_16","EPP-32"};
0234
0235         printk("%s: kbic %s, KingByte %s at 0x%x, ",
0236                 pi->device,KBIC_VERSION,chip,pi->port);
0237         printk("mode %d (%s), delay %d\n",pi->mode,
0238         mode_string[pi->mode],pi->delay);
0239
0240 }
0241
0242 static void k951_log_adapter( PIA *pi, char * scratch, int verbose )
0243
0244 {   kbic_log_adapter(pi,scratch,verbose,"KBIC-951A");
0245 }
0246
0247 static void k971_log_adapter( PIA *pi, char * scratch, int verbose )
0248
0249 {       kbic_log_adapter(pi,scratch,verbose,"KBIC-971A");
0250 }
0251
0252 static struct pi_protocol k951 = {
0253     .owner      = THIS_MODULE,
0254     .name       = "k951",
0255     .max_mode   = 6,
0256     .epp_first  = 3,
0257     .default_delay  = 1,
0258     .max_units  = 1,
0259     .write_regr = kbic_write_regr,
0260     .read_regr  = kbic_read_regr,
0261     .write_block    = kbic_write_block,
0262     .read_block = kbic_read_block,
0263     .connect    = k951_connect,
0264     .disconnect = k951_disconnect,
0265     .log_adapter    = k951_log_adapter,
0266 };
0267
0268 static struct pi_protocol k971 = {
0269     .owner      = THIS_MODULE,
0270     .name       = "k971",
0271     .max_mode   = 6,
0272     .epp_first  = 3,
0273     .default_delay  = 1,
0274     .max_units  = 1,
0275     .write_regr = kbic_write_regr,
0276     .read_regr  = kbic_read_regr,
0277     .write_block    = kbic_write_block,
0278     .read_block = kbic_read_block,
0279     .connect    = k971_connect,
0280     .disconnect = k971_disconnect,
0281     .log_adapter    = k971_log_adapter,
0282 };
0283
0284 static int __init kbic_init(void)
0285 {
0286     int rv;
0287
0288     rv = paride_register(&k951);
0289     if (rv < 0)
0290         return rv;
0291     rv = paride_register(&k971);
0292     if (rv < 0)
0293         paride_unregister(&k951);
0294     return rv;
0295 }
0296
0297 static void __exit kbic_exit(void)
0298 {
0299     paride_unregister(&k951);
0300     paride_unregister(&k971);
0301 }
0302
0303 MODULE_LICENSE("GPL");
0304 module_init(kbic_init)
0305 module_exit(kbic_exit)