kernel/drivers/block/paride/paride.c

   1 /*
   2         paride.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 base module for the family of device drivers
   6         that support parallel port IDE devices.
   7
   8 */
   9
  10 /* Changes:
  11
  12         1.01    GRG 1998.05.03  Use spinlocks
  13         1.02    GRG 1998.05.05  init_proto, release_proto, ktti
  14         1.03    GRG 1998.08.15  eliminate compiler warning
  15         1.04    GRG 1998.11.28  added support for FRIQ
  16         1.05    TMW 2000.06.06  use parport_find_number instead of
  17                                 parport_enumerate
  18         1.06    TMW 2001.03.26  more sane parport-or-not resource management
  19 */
  20
  21 #define PI_VERSION      "1.06"
  22
  23 #include <linux/module.h>
  24 #include <linux/kmod.h>
  25 #include <linux/types.h>
  26 #include <linux/kernel.h>
  27 #include <linux/ioport.h>
  28 #include <linux/string.h>
  29 #include <linux/spinlock.h>
  30 #include <linux/wait.h>
  31 #include <linux/sched.h>        /* TASK_* */
  32 #include <linux/parport.h>
  33
  34 #include "paride.h"
  35
  36 MODULE_LICENSE("GPL");
  37
  38 #define MAX_PROTOS      32
  39
  40 static struct pi_protocol *protocols[MAX_PROTOS];
  41
  42 static DEFINE_SPINLOCK(pi_spinlock);
  43
  44 void pi_write_regr(PIA * pi, int cont, int regr, int val)
  45 {
  46         pi->proto->write_regr(pi, cont, regr, val);
  47 }
  48
  49 EXPORT_SYMBOL(pi_write_regr);
  50
  51 int pi_read_regr(PIA * pi, int cont, int regr)
  52 {
  53         return pi->proto->read_regr(pi, cont, regr);
  54 }
  55
  56 EXPORT_SYMBOL(pi_read_regr);
  57
  58 void pi_write_block(PIA * pi, char *buf, int count)
  59 {
  60         pi->proto->write_block(pi, buf, count);
  61 }
  62
  63 EXPORT_SYMBOL(pi_write_block);
  64
  65 void pi_read_block(PIA * pi, char *buf, int count)
  66 {
  67         pi->proto->read_block(pi, buf, count);
  68 }
  69
  70 EXPORT_SYMBOL(pi_read_block);
  71
  72 static void pi_wake_up(void *p)
  73 {
  74         PIA *pi = (PIA *) p;
  75         unsigned long flags;
  76         void (*cont) (void) = NULL;
  77
  78         spin_lock_irqsave(&pi_spinlock, flags);
  79
  80         if (pi->claim_cont && !parport_claim(pi->pardev)) {
  81                 cont = pi->claim_cont;
  82                 pi->claim_cont = NULL;
  83                 pi->claimed = 1;
  84         }
  85
  86         spin_unlock_irqrestore(&pi_spinlock, flags);
  87
  88         wake_up(&(pi->parq));
  89
  90         if (cont)
  91                 cont();
  92 }
  93
  94 int pi_schedule_claimed(PIA * pi, void (*cont) (void))
  95 {
  96         unsigned long flags;
  97
  98         spin_lock_irqsave(&pi_spinlock, flags);
  99         if (pi->pardev && parport_claim(pi->pardev)) {
 100                 pi->claim_cont = cont;
 101                 spin_unlock_irqrestore(&pi_spinlock, flags);
 102                 return 0;
 103         }
 104         pi->claimed = 1;
 105         spin_unlock_irqrestore(&pi_spinlock, flags);
 106         return 1;
 107 }
 108 EXPORT_SYMBOL(pi_schedule_claimed);
 109
 110 void pi_do_claimed(PIA * pi, void (*cont) (void))
 111 {
 112         if (pi_schedule_claimed(pi, cont))
 113                 cont();
 114 }
 115
 116 EXPORT_SYMBOL(pi_do_claimed);
 117
 118 static void pi_claim(PIA * pi)
 119 {
 120         if (pi->claimed)
 121                 return;
 122         pi->claimed = 1;
 123         if (pi->pardev)
 124                 wait_event(pi->parq,
 125                            !parport_claim((struct pardevice *) pi->pardev));
 126 }
 127
 128 static void pi_unclaim(PIA * pi)
 129 {
 130         pi->claimed = 0;
 131         if (pi->pardev)
 132                 parport_release((struct pardevice *) (pi->pardev));
 133 }
 134
 135 void pi_connect(PIA * pi)
 136 {
 137         pi_claim(pi);
 138         pi->proto->connect(pi);
 139 }
 140
 141 EXPORT_SYMBOL(pi_connect);
 142
 143 void pi_disconnect(PIA * pi)
 144 {
 145         pi->proto->disconnect(pi);
 146         pi_unclaim(pi);
 147 }
 148
 149 EXPORT_SYMBOL(pi_disconnect);
 150
 151 static void pi_unregister_parport(PIA * pi)
 152 {
 153         if (pi->pardev) {
 154                 parport_unregister_device((struct pardevice *) (pi->pardev));
 155                 pi->pardev = NULL;
 156         }
 157 }
 158
 159 void pi_release(PIA * pi)
 160 {
 161         pi_unregister_parport(pi);
 162         if (pi->proto->release_proto)
 163                 pi->proto->release_proto(pi);
 164         module_put(pi->proto->owner);
 165 }
 166
 167 EXPORT_SYMBOL(pi_release);
 168
 169 static int default_test_proto(PIA * pi, char *scratch, int verbose)
 170 {
 171         int j, k;
 172         int e[2] = { 0, 0 };
 173
 174         pi->proto->connect(pi);
 175
 176         for (j = 0; j < 2; j++) {
 177                 pi_write_regr(pi, 0, 6, 0xa0 + j * 0x10);
 178                 for (k = 0; k < 256; k++) {
 179                         pi_write_regr(pi, 0, 2, k ^ 0xaa);
 180                         pi_write_regr(pi, 0, 3, k ^ 0x55);
 181                         if (pi_read_regr(pi, 0, 2) != (k ^ 0xaa))
 182                                 e[j]++;
 183                 }
 184         }
 185         pi->proto->disconnect(pi);
 186
 187         if (verbose)
 188                 printk("%s: %s: port 0x%x, mode  %d, test=(%d,%d)\n",
 189                        pi->device, pi->proto->name, pi->port,
 190                        pi->mode, e[0], e[1]);
 191
 192         return (e[0] && e[1]);  /* not here if both > 0 */
 193 }
 194
 195 static int pi_test_proto(PIA * pi, char *scratch, int verbose)
 196 {
 197         int res;
 198
 199         pi_claim(pi);
 200         if (pi->proto->test_proto)
 201                 res = pi->proto->test_proto(pi, scratch, verbose);
 202         else
 203                 res = default_test_proto(pi, scratch, verbose);
 204         pi_unclaim(pi);
 205
 206         return res;
 207 }
 208
 209 int paride_register(PIP * pr)
 210 {
 211         int k;
 212
 213         for (k = 0; k < MAX_PROTOS; k++)
 214                 if (protocols[k] && !strcmp(pr->name, protocols[k]->name)) {
 215                         printk("paride: %s protocol already registered\n",
 216                                pr->name);
 217                         return -1;
 218                 }
 219         k = 0;
 220         while ((k < MAX_PROTOS) && (protocols[k]))
 221                 k++;
 222         if (k == MAX_PROTOS) {
 223                 printk("paride: protocol table full\n");
 224                 return -1;
 225         }
 226         protocols[k] = pr;
 227         pr->index = k;
 228         printk("paride: %s registered as protocol %d\n", pr->name, k);
 229         return 0;
 230 }
 231
 232 EXPORT_SYMBOL(paride_register);
 233
 234 void paride_unregister(PIP * pr)
 235 {
 236         if (!pr)
 237                 return;
 238         if (protocols[pr->index] != pr) {
 239                 printk("paride: %s not registered\n", pr->name);
 240                 return;
 241         }
 242         protocols[pr->index] = NULL;
 243 }
 244
 245 EXPORT_SYMBOL(paride_unregister);
 246
 247 static int pi_register_parport(PIA * pi, int verbose)
 248 {
 249         struct parport *port;
 250
 251         port = parport_find_base(pi->port);
 252         if (!port)
 253                 return 0;
 254
 255         pi->pardev = parport_register_device(port,
 256                                              pi->device, NULL,
 257                                              pi_wake_up, NULL, 0, (void *) pi);
 258         parport_put_port(port);
 259         if (!pi->pardev)
 260                 return 0;
 261
 262         init_waitqueue_head(&pi->parq);
 263
 264         if (verbose)
 265                 printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);
 266
 267         pi->parname = (char *) port->name;
 268
 269         return 1;
 270 }
 271
 272 static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
 273 {
 274         int best, range;
 275
 276         if (pi->mode != -1) {
 277                 if (pi->mode >= max)
 278                         return 0;
 279                 range = 3;
 280                 if (pi->mode >= pi->proto->epp_first)
 281                         range = 8;
 282                 if ((range == 8) && (pi->port % 8))
 283                         return 0;
 284                 pi->reserved = range;
 285                 return (!pi_test_proto(pi, scratch, verbose));
 286         }
 287         best = -1;
 288         for (pi->mode = 0; pi->mode < max; pi->mode++) {
 289                 range = 3;
 290                 if (pi->mode >= pi->proto->epp_first)
 291                         range = 8;
 292                 if ((range == 8) && (pi->port % 8))
 293                         break;
 294                 pi->reserved = range;
 295                 if (!pi_test_proto(pi, scratch, verbose))
 296                         best = pi->mode;
 297         }
 298         pi->mode = best;
 299         return (best > -1);
 300 }
 301
 302 static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
 303 {
 304         int max, s, e;
 305
 306         s = unit;
 307         e = s + 1;
 308
 309         if (s == -1) {
 310                 s = 0;
 311                 e = pi->proto->max_units;
 312         }
 313
 314         if (!pi_register_parport(pi, verbose))
 315                 return 0;
 316
 317         if (pi->proto->test_port) {
 318                 pi_claim(pi);
 319                 max = pi->proto->test_port(pi);
 320                 pi_unclaim(pi);
 321         } else
 322                 max = pi->proto->max_mode;
 323
 324         if (pi->proto->probe_unit) {
 325                 pi_claim(pi);
 326                 for (pi->unit = s; pi->unit < e; pi->unit++)
 327                         if (pi->proto->probe_unit(pi)) {
 328                                 pi_unclaim(pi);
 329                                 if (pi_probe_mode(pi, max, scratch, verbose))
 330                                         return 1;
 331                                 pi_unregister_parport(pi);
 332                                 return 0;
 333                         }
 334                 pi_unclaim(pi);
 335                 pi_unregister_parport(pi);
 336                 return 0;
 337         }
 338
 339         if (!pi_probe_mode(pi, max, scratch, verbose)) {
 340                 pi_unregister_parport(pi);
 341                 return 0;
 342         }
 343         return 1;
 344
 345 }
 346
 347 int pi_init(PIA * pi, int autoprobe, int port, int mode,
 348         int unit, int protocol, int delay, char *scratch,
 349         int devtype, int verbose, char *device)
 350 {
 351         int p, k, s, e;
 352         int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };
 353
 354         s = protocol;
 355         e = s + 1;
 356
 357         if (!protocols[0])
 358                 request_module("paride_protocol");
 359
 360         if (autoprobe) {
 361                 s = 0;
 362                 e = MAX_PROTOS;
 363         } else if ((s < 0) || (s >= MAX_PROTOS) || (port <= 0) ||
 364                    (!protocols[s]) || (unit < 0) ||
 365                    (unit >= protocols[s]->max_units)) {
 366                 printk("%s: Invalid parameters\n", device);
 367                 return 0;
 368         }
 369
 370         for (p = s; p < e; p++) {
 371                 struct pi_protocol *proto = protocols[p];
 372                 if (!proto)
 373                         continue;
 374                 /* still racy */
 375                 if (!try_module_get(proto->owner))
 376                         continue;
 377                 pi->proto = proto;
 378                 pi->private = 0;
 379                 if (proto->init_proto && proto->init_proto(pi) < 0) {
 380                         pi->proto = NULL;
 381                         module_put(proto->owner);
 382                         continue;
 383                 }
 384                 if (delay == -1)
 385                         pi->delay = pi->proto->default_delay;
 386                 else
 387                         pi->delay = delay;
 388                 pi->devtype = devtype;
 389                 pi->device = device;
 390
 391                 pi->parname = NULL;
 392                 pi->pardev = NULL;
 393                 init_waitqueue_head(&pi->parq);
 394                 pi->claimed = 0;
 395                 pi->claim_cont = NULL;
 396
 397                 pi->mode = mode;
 398                 if (port != -1) {
 399                         pi->port = port;
 400                         if (pi_probe_unit(pi, unit, scratch, verbose))
 401                                 break;
 402                         pi->port = 0;
 403                 } else {
 404                         k = 0;
 405                         while ((pi->port = lpts[k++]))
 406                                 if (pi_probe_unit
 407                                     (pi, unit, scratch, verbose))
 408                                         break;
 409                         if (pi->port)
 410                                 break;
 411                 }
 412                 if (pi->proto->release_proto)
 413                         pi->proto->release_proto(pi);
 414                 module_put(proto->owner);
 415         }
 416
 417         if (!pi->port) {
 418                 if (autoprobe)
 419                         printk("%s: Autoprobe failed\n", device);
 420                 else
 421                         printk("%s: Adapter not found\n", device);
 422                 return 0;
 423         }
 424
 425         if (pi->parname)
 426                 printk("%s: Sharing %s at 0x%x\n", pi->device,
 427                        pi->parname, pi->port);
 428
 429         pi->proto->log_adapter(pi, scratch, verbose);
 430
 431         return 1;
 432 }
 433
 434 EXPORT_SYMBOL(pi_init);