drivers/ata/pata_parport/dstr.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * (c) 1997-1998  Grant R. Guenther <[email protected]>
   4  *
   5  * dstr.c is a low-level protocol driver for the DataStor EP2000 parallel
   6  * to IDE adapter chip.
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/delay.h>
  12 #include <linux/kernel.h>
  13 #include <linux/types.h>
  14 #include <linux/wait.h>
  15 #include <asm/io.h>
  16 #include "pata_parport.h"
  17
  18 /*
  19  * mode codes:  0  nybble reads, 8-bit writes
  20  *              1  8-bit reads and writes
  21  *              2  8-bit EPP mode
  22  *              3  EPP-16
  23  *              4  EPP-32
  24  */
  25
  26 #define j44(a, b)  (((a >> 3) & 0x07) | ((~a >> 4) & 0x08) | \
  27                     ((b << 1) & 0x70) | ((~b) & 0x80))
  28
  29 #define P1      w2(5);w2(0xd);w2(5);w2(4);
  30 #define P2      w2(5);w2(7);w2(5);w2(4);
  31 #define P3      w2(6);w2(4);w2(6);w2(4);
  32
  33 /*
  34  * cont = 0 - access the IDE register file
  35  * cont = 1 - access the IDE command set
  36  */
  37 static int  cont_map[2] = { 0x20, 0x40 };
  38
  39 static int dstr_read_regr(struct pi_adapter *pi, int cont, int regr)
  40 {
  41         int a, b, r;
  42
  43         r = regr + cont_map[cont];
  44
  45         w0(0x81); P1;
  46         if (pi->mode)
  47                 w0(0x11);
  48         else
  49                 w0(1);
  50         P2; w0(r); P1;
  51
  52         switch (pi->mode) {
  53         case 0:
  54                 w2(6); a = r1(); w2(4); w2(6); b = r1(); w2(4);
  55                 return j44(a, b);
  56         case 1:
  57                 w0(0); w2(0x26); a = r0(); w2(4);
  58                 return a;
  59         case 2:
  60         case 3:
  61         case 4:
  62                 w2(0x24); a = r4(); w2(4);
  63                 return a;
  64         }
  65
  66         return -1;
  67 }
  68
  69 static void dstr_write_regr(struct pi_adapter *pi, int cont, int regr, int val)
  70 {
  71         int  r = regr + cont_map[cont];
  72
  73         w0(0x81); P1;
  74         if (pi->mode >= 2)
  75                 w0(0x11);
  76         else
  77                 w0(1);
  78         P2; w0(r); P1;
  79
  80         switch (pi->mode)  {
  81         case 0:
  82         case 1:
  83                 w0(val); w2(5); w2(7); w2(5); w2(4);
  84                 break;
  85         case 2:
  86         case 3:
  87         case 4:
  88                 w4(val);
  89                 break;
  90         }
  91 }
  92
  93 #define  CCP(x)                                         \
  94         do {                                            \
  95                 w0(0xff); w2(0xc); w2(4);               \
  96                 w0(0xaa); w0(0x55); w0(0); w0(0xff);    \
  97                 w0(0x87); w0(0x78);                     \
  98                 w0(x); w2(5); w2(4);                    \
  99         } while (0)
 100
 101 static void dstr_connect(struct pi_adapter *pi)
 102 {
 103         pi->saved_r0 = r0();
 104         pi->saved_r2 = r2();
 105         w2(4); CCP(0xe0); w0(0xff);
 106 }
 107
 108 static void dstr_disconnect(struct pi_adapter *pi)
 109 {
 110         CCP(0x30);
 111         w0(pi->saved_r0);
 112         w2(pi->saved_r2);
 113 }
 114
 115 static void dstr_read_block(struct pi_adapter *pi, char *buf, int count)
 116 {
 117         int k, a, b;
 118
 119         w0(0x81); P1;
 120         if (pi->mode)
 121                 w0(0x19);
 122         else
 123                 w0(9);
 124         P2; w0(0x82); P1; P3; w0(0x20); P1;
 125
 126         switch (pi->mode) {
 127         case 0:
 128                 for (k = 0; k < count; k++) {
 129                         w2(6); a = r1(); w2(4);
 130                         w2(6); b = r1(); w2(4);
 131                         buf[k] = j44(a, b);
 132                 }
 133                 break;
 134         case 1:
 135                 w0(0);
 136                 for (k = 0; k < count; k++) {
 137                         w2(0x26);
 138                         buf[k] = r0();
 139                         w2(0x24);
 140                 }
 141                 w2(4);
 142                 break;
 143         case 2:
 144                 w2(0x24);
 145                 for (k = 0; k < count; k++)
 146                         buf[k] = r4();
 147                 w2(4);
 148                 break;
 149         case 3:
 150                 w2(0x24);
 151                 for (k = 0; k < count / 2; k++)
 152                         ((u16 *)buf)[k] = r4w();
 153                 w2(4);
 154                 break;
 155         case 4:
 156                 w2(0x24);
 157                 for (k = 0; k < count / 4; k++)
 158                         ((u32 *)buf)[k] = r4l();
 159                 w2(4);
 160                 break;
 161         }
 162 }
 163
 164 static void dstr_write_block(struct pi_adapter *pi, char *buf, int count)
 165 {
 166         int k;
 167
 168         w0(0x81); P1;
 169         if (pi->mode)
 170                 w0(0x19);
 171         else
 172                 w0(9);
 173         P2; w0(0x82); P1; P3; w0(0x20); P1;
 174
 175         switch (pi->mode) {
 176         case 0:
 177         case 1:
 178                 for (k = 0; k < count; k++) {
 179                         w2(5);
 180                         w0(buf[k]);
 181                         w2(7);
 182                 }
 183                 w2(5); w2(4);
 184                 break;
 185         case 2:
 186                 w2(0xc5);
 187                 for (k = 0; k < count; k++)
 188                         w4(buf[k]);
 189                 w2(0xc4);
 190                 break;
 191         case 3:
 192                 w2(0xc5);
 193                 for (k = 0; k < count / 2; k++)
 194                         w4w(((u16 *)buf)[k]);
 195                 w2(0xc4);
 196                 break;
 197         case 4:
 198                 w2(0xc5);
 199                 for (k = 0; k < count / 4; k++)
 200                         w4l(((u32 *)buf)[k]);
 201                 w2(0xc4);
 202                 break;
 203         }
 204 }
 205
 206 static void dstr_log_adapter(struct pi_adapter *pi)
 207
 208 {
 209         char *mode_string[5] = { "4-bit", "8-bit", "EPP-8", "EPP-16", "EPP-32" };
 210
 211         dev_info(&pi->dev,
 212                  "DataStor EP2000 at 0x%x, mode %d (%s), delay %d\n",
 213                  pi->port, pi->mode, mode_string[pi->mode], pi->delay);
 214 }
 215
 216 static struct pi_protocol dstr = {
 217         .owner          = THIS_MODULE,
 218         .name           = "dstr",
 219         .max_mode       = 5,
 220         .epp_first      = 2,
 221         .default_delay  = 1,
 222         .max_units      = 1,
 223         .write_regr     = dstr_write_regr,
 224         .read_regr      = dstr_read_regr,
 225         .write_block    = dstr_write_block,
 226         .read_block     = dstr_read_block,
 227         .connect        = dstr_connect,
 228         .disconnect     = dstr_disconnect,
 229         .log_adapter    = dstr_log_adapter,
 230 };
 231
 232 MODULE_LICENSE("GPL");
 233 MODULE_AUTHOR("Grant R. Guenther <[email protected]>");
 234 MODULE_DESCRIPTION("DataStor EP2000 parallel port IDE adapter protocol driver");
 235 module_pata_parport_driver(dstr);