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 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
  16 */
  17
  18 #define PI_VERSION      "1.03"
  19
  20 #include <linux/module.h>
  21 #include <linux/config.h>
  22 #include <linux/types.h>
  23 #include <linux/kernel.h>
  24 #include <linux/ioport.h>
  25 #include <linux/string.h>
  26 #include <asm/spinlock.h>
  27
  28 #ifdef CONFIG_PARPORT_MODULE
  29 #define CONFIG_PARPORT
  30 #endif
  31
  32 #ifdef CONFIG_PARPORT
  33 #include <linux/parport.h>
  34 #endif
  35
  36 #include "paride.h"
  37
  38 #define MAX_PROTOS      32
  39
  40 static struct pi_protocol       *protocols[MAX_PROTOS];
  41
  42 spinlock_t      pi_spinlock = SPIN_LOCK_UNLOCKED;
  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 int pi_read_regr( PIA *pi, int cont, int regr)
  50
  51 {       return pi->proto->read_regr(pi,cont,regr);
  52 }
  53
  54 void pi_write_block( PIA *pi, char * buf, int count)
  55
  56 {       pi->proto->write_block(pi,buf,count);
  57 }
  58
  59 void pi_read_block( PIA *pi, char * buf, int count)
  60
  61 {       pi->proto->read_block(pi,buf,count);
  62 }
  63
  64 #ifdef CONFIG_PARPORT
  65
  66 static void pi_wake_up( void *p)
  67
  68 {       PIA  *pi = (PIA *) p;
  69         long flags;
  70         void (*cont)(void) = NULL;
  71
  72         spin_lock_irqsave(&pi_spinlock,flags);
  73
  74         if (pi->claim_cont && !parport_claim(pi->pardev)) {
  75                 cont = pi->claim_cont;
  76                 pi->claim_cont = NULL;
  77                 pi->claimed = 1;
  78         }
  79
  80         spin_unlock_irqrestore(&pi_spinlock,flags);
  81
  82         wake_up(&(pi->parq));
  83
  84         if (cont) cont();
  85 }
  86
  87 #endif
  88
  89 void pi_do_claimed( PIA *pi, void(*cont)(void))
  90
  91 #ifdef CONFIG_PARPORT
  92
  93 {       long flags;
  94
  95         spin_lock_irqsave(&pi_spinlock,flags);
  96
  97         if (!pi->pardev || !parport_claim(pi->pardev)) {
  98                 pi->claimed = 1;
  99                 spin_unlock_irqrestore(&pi_spinlock,flags);
 100                 cont();
 101         } else {
 102                 pi->claim_cont = cont;
 103                 spin_unlock_irqrestore(&pi_spinlock,flags);
 104         }
 105 }
 106
 107 #else
 108
 109 {       cont();
 110 }
 111
 112 #endif
 113
 114 static void pi_claim( PIA *pi)
 115
 116 {       if (pi->claimed) return;
 117         pi->claimed = 1;
 118 #ifdef CONFIG_PARPORT
 119         if (pi->pardev)
 120           while (parport_claim((struct pardevice *)(pi->pardev)))
 121             sleep_on(&(pi->parq));
 122 #endif
 123 }
 124
 125 static void pi_unclaim( PIA *pi)
 126
 127 {       pi->claimed = 0;
 128 #ifdef CONFIG_PARPORT
 129         if (pi->pardev) parport_release((struct pardevice *)(pi->pardev));
 130 #endif
 131 }
 132
 133 void pi_connect( PIA *pi)
 134
 135 {       pi_claim(pi);
 136         pi->proto->connect(pi);
 137 }
 138
 139 void pi_disconnect( PIA *pi)
 140
 141 {       pi->proto->disconnect(pi);
 142         pi_unclaim(pi);
 143 }
 144
 145 static void pi_unregister_parport( PIA *pi)
 146
 147 {
 148 #ifdef CONFIG_PARPORT
 149         if (pi->pardev) {
 150            parport_unregister_device((struct pardevice *)(pi->pardev));
 151            pi->pardev = NULL;
 152         }
 153 #endif
 154 }
 155
 156 void pi_release( PIA *pi)
 157
 158 {       pi_unregister_parport(pi);
 159         if ((!pi->pardev)&&(pi->reserved))
 160                 release_region(pi->port,pi->reserved);
 161         pi->proto->release_proto(pi);
 162 }
 163
 164 #define WR(r,v)         pi_write_regr(pi,0,r,v)
 165 #define RR(r)           (pi_read_regr(pi,0,r))
 166
 167 static int pi_test_proto( PIA *pi, char * scratch, int verbose )
 168
 169 {       int     j, k;
 170         int     e[2] = {0,0};
 171
 172         if (pi->proto->test_proto) {
 173                 pi_claim(pi);
 174                 j = pi->proto->test_proto(pi,scratch,verbose);
 175                 pi_unclaim(pi);
 176                 return j;
 177         }
 178
 179         pi_connect(pi);
 180
 181         for (j=0;j<2;j++) {
 182                 WR(6,0xa0+j*0x10);
 183                 for (k=0;k<256;k++) {
 184                         WR(2,k^0xaa);
 185                         WR(3,k^0x55);
 186                         if (RR(2) != (k^0xaa)) e[j]++;
 187                         }
 188                 }
 189
 190         pi_disconnect(pi);
 191
 192         if (verbose)
 193                 printk("%s: %s: port 0x%x, mode  %d, test=(%d,%d)\n",
 194                         pi->device,pi->proto->name,pi->port,
 195                         pi->mode,e[0],e[1]);
 196
 197         return (e[0] && e[1]);  /* not here if both > 0 */
 198 }
 199
 200 int  pi_register( PIP *pr)
 201
 202 {       int k;
 203
 204         for (k=0;k<MAX_PROTOS;k++)
 205            if (protocols[k] && !strcmp(pr->name,protocols[k]->name)) {
 206                 printk("paride: %s protocol already registered\n",pr->name);
 207                 return 0;
 208            }
 209         k = 0;
 210         while((k<MAX_PROTOS) && (protocols[k])) k++;
 211         if (k == MAX_PROTOS) {
 212                 printk("paride: protocol table full\n");
 213                 return 0;
 214         }
 215         MOD_INC_USE_COUNT;
 216         protocols[k] = pr;
 217         pr->index = k;
 218         printk("paride: %s registered as protocol %d\n",pr->name,k);
 219         return 1;
 220 }
 221
 222 void pi_unregister( PIP *pr)
 223
 224 {       if (!pr) return;
 225         if (protocols[pr->index] != pr) {
 226                 printk("paride: %s not registered\n",pr->name);
 227                 return;
 228         }
 229         protocols[pr->index] = 0;
 230         MOD_DEC_USE_COUNT;
 231 }
 232
 233 static void pi_register_parport( PIA *pi, int verbose)
 234
 235 {
 236 #ifdef CONFIG_PARPORT
 237
 238         struct parport  *pp;
 239
 240         pp = parport_enumerate();
 241
 242         while((pp)&&(pp->base != pi->port)) pp = pp->next;
 243
 244         if (!pp) return;
 245
 246         pi->pardev = (void *) parport_register_device(
 247               pp,pi->device,NULL,pi_wake_up,NULL,0,(void *)pi);
 248
 249         pi->parq = NULL;
 250
 251         if (verbose) printk("%s: 0x%x is %s\n",pi->device,pi->port,pp->name);
 252
 253         pi->parname = (char *)pp->name;
 254
 255 #endif
 256 }
 257
 258 static int pi_probe_mode( PIA *pi, int max, char * scratch, int verbose)
 259
 260 {       int     best, range;
 261
 262         if (pi->mode != -1) {
 263                 if (pi->mode >= max) return 0;
 264                 range = 3;
 265                 if (pi->mode >= pi->proto->epp_first) range = 8;
 266                 if ((range == 8) && (pi->port % 8)) return 0;
 267                 if ((!pi->pardev) && check_region(pi->port,range)) return 0;
 268                 pi->reserved = range;
 269                 return (!pi_test_proto(pi,scratch,verbose));
 270         }
 271         best = -1;
 272         for(pi->mode=0;pi->mode<max;pi->mode++) {
 273                 range = 3;
 274                 if (pi->mode >= pi->proto->epp_first) range = 8;
 275                 if ((range == 8) && (pi->port % 8)) break;
 276                 if ((!pi->pardev) && check_region(pi->port,range)) break;
 277                 pi->reserved = range;
 278                 if (!pi_test_proto(pi,scratch,verbose)) best = pi->mode;
 279         }
 280         pi->mode = best;
 281         return (best > -1);
 282 }
 283
 284 static int pi_probe_unit( PIA *pi, int unit, char * scratch, int verbose)
 285
 286 {       int max,s,e;
 287
 288         s = unit; e = s+1;
 289
 290         if (s == -1) {
 291                 s = 0;
 292                 e = pi->proto->max_units;
 293         }
 294
 295         pi_register_parport(pi,verbose);
 296
 297         if ((!pi->pardev) && check_region(pi->port,3)) return 0;
 298
 299         if (pi->proto->test_port) {
 300                 pi_claim(pi);
 301                 max = pi->proto->test_port(pi);
 302                 pi_unclaim(pi);
 303         }
 304         else max = pi->proto->max_mode;
 305
 306         if (pi->proto->probe_unit) {
 307            pi_claim(pi);
 308            for (pi->unit=s;pi->unit<e;pi->unit++)
 309               if (pi->proto->probe_unit(pi)) {
 310                  pi_unclaim(pi);
 311                  if (pi_probe_mode(pi,max,scratch,verbose)) return 1;
 312                  pi_unregister_parport(pi);
 313                  return 0;
 314                  }
 315            pi_unclaim(pi);
 316            pi_unregister_parport(pi);
 317            return 0;
 318            }
 319
 320         if (!pi_probe_mode(pi,max,scratch,verbose)) {
 321            pi_unregister_parport(pi);
 322            return 0;
 323         }
 324         return 1;
 325
 326 }
 327
 328 int pi_init(PIA *pi, int autoprobe, int port, int mode,
 329             int unit, int protocol, int delay, char * scratch,
 330             int devtype, int verbose, char *device )
 331
 332 {       int p,k,s,e;
 333         int lpts[7] = {0x3bc,0x378,0x278,0x268,0x27c,0x26c,0};
 334
 335         s = protocol; e = s+1;
 336
 337         if (autoprobe) {
 338                 s = 0;
 339                 e = MAX_PROTOS;
 340         } else if ((s < 0) || (s >= MAX_PROTOS) || (port <= 0) ||
 341                     (!protocols[s]) || (unit < 0) ||
 342                     (unit >= protocols[s]->max_units)) {
 343                         printk("%s: Invalid parameters\n",device);
 344                         return 0;
 345                         }
 346
 347         for (p=s;p<e;p++) {
 348           if (protocols[p]) {
 349                 pi->proto = protocols[p];
 350                 pi->private = 0;
 351                 pi->proto->init_proto(pi);
 352                 if (delay == -1) pi->delay = pi->proto->default_delay;
 353                   else pi->delay = delay;
 354                 pi->devtype = devtype;
 355                 pi->device = device;
 356
 357                 pi->parname = NULL;
 358                 pi->pardev = NULL;
 359                 pi->parq = NULL;
 360                 pi->claimed = 0;
 361                 pi->claim_cont = NULL;
 362
 363                 pi->mode = mode;
 364                 if (port != -1) {
 365                         pi->port = port;
 366                         if (pi_probe_unit(pi,unit,scratch,verbose)) break;
 367                         pi->port = 0;
 368                 } else {
 369                         k = 0;
 370                         while ((pi->port = lpts[k++]))
 371                            if (pi_probe_unit(pi,unit,scratch,verbose)) break;
 372                         if (pi->port) break;
 373                 }
 374                 pi->proto->release_proto(pi);
 375           }
 376         }
 377
 378         if (!pi->port) {
 379                 if (autoprobe) printk("%s: Autoprobe failed\n",device);
 380                 else printk("%s: Adapter not found\n",device);
 381                 return 0;
 382         }
 383
 384         if (!pi->pardev)
 385            request_region(pi->port,pi->reserved,pi->device);
 386
 387         if (pi->parname)
 388            printk("%s: Sharing %s at 0x%x\n",pi->device,
 389                         pi->parname,pi->port);
 390
 391         pi->proto->log_adapter(pi,scratch,verbose);
 392
 393         return 1;
 394 }
 395
 396 #ifdef MODULE
 397
 398 int     init_module(void)
 399
 400 {       int k;
 401
 402         for (k=0;k<MAX_PROTOS;k++) protocols[k] = 0;
 403         printk("paride: version %s installed\n",PI_VERSION);
 404         return 0;
 405 }
 406
 407 void    cleanup_module(void)
 408
 409 {
 410 }
 411
 412 #else
 413
 414 void    paride_init( void )
 415
 416 {
 417
 418 #ifdef CONFIG_PARIDE_ATEN
 419         { extern struct pi_protocol aten;
 420           pi_register(&aten);
 421         };
 422 #endif
 423 #ifdef CONFIG_PARIDE_BPCK
 424         { extern struct pi_protocol bpck;
 425           pi_register(&bpck);
 426         };
 427 #endif
 428 #ifdef CONFIG_PARIDE_COMM
 429         { extern struct pi_protocol comm;
 430           pi_register(&comm);
 431         };
 432 #endif
 433 #ifdef CONFIG_PARIDE_DSTR
 434         { extern struct pi_protocol dstr;
 435           pi_register(&dstr);
 436         };
 437 #endif
 438 #ifdef CONFIG_PARIDE_EPAT
 439         { extern struct pi_protocol epat;
 440           pi_register(&epat);
 441         };
 442 #endif
 443 #ifdef CONFIG_PARIDE_EPIA
 444         { extern struct pi_protocol epia;
 445           pi_register(&epia);
 446         };
 447 #endif
 448 #ifdef CONFIG_PARIDE_FRPW
 449         { extern struct pi_protocol frpw;
 450           pi_register(&frpw);
 451         };
 452 #endif
 453 #ifdef CONFIG_PARIDE_FIT2
 454         { extern struct pi_protocol fit2;
 455           pi_register(&fit2);
 456         };
 457 #endif
 458 #ifdef CONFIG_PARIDE_FIT3
 459         { extern struct pi_protocol fit3;
 460           pi_register(&fit3);
 461         };
 462 #endif
 463 #ifdef CONFIG_PARIDE_KBIC
 464         { extern struct pi_protocol k951;
 465           extern struct pi_protocol k971;
 466           pi_register(&k951);
 467           pi_register(&k971);
 468         };
 469 #endif
 470 #ifdef CONFIG_PARIDE_KTTI
 471         { extern struct pi_protocol ktti;
 472           pi_register(&ktti);
 473         };
 474 #endif
 475 #ifdef CONFIG_PARIDE_ON20
 476         { extern struct pi_protocol on20;
 477           pi_register(&on20);
 478         };
 479 #endif
 480 #ifdef CONFIG_PARIDE_ON26
 481         { extern struct pi_protocol on26;
 482           pi_register(&on26);
 483         };
 484 #endif
 485
 486 #ifdef CONFIG_PARIDE_PD
 487         { extern int pd_init(void);
 488           pd_init();
 489         };
 490 #endif
 491 #ifdef CONFIG_PARIDE_PCD
 492         { extern int pcd_init(void);
 493           pcd_init();
 494         };
 495 #endif
 496 #ifdef CONFIG_PARIDE_PF
 497         { extern int pf_init(void);
 498           pf_init();
 499         };
 500 #endif
 501 #ifdef CONFIG_PARIDE_PT
 502         { extern int pt_init(void);
 503           pt_init();
 504         };
 505 #endif
 506 #ifdef CONFIG_PARIDE_PG
 507         { extern int pg_init(void);
 508           pg_init();
 509         };
 510 #endif
 511 }
 512
 513 #endif
 514
 515 /* end of paride.c */