drivers/block/paride/pd.c

   1 /*
   2         pd.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 high-level driver for parallel port IDE hard
   6         drives based on chips supported by the paride module.
   7
   8         By default, the driver will autoprobe for a single parallel
   9         port IDE drive, but if their individual parameters are
  10         specified, the driver can handle up to 4 drives.
  11
  12         The behaviour of the pd driver can be altered by setting
  13         some parameters from the insmod command line.  The following
  14         parameters are adjustable:
  15
  16             drive0      These four arguments can be arrays of
  17             drive1      1-8 integers as follows:
  18             drive2
  19             drive3      <prt>,<pro>,<uni>,<mod>,<geo>,<sby>,<dly>,<slv>
  20
  21                         Where,
  22
  23                 <prt>   is the base of the parallel port address for
  24                         the corresponding drive.  (required)
  25
  26                 <pro>   is the protocol number for the adapter that
  27                         supports this drive.  These numbers are
  28                         logged by 'paride' when the protocol modules
  29                         are initialised.  (0 if not given)
  30
  31                 <uni>   for those adapters that support chained
  32                         devices, this is the unit selector for the
  33                         chain of devices on the given port.  It should
  34                         be zero for devices that don't support chaining.
  35                         (0 if not given)
  36
  37                 <mod>   this can be -1 to choose the best mode, or one
  38                         of the mode numbers supported by the adapter.
  39                         (-1 if not given)
  40
  41                 <geo>   this defaults to 0 to indicate that the driver
  42                         should use the CHS geometry provided by the drive
  43                         itself.  If set to 1, the driver will provide
  44                         a logical geometry with 64 heads and 32 sectors
  45                         per track, to be consistent with most SCSI
  46                         drivers.  (0 if not given)
  47
  48                 <sby>   set this to zero to disable the power saving
  49                         standby mode, if needed.  (1 if not given)
  50
  51                 <dly>   some parallel ports require the driver to
  52                         go more slowly.  -1 sets a default value that
  53                         should work with the chosen protocol.  Otherwise,
  54                         set this to a small integer, the larger it is
  55                         the slower the port i/o.  In some cases, setting
  56                         this to zero will speed up the device. (default -1)
  57
  58                 <slv>   IDE disks can be jumpered to master or slave.
  59                         Set this to 0 to choose the master drive, 1 to
  60                         choose the slave, -1 (the default) to choose the
  61                         first drive found.
  62
  63
  64             major       You may use this parameter to override the
  65                         default major number (45) that this driver
  66                         will use.  Be sure to change the device
  67                         name as well.
  68
  69             name        This parameter is a character string that
  70                         contains the name the kernel will use for this
  71                         device (in /proc output, for instance).
  72                         (default "pd")
  73
  74             cluster     The driver will attempt to aggregate requests
  75                         for adjacent blocks into larger multi-block
  76                         clusters.  The maximum cluster size (in 512
  77                         byte sectors) is set with this parameter.
  78                         (default 64)
  79
  80             verbose     This parameter controls the amount of logging
  81                         that the driver will do.  Set it to 0 for
  82                         normal operation, 1 to see autoprobe progress
  83                         messages, or 2 to see additional debugging
  84                         output.  (default 0)
  85
  86             nice        This parameter controls the driver's use of
  87                         idle CPU time, at the expense of some speed.
  88
  89         If this driver is built into the kernel, you can use kernel
  90         the following command line parameters, with the same values
  91         as the corresponding module parameters listed above:
  92
  93             pd.drive0
  94             pd.drive1
  95             pd.drive2
  96             pd.drive3
  97             pd.cluster
  98             pd.nice
  99
 100         In addition, you can use the parameter pd.disable to disable
 101         the driver entirely.
 102
 103 */
 104
 105 /* Changes:
 106
 107         1.01    GRG 1997.01.24  Restored pd_reset()
 108                                 Added eject ioctl
 109         1.02    GRG 1998.05.06  SMP spinlock changes,
 110                                 Added slave support
 111         1.03    GRG 1998.06.16  Eliminate an Ugh.
 112         1.04    GRG 1998.08.15  Extra debugging, use HZ in loop timing
 113         1.05    GRG 1998.09.24  Added jumbo support
 114
 115 */
 116
 117 #define PD_VERSION      "1.05"
 118 #define PD_MAJOR        45
 119 #define PD_NAME         "pd"
 120 #define PD_UNITS        4
 121
 122 /* Here are things one can override from the insmod command.
 123    Most are autoprobed by paride unless set here.  Verbose is off
 124    by default.
 125
 126 */
 127 #include <linux/types.h>
 128
 129 static int verbose = 0;
 130 static int major = PD_MAJOR;
 131 static char *name = PD_NAME;
 132 static int cluster = 64;
 133 static int nice = 0;
 134 static int disable = 0;
 135
 136 static int drive0[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 137 static int drive1[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 138 static int drive2[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 139 static int drive3[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 140
 141 static int (*drives[4])[8] = {&drive0, &drive1, &drive2, &drive3};
 142
 143 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
 144
 145 /* end of parameters */
 146
 147 #include <linux/init.h>
 148 #include <linux/module.h>
 149 #include <linux/gfp.h>
 150 #include <linux/fs.h>
 151 #include <linux/delay.h>
 152 #include <linux/hdreg.h>
 153 #include <linux/cdrom.h>        /* for the eject ioctl */
 154 #include <linux/blkdev.h>
 155 #include <linux/blkpg.h>
 156 #include <linux/kernel.h>
 157 #include <linux/mutex.h>
 158 #include <linux/uaccess.h>
 159 #include <linux/workqueue.h>
 160
 161 static DEFINE_MUTEX(pd_mutex);
 162 static DEFINE_SPINLOCK(pd_lock);
 163
 164 module_param(verbose, int, 0);
 165 module_param(major, int, 0);
 166 module_param(name, charp, 0);
 167 module_param(cluster, int, 0);
 168 module_param(nice, int, 0);
 169 module_param_array(drive0, int, NULL, 0);
 170 module_param_array(drive1, int, NULL, 0);
 171 module_param_array(drive2, int, NULL, 0);
 172 module_param_array(drive3, int, NULL, 0);
 173
 174 #include "paride.h"
 175
 176 #define PD_BITS    4
 177
 178 /* numbers for "SCSI" geometry */
 179
 180 #define PD_LOG_HEADS    64
 181 #define PD_LOG_SECTS    32
 182
 183 #define PD_ID_OFF       54
 184 #define PD_ID_LEN       14
 185
 186 #define PD_MAX_RETRIES  5
 187 #define PD_TMO          800     /* interrupt timeout in jiffies */
 188 #define PD_SPIN_DEL     50      /* spin delay in micro-seconds  */
 189
 190 #define PD_SPIN         (1000000*PD_TMO)/(HZ*PD_SPIN_DEL)
 191
 192 #define STAT_ERR        0x00001
 193 #define STAT_INDEX      0x00002
 194 #define STAT_ECC        0x00004
 195 #define STAT_DRQ        0x00008
 196 #define STAT_SEEK       0x00010
 197 #define STAT_WRERR      0x00020
 198 #define STAT_READY      0x00040
 199 #define STAT_BUSY       0x00080
 200
 201 #define ERR_AMNF        0x00100
 202 #define ERR_TK0NF       0x00200
 203 #define ERR_ABRT        0x00400
 204 #define ERR_MCR         0x00800
 205 #define ERR_IDNF        0x01000
 206 #define ERR_MC          0x02000
 207 #define ERR_UNC         0x04000
 208 #define ERR_TMO         0x10000
 209
 210 #define IDE_READ                0x20
 211 #define IDE_WRITE               0x30
 212 #define IDE_READ_VRFY           0x40
 213 #define IDE_INIT_DEV_PARMS      0x91
 214 #define IDE_STANDBY             0x96
 215 #define IDE_ACKCHANGE           0xdb
 216 #define IDE_DOORLOCK            0xde
 217 #define IDE_DOORUNLOCK          0xdf
 218 #define IDE_IDENTIFY            0xec
 219 #define IDE_EJECT               0xed
 220
 221 #define PD_NAMELEN      8
 222
 223 struct pd_unit {
 224         struct pi_adapter pia;  /* interface to paride layer */
 225         struct pi_adapter *pi;
 226         int access;             /* count of active opens ... */
 227         int capacity;           /* Size of this volume in sectors */
 228         int heads;              /* physical geometry */
 229         int sectors;
 230         int cylinders;
 231         int can_lba;
 232         int drive;              /* master=0 slave=1 */
 233         int changed;            /* Have we seen a disk change ? */
 234         int removable;          /* removable media device  ?  */
 235         int standby;
 236         int alt_geom;
 237         char name[PD_NAMELEN];  /* pda, pdb, etc ... */
 238         struct gendisk *gd;
 239 };
 240
 241 static struct pd_unit pd[PD_UNITS];
 242
 243 static char pd_scratch[512];    /* scratch block buffer */
 244
 245 static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
 246         "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
 247         "IDNF", "MC", "UNC", "???", "TMO"
 248 };
 249
 250 static void *par_drv;           /* reference of parport driver */
 251
 252 static inline int status_reg(struct pd_unit *disk)
 253 {
 254         return pi_read_regr(disk->pi, 1, 6);
 255 }
 256
 257 static inline int read_reg(struct pd_unit *disk, int reg)
 258 {
 259         return pi_read_regr(disk->pi, 0, reg);
 260 }
 261
 262 static inline void write_status(struct pd_unit *disk, int val)
 263 {
 264         pi_write_regr(disk->pi, 1, 6, val);
 265 }
 266
 267 static inline void write_reg(struct pd_unit *disk, int reg, int val)
 268 {
 269         pi_write_regr(disk->pi, 0, reg, val);
 270 }
 271
 272 static inline u8 DRIVE(struct pd_unit *disk)
 273 {
 274         return 0xa0+0x10*disk->drive;
 275 }
 276
 277 /*  ide command interface */
 278
 279 static void pd_print_error(struct pd_unit *disk, char *msg, int status)
 280 {
 281         int i;
 282
 283         printk("%s: %s: status = 0x%x =", disk->name, msg, status);
 284         for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
 285                 if (status & (1 << i))
 286                         printk(" %s", pd_errs[i]);
 287         printk("\n");
 288 }
 289
 290 static void pd_reset(struct pd_unit *disk)
 291 {                               /* called only for MASTER drive */
 292         write_status(disk, 4);
 293         udelay(50);
 294         write_status(disk, 0);
 295         udelay(250);
 296 }
 297
 298 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 299
 300 static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
 301 {                               /* polled wait */
 302         int k, r, e;
 303
 304         k = 0;
 305         while (k < PD_SPIN) {
 306                 r = status_reg(disk);
 307                 k++;
 308                 if (((r & w) == w) && !(r & STAT_BUSY))
 309                         break;
 310                 udelay(PD_SPIN_DEL);
 311         }
 312         e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
 313         if (k >= PD_SPIN)
 314                 e |= ERR_TMO;
 315         if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
 316                 pd_print_error(disk, msg, e);
 317         return e;
 318 }
 319
 320 static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
 321 {
 322         write_reg(disk, 6, DRIVE(disk) + h);
 323         write_reg(disk, 1, 0);          /* the IDE task file */
 324         write_reg(disk, 2, n);
 325         write_reg(disk, 3, s);
 326         write_reg(disk, 4, c0);
 327         write_reg(disk, 5, c1);
 328         write_reg(disk, 7, func);
 329
 330         udelay(1);
 331 }
 332
 333 static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
 334 {
 335         int c1, c0, h, s;
 336
 337         if (disk->can_lba) {
 338                 s = block & 255;
 339                 c0 = (block >>= 8) & 255;
 340                 c1 = (block >>= 8) & 255;
 341                 h = ((block >>= 8) & 15) + 0x40;
 342         } else {
 343                 s = (block % disk->sectors) + 1;
 344                 h = (block /= disk->sectors) % disk->heads;
 345                 c0 = (block /= disk->heads) % 256;
 346                 c1 = (block >>= 8);
 347         }
 348         pd_send_command(disk, count, s, h, c0, c1, func);
 349 }
 350
 351 /* The i/o request engine */
 352
 353 enum action {Fail = 0, Ok = 1, Hold, Wait};
 354
 355 static struct request *pd_req;  /* current request */
 356 static enum action (*phase)(void);
 357
 358 static void run_fsm(void);
 359
 360 static void ps_tq_int(struct work_struct *work);
 361
 362 static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
 363
 364 static void schedule_fsm(void)
 365 {
 366         if (!nice)
 367                 schedule_delayed_work(&fsm_tq, 0);
 368         else
 369                 schedule_delayed_work(&fsm_tq, nice-1);
 370 }
 371
 372 static void ps_tq_int(struct work_struct *work)
 373 {
 374         run_fsm();
 375 }
 376
 377 static enum action do_pd_io_start(void);
 378 static enum action pd_special(void);
 379 static enum action do_pd_read_start(void);
 380 static enum action do_pd_write_start(void);
 381 static enum action do_pd_read_drq(void);
 382 static enum action do_pd_write_done(void);
 383
 384 static int pd_queue;
 385 static int pd_claimed;
 386
 387 static struct pd_unit *pd_current; /* current request's drive */
 388 static PIA *pi_current; /* current request's PIA */
 389
 390 static int set_next_request(void)
 391 {
 392         struct gendisk *disk;
 393         struct request_queue *q;
 394         int old_pos = pd_queue;
 395
 396         do {
 397                 disk = pd[pd_queue].gd;
 398                 q = disk ? disk->queue : NULL;
 399                 if (++pd_queue == PD_UNITS)
 400                         pd_queue = 0;
 401                 if (q) {
 402                         pd_req = blk_fetch_request(q);
 403                         if (pd_req)
 404                                 break;
 405                 }
 406         } while (pd_queue != old_pos);
 407
 408         return pd_req != NULL;
 409 }
 410
 411 static void run_fsm(void)
 412 {
 413         while (1) {
 414                 enum action res;
 415                 unsigned long saved_flags;
 416                 int stop = 0;
 417
 418                 if (!phase) {
 419                         pd_current = pd_req->rq_disk->private_data;
 420                         pi_current = pd_current->pi;
 421                         phase = do_pd_io_start;
 422                 }
 423
 424                 switch (pd_claimed) {
 425                         case 0:
 426                                 pd_claimed = 1;
 427                                 if (!pi_schedule_claimed(pi_current, run_fsm))
 428                                         return;
 429                                 /* fall through */
 430                         case 1:
 431                                 pd_claimed = 2;
 432                                 pi_current->proto->connect(pi_current);
 433                 }
 434
 435                 switch(res = phase()) {
 436                         case Ok: case Fail:
 437                                 pi_disconnect(pi_current);
 438                                 pd_claimed = 0;
 439                                 phase = NULL;
 440                                 spin_lock_irqsave(&pd_lock, saved_flags);
 441                                 if (!__blk_end_request_cur(pd_req,
 442                                                 res == Ok ? 0 : BLK_STS_IOERR)) {
 443                                         if (!set_next_request())
 444                                                 stop = 1;
 445                                 }
 446                                 spin_unlock_irqrestore(&pd_lock, saved_flags);
 447                                 if (stop)
 448                                         return;
 449                                 /* fall through */
 450                         case Hold:
 451                                 schedule_fsm();
 452                                 return;
 453                         case Wait:
 454                                 pi_disconnect(pi_current);
 455                                 pd_claimed = 0;
 456                 }
 457         }
 458 }
 459
 460 static int pd_retries = 0;      /* i/o error retry count */
 461 static int pd_block;            /* address of next requested block */
 462 static int pd_count;            /* number of blocks still to do */
 463 static int pd_run;              /* sectors in current cluster */
 464 static char *pd_buf;            /* buffer for request in progress */
 465
 466 static enum action do_pd_io_start(void)
 467 {
 468         switch (req_op(pd_req)) {
 469         case REQ_OP_DRV_IN:
 470                 phase = pd_special;
 471                 return pd_special();
 472         case REQ_OP_READ:
 473         case REQ_OP_WRITE:
 474                 pd_block = blk_rq_pos(pd_req);
 475                 pd_count = blk_rq_cur_sectors(pd_req);
 476                 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
 477                         return Fail;
 478                 pd_run = blk_rq_sectors(pd_req);
 479                 pd_buf = bio_data(pd_req->bio);
 480                 pd_retries = 0;
 481                 if (req_op(pd_req) == REQ_OP_READ)
 482                         return do_pd_read_start();
 483                 else
 484                         return do_pd_write_start();
 485         }
 486         return Fail;
 487 }
 488
 489 static enum action pd_special(void)
 490 {
 491         enum action (*func)(struct pd_unit *) = pd_req->special;
 492         return func(pd_current);
 493 }
 494
 495 static int pd_next_buf(void)
 496 {
 497         unsigned long saved_flags;
 498
 499         pd_count--;
 500         pd_run--;
 501         pd_buf += 512;
 502         pd_block++;
 503         if (!pd_run)
 504                 return 1;
 505         if (pd_count)
 506                 return 0;
 507         spin_lock_irqsave(&pd_lock, saved_flags);
 508         __blk_end_request_cur(pd_req, 0);
 509         pd_count = blk_rq_cur_sectors(pd_req);
 510         pd_buf = bio_data(pd_req->bio);
 511         spin_unlock_irqrestore(&pd_lock, saved_flags);
 512         return 0;
 513 }
 514
 515 static unsigned long pd_timeout;
 516
 517 static enum action do_pd_read_start(void)
 518 {
 519         if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
 520                 if (pd_retries < PD_MAX_RETRIES) {
 521                         pd_retries++;
 522                         return Wait;
 523                 }
 524                 return Fail;
 525         }
 526         pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
 527         phase = do_pd_read_drq;
 528         pd_timeout = jiffies + PD_TMO;
 529         return Hold;
 530 }
 531
 532 static enum action do_pd_write_start(void)
 533 {
 534         if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
 535                 if (pd_retries < PD_MAX_RETRIES) {
 536                         pd_retries++;
 537                         return Wait;
 538                 }
 539                 return Fail;
 540         }
 541         pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
 542         while (1) {
 543                 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
 544                         if (pd_retries < PD_MAX_RETRIES) {
 545                                 pd_retries++;
 546                                 return Wait;
 547                         }
 548                         return Fail;
 549                 }
 550                 pi_write_block(pd_current->pi, pd_buf, 512);
 551                 if (pd_next_buf())
 552                         break;
 553         }
 554         phase = do_pd_write_done;
 555         pd_timeout = jiffies + PD_TMO;
 556         return Hold;
 557 }
 558
 559 static inline int pd_ready(void)
 560 {
 561         return !(status_reg(pd_current) & STAT_BUSY);
 562 }
 563
 564 static enum action do_pd_read_drq(void)
 565 {
 566         if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
 567                 return Hold;
 568
 569         while (1) {
 570                 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
 571                         if (pd_retries < PD_MAX_RETRIES) {
 572                                 pd_retries++;
 573                                 phase = do_pd_read_start;
 574                                 return Wait;
 575                         }
 576                         return Fail;
 577                 }
 578                 pi_read_block(pd_current->pi, pd_buf, 512);
 579                 if (pd_next_buf())
 580                         break;
 581         }
 582         return Ok;
 583 }
 584
 585 static enum action do_pd_write_done(void)
 586 {
 587         if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
 588                 return Hold;
 589
 590         if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
 591                 if (pd_retries < PD_MAX_RETRIES) {
 592                         pd_retries++;
 593                         phase = do_pd_write_start;
 594                         return Wait;
 595                 }
 596                 return Fail;
 597         }
 598         return Ok;
 599 }
 600
 601 /* special io requests */
 602
 603 /* According to the ATA standard, the default CHS geometry should be
 604    available following a reset.  Some Western Digital drives come up
 605    in a mode where only LBA addresses are accepted until the device
 606    parameters are initialised.
 607 */
 608
 609 static void pd_init_dev_parms(struct pd_unit *disk)
 610 {
 611         pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
 612         pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
 613                         IDE_INIT_DEV_PARMS);
 614         udelay(300);
 615         pd_wait_for(disk, 0, "Initialise device parameters");
 616 }
 617
 618 static enum action pd_door_lock(struct pd_unit *disk)
 619 {
 620         if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
 621                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
 622                 pd_wait_for(disk, STAT_READY, "Lock done");
 623         }
 624         return Ok;
 625 }
 626
 627 static enum action pd_door_unlock(struct pd_unit *disk)
 628 {
 629         if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
 630                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
 631                 pd_wait_for(disk, STAT_READY, "Lock done");
 632         }
 633         return Ok;
 634 }
 635
 636 static enum action pd_eject(struct pd_unit *disk)
 637 {
 638         pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
 639         pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
 640         pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
 641         pd_wait_for(disk, 0, DBMSG("before eject"));
 642         pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
 643         pd_wait_for(disk, 0, DBMSG("after eject"));
 644         return Ok;
 645 }
 646
 647 static enum action pd_media_check(struct pd_unit *disk)
 648 {
 649         int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
 650         if (!(r & STAT_ERR)) {
 651                 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
 652                 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
 653         } else
 654                 disk->changed = 1;      /* say changed if other error */
 655         if (r & ERR_MC) {
 656                 disk->changed = 1;
 657                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
 658                 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
 659                 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
 660                 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
 661         }
 662         return Ok;
 663 }
 664
 665 static void pd_standby_off(struct pd_unit *disk)
 666 {
 667         pd_wait_for(disk, 0, DBMSG("before STANDBY"));
 668         pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
 669         pd_wait_for(disk, 0, DBMSG("after STANDBY"));
 670 }
 671
 672 static enum action pd_identify(struct pd_unit *disk)
 673 {
 674         int j;
 675         char id[PD_ID_LEN + 1];
 676
 677 /* WARNING:  here there may be dragons.  reset() applies to both drives,
 678    but we call it only on probing the MASTER. This should allow most
 679    common configurations to work, but be warned that a reset can clear
 680    settings on the SLAVE drive.
 681 */
 682
 683         if (disk->drive == 0)
 684                 pd_reset(disk);
 685
 686         write_reg(disk, 6, DRIVE(disk));
 687         pd_wait_for(disk, 0, DBMSG("before IDENT"));
 688         pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
 689
 690         if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
 691                 return Fail;
 692         pi_read_block(disk->pi, pd_scratch, 512);
 693         disk->can_lba = pd_scratch[99] & 2;
 694         disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
 695         disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
 696         disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
 697         if (disk->can_lba)
 698                 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
 699         else
 700                 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
 701
 702         for (j = 0; j < PD_ID_LEN; j++)
 703                 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
 704         j = PD_ID_LEN - 1;
 705         while ((j >= 0) && (id[j] <= 0x20))
 706                 j--;
 707         j++;
 708         id[j] = 0;
 709
 710         disk->removable = pd_scratch[0] & 0x80;
 711
 712         printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
 713                disk->name, id,
 714                disk->drive ? "slave" : "master",
 715                disk->capacity, disk->capacity / 2048,
 716                disk->cylinders, disk->heads, disk->sectors,
 717                disk->removable ? "removable" : "fixed");
 718
 719         if (disk->capacity)
 720                 pd_init_dev_parms(disk);
 721         if (!disk->standby)
 722                 pd_standby_off(disk);
 723
 724         return Ok;
 725 }
 726
 727 /* end of io request engine */
 728
 729 static void do_pd_request(struct request_queue * q)
 730 {
 731         if (pd_req)
 732                 return;
 733         pd_req = blk_fetch_request(q);
 734         if (!pd_req)
 735                 return;
 736
 737         schedule_fsm();
 738 }
 739
 740 static int pd_special_command(struct pd_unit *disk,
 741                       enum action (*func)(struct pd_unit *disk))
 742 {
 743         struct request *rq;
 744
 745         rq = blk_get_request(disk->gd->queue, REQ_OP_DRV_IN, 0);
 746         if (IS_ERR(rq))
 747                 return PTR_ERR(rq);
 748
 749         rq->special = func;
 750         blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
 751         blk_put_request(rq);
 752         return 0;
 753 }
 754
 755 /* kernel glue structures */
 756
 757 static int pd_open(struct block_device *bdev, fmode_t mode)
 758 {
 759         struct pd_unit *disk = bdev->bd_disk->private_data;
 760
 761         mutex_lock(&pd_mutex);
 762         disk->access++;
 763
 764         if (disk->removable) {
 765                 pd_special_command(disk, pd_media_check);
 766                 pd_special_command(disk, pd_door_lock);
 767         }
 768         mutex_unlock(&pd_mutex);
 769         return 0;
 770 }
 771
 772 static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 773 {
 774         struct pd_unit *disk = bdev->bd_disk->private_data;
 775
 776         if (disk->alt_geom) {
 777                 geo->heads = PD_LOG_HEADS;
 778                 geo->sectors = PD_LOG_SECTS;
 779                 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
 780         } else {
 781                 geo->heads = disk->heads;
 782                 geo->sectors = disk->sectors;
 783                 geo->cylinders = disk->cylinders;
 784         }
 785
 786         return 0;
 787 }
 788
 789 static int pd_ioctl(struct block_device *bdev, fmode_t mode,
 790          unsigned int cmd, unsigned long arg)
 791 {
 792         struct pd_unit *disk = bdev->bd_disk->private_data;
 793
 794         switch (cmd) {
 795         case CDROMEJECT:
 796                 mutex_lock(&pd_mutex);
 797                 if (disk->access == 1)
 798                         pd_special_command(disk, pd_eject);
 799                 mutex_unlock(&pd_mutex);
 800                 return 0;
 801         default:
 802                 return -EINVAL;
 803         }
 804 }
 805
 806 static void pd_release(struct gendisk *p, fmode_t mode)
 807 {
 808         struct pd_unit *disk = p->private_data;
 809
 810         mutex_lock(&pd_mutex);
 811         if (!--disk->access && disk->removable)
 812                 pd_special_command(disk, pd_door_unlock);
 813         mutex_unlock(&pd_mutex);
 814 }
 815
 816 static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)
 817 {
 818         struct pd_unit *disk = p->private_data;
 819         int r;
 820         if (!disk->removable)
 821                 return 0;
 822         pd_special_command(disk, pd_media_check);
 823         r = disk->changed;
 824         disk->changed = 0;
 825         return r ? DISK_EVENT_MEDIA_CHANGE : 0;
 826 }
 827
 828 static int pd_revalidate(struct gendisk *p)
 829 {
 830         struct pd_unit *disk = p->private_data;
 831         if (pd_special_command(disk, pd_identify) == 0)
 832                 set_capacity(p, disk->capacity);
 833         else
 834                 set_capacity(p, 0);
 835         return 0;
 836 }
 837
 838 static const struct block_device_operations pd_fops = {
 839         .owner          = THIS_MODULE,
 840         .open           = pd_open,
 841         .release        = pd_release,
 842         .ioctl          = pd_ioctl,
 843         .getgeo         = pd_getgeo,
 844         .check_events   = pd_check_events,
 845         .revalidate_disk= pd_revalidate
 846 };
 847
 848 /* probing */
 849
 850 static void pd_probe_drive(struct pd_unit *disk)
 851 {
 852         struct gendisk *p = alloc_disk(1 << PD_BITS);
 853         if (!p)
 854                 return;
 855         strcpy(p->disk_name, disk->name);
 856         p->fops = &pd_fops;
 857         p->major = major;
 858         p->first_minor = (disk - pd) << PD_BITS;
 859         disk->gd = p;
 860         p->private_data = disk;
 861         p->queue = blk_init_queue(do_pd_request, &pd_lock);
 862         if (!p->queue) {
 863                 disk->gd = NULL;
 864                 put_disk(p);
 865                 return;
 866         }
 867         blk_queue_max_hw_sectors(p->queue, cluster);
 868         blk_queue_bounce_limit(p->queue, BLK_BOUNCE_HIGH);
 869
 870         if (disk->drive == -1) {
 871                 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
 872                         if (pd_special_command(disk, pd_identify) == 0)
 873                                 return;
 874         } else if (pd_special_command(disk, pd_identify) == 0)
 875                 return;
 876         disk->gd = NULL;
 877         put_disk(p);
 878 }
 879
 880 static int pd_detect(void)
 881 {
 882         int found = 0, unit, pd_drive_count = 0;
 883         struct pd_unit *disk;
 884
 885         for (unit = 0; unit < PD_UNITS; unit++) {
 886                 int *parm = *drives[unit];
 887                 struct pd_unit *disk = pd + unit;
 888                 disk->pi = &disk->pia;
 889                 disk->access = 0;
 890                 disk->changed = 1;
 891                 disk->capacity = 0;
 892                 disk->drive = parm[D_SLV];
 893                 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit);
 894                 disk->alt_geom = parm[D_GEO];
 895                 disk->standby = parm[D_SBY];
 896                 if (parm[D_PRT])
 897                         pd_drive_count++;
 898         }
 899
 900         par_drv = pi_register_driver(name);
 901         if (!par_drv) {
 902                 pr_err("failed to register %s driver\n", name);
 903                 return -1;
 904         }
 905
 906         if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
 907                 disk = pd;
 908                 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch,
 909                             PI_PD, verbose, disk->name)) {
 910                         pd_probe_drive(disk);
 911                         if (!disk->gd)
 912                                 pi_release(disk->pi);
 913                 }
 914
 915         } else {
 916                 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 917                         int *parm = *drives[unit];
 918                         if (!parm[D_PRT])
 919                                 continue;
 920                         if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD],
 921                                      parm[D_UNI], parm[D_PRO], parm[D_DLY],
 922                                      pd_scratch, PI_PD, verbose, disk->name)) {
 923                                 pd_probe_drive(disk);
 924                                 if (!disk->gd)
 925                                         pi_release(disk->pi);
 926                         }
 927                 }
 928         }
 929         for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 930                 if (disk->gd) {
 931                         set_capacity(disk->gd, disk->capacity);
 932                         add_disk(disk->gd);
 933                         found = 1;
 934                 }
 935         }
 936         if (!found) {
 937                 printk("%s: no valid drive found\n", name);
 938                 pi_unregister_driver(par_drv);
 939         }
 940         return found;
 941 }
 942
 943 static int __init pd_init(void)
 944 {
 945         if (disable)
 946                 goto out1;
 947
 948         if (register_blkdev(major, name))
 949                 goto out1;
 950
 951         printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 952                name, name, PD_VERSION, major, cluster, nice);
 953         if (!pd_detect())
 954                 goto out2;
 955
 956         return 0;
 957
 958 out2:
 959         unregister_blkdev(major, name);
 960 out1:
 961         return -ENODEV;
 962 }
 963
 964 static void __exit pd_exit(void)
 965 {
 966         struct pd_unit *disk;
 967         int unit;
 968         unregister_blkdev(major, name);
 969         for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 970                 struct gendisk *p = disk->gd;
 971                 if (p) {
 972                         disk->gd = NULL;
 973                         del_gendisk(p);
 974                         blk_cleanup_queue(p->queue);
 975                         put_disk(p);
 976                         pi_release(disk->pi);
 977                 }
 978         }
 979 }
 980
 981 MODULE_LICENSE("GPL");
 982 module_init(pd_init)
 983 module_exit(pd_exit)