drivers/ata/pata_parport/kbic.c

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