git.oblomov.eu Git - linux-2.6/blob - 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 overide 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
 128 static int verbose = 0;
 129 static int major = PD_MAJOR;
 130 static char *name = PD_NAME;
 131 static int cluster = 64;
 132 static int nice = 0;
 133 static int disable = 0;
 134
 135 static int drive0[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 136 static int drive1[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 137 static int drive2[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 138 static int drive3[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
 139
 140 static int (*drives[4])[8] = {&drive0, &drive1, &drive2, &drive3};
 141
 142 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
 143
 144 /* end of parameters */
 145
 146 #include <linux/init.h>
 147 #include <linux/module.h>
 148 #include <linux/fs.h>
 149 #include <linux/delay.h>
 150 #include <linux/hdreg.h>
 151 #include <linux/cdrom.h>        /* for the eject ioctl */
 152 #include <linux/blkdev.h>
 153 #include <linux/blkpg.h>
 154 #include <linux/kernel.h>
 155 #include <asm/uaccess.h>
 156 #include <linux/workqueue.h>
 157
 158 static DEFINE_SPINLOCK(pd_lock);
 159
 160 module_param(verbose, bool, 0);
 161 module_param(major, int, 0);
 162 module_param(name, charp, 0);
 163 module_param(cluster, int, 0);
 164 module_param(nice, int, 0);
 165 module_param_array(drive0, int, NULL, 0);
 166 module_param_array(drive1, int, NULL, 0);
 167 module_param_array(drive2, int, NULL, 0);
 168 module_param_array(drive3, int, NULL, 0);
 169
 170 #include "paride.h"
 171
 172 #define PD_BITS    4
 173
 174 /* numbers for "SCSI" geometry */
 175
 176 #define PD_LOG_HEADS    64
 177 #define PD_LOG_SECTS    32
 178
 179 #define PD_ID_OFF       54
 180 #define PD_ID_LEN       14
 181
 182 #define PD_MAX_RETRIES  5
 183 #define PD_TMO          800     /* interrupt timeout in jiffies */
 184 #define PD_SPIN_DEL     50      /* spin delay in micro-seconds  */
 185
 186 #define PD_SPIN         (1000000*PD_TMO)/(HZ*PD_SPIN_DEL)
 187
 188 #define STAT_ERR        0x00001
 189 #define STAT_INDEX      0x00002
 190 #define STAT_ECC        0x00004
 191 #define STAT_DRQ        0x00008
 192 #define STAT_SEEK       0x00010
 193 #define STAT_WRERR      0x00020
 194 #define STAT_READY      0x00040
 195 #define STAT_BUSY       0x00080
 196
 197 #define ERR_AMNF        0x00100
 198 #define ERR_TK0NF       0x00200
 199 #define ERR_ABRT        0x00400
 200 #define ERR_MCR         0x00800
 201 #define ERR_IDNF        0x01000
 202 #define ERR_MC          0x02000
 203 #define ERR_UNC         0x04000
 204 #define ERR_TMO         0x10000
 205
 206 #define IDE_READ                0x20
 207 #define IDE_WRITE               0x30
 208 #define IDE_READ_VRFY           0x40
 209 #define IDE_INIT_DEV_PARMS      0x91
 210 #define IDE_STANDBY             0x96
 211 #define IDE_ACKCHANGE           0xdb
 212 #define IDE_DOORLOCK            0xde
 213 #define IDE_DOORUNLOCK          0xdf
 214 #define IDE_IDENTIFY            0xec
 215 #define IDE_EJECT               0xed
 216
 217 #define PD_NAMELEN      8
 218
 219 struct pd_unit {
 220         struct pi_adapter pia;  /* interface to paride layer */
 221         struct pi_adapter *pi;
 222         int access;             /* count of active opens ... */
 223         int capacity;           /* Size of this volume in sectors */
 224         int heads;              /* physical geometry */
 225         int sectors;
 226         int cylinders;
 227         int can_lba;
 228         int drive;              /* master=0 slave=1 */
 229         int changed;            /* Have we seen a disk change ? */
 230         int removable;          /* removable media device  ?  */
 231         int standby;
 232         int alt_geom;
 233         char name[PD_NAMELEN];  /* pda, pdb, etc ... */
 234         struct gendisk *gd;
 235 };
 236
 237 static struct pd_unit pd[PD_UNITS];
 238
 239 static char pd_scratch[512];    /* scratch block buffer */
 240
 241 static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
 242         "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
 243         "IDNF", "MC", "UNC", "???", "TMO"
 244 };
 245
 246 static inline int status_reg(struct pd_unit *disk)
 247 {
 248         return pi_read_regr(disk->pi, 1, 6);
 249 }
 250
 251 static inline int read_reg(struct pd_unit *disk, int reg)
 252 {
 253         return pi_read_regr(disk->pi, 0, reg);
 254 }
 255
 256 static inline void write_status(struct pd_unit *disk, int val)
 257 {
 258         pi_write_regr(disk->pi, 1, 6, val);
 259 }
 260
 261 static inline void write_reg(struct pd_unit *disk, int reg, int val)
 262 {
 263         pi_write_regr(disk->pi, 0, reg, val);
 264 }
 265
 266 static inline u8 DRIVE(struct pd_unit *disk)
 267 {
 268         return 0xa0+0x10*disk->drive;
 269 }
 270
 271 /*  ide command interface */
 272
 273 static void pd_print_error(struct pd_unit *disk, char *msg, int status)
 274 {
 275         int i;
 276
 277         printk("%s: %s: status = 0x%x =", disk->name, msg, status);
 278         for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
 279                 if (status & (1 << i))
 280                         printk(" %s", pd_errs[i]);
 281         printk("\n");
 282 }
 283
 284 static void pd_reset(struct pd_unit *disk)
 285 {                               /* called only for MASTER drive */
 286         write_status(disk, 4);
 287         udelay(50);
 288         write_status(disk, 0);
 289         udelay(250);
 290 }
 291
 292 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 293
 294 static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
 295 {                               /* polled wait */
 296         int k, r, e;
 297
 298         k = 0;
 299         while (k < PD_SPIN) {
 300                 r = status_reg(disk);
 301                 k++;
 302                 if (((r & w) == w) && !(r & STAT_BUSY))
 303                         break;
 304                 udelay(PD_SPIN_DEL);
 305         }
 306         e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
 307         if (k >= PD_SPIN)
 308                 e |= ERR_TMO;
 309         if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
 310                 pd_print_error(disk, msg, e);
 311         return e;
 312 }
 313
 314 static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
 315 {
 316         write_reg(disk, 6, DRIVE(disk) + h);
 317         write_reg(disk, 1, 0);          /* the IDE task file */
 318         write_reg(disk, 2, n);
 319         write_reg(disk, 3, s);
 320         write_reg(disk, 4, c0);
 321         write_reg(disk, 5, c1);
 322         write_reg(disk, 7, func);
 323
 324         udelay(1);
 325 }
 326
 327 static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
 328 {
 329         int c1, c0, h, s;
 330
 331         if (disk->can_lba) {
 332                 s = block & 255;
 333                 c0 = (block >>= 8) & 255;
 334                 c1 = (block >>= 8) & 255;
 335                 h = ((block >>= 8) & 15) + 0x40;
 336         } else {
 337                 s = (block % disk->sectors) + 1;
 338                 h = (block /= disk->sectors) % disk->heads;
 339                 c0 = (block /= disk->heads) % 256;
 340                 c1 = (block >>= 8);
 341         }
 342         pd_send_command(disk, count, s, h, c0, c1, func);
 343 }
 344
 345 /* The i/o request engine */
 346
 347 enum action {Fail = 0, Ok = 1, Hold, Wait};
 348
 349 static struct request *pd_req;  /* current request */
 350 static enum action (*phase)(void);
 351
 352 static void run_fsm(void);
 353
 354 static void ps_tq_int(struct work_struct *work);
 355
 356 static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
 357
 358 static void schedule_fsm(void)
 359 {
 360         if (!nice)
 361                 schedule_delayed_work(&fsm_tq, 0);
 362         else
 363                 schedule_delayed_work(&fsm_tq, nice-1);
 364 }
 365
 366 static void ps_tq_int(struct work_struct *work)
 367 {
 368         run_fsm();
 369 }
 370
 371 static enum action do_pd_io_start(void);
 372 static enum action pd_special(void);
 373 static enum action do_pd_read_start(void);
 374 static enum action do_pd_write_start(void);
 375 static enum action do_pd_read_drq(void);
 376 static enum action do_pd_write_done(void);
 377
 378 static struct request_queue *pd_queue;
 379 static int pd_claimed;
 380
 381 static struct pd_unit *pd_current; /* current request's drive */
 382 static PIA *pi_current; /* current request's PIA */
 383
 384 static void run_fsm(void)
 385 {
 386         while (1) {
 387                 enum action res;
 388                 unsigned long saved_flags;
 389                 int stop = 0;
 390
 391                 if (!phase) {
 392                         pd_current = pd_req->rq_disk->private_data;
 393                         pi_current = pd_current->pi;
 394                         phase = do_pd_io_start;
 395                 }
 396
 397                 switch (pd_claimed) {
 398                         case 0:
 399                                 pd_claimed = 1;
 400                                 if (!pi_schedule_claimed(pi_current, run_fsm))
 401                                         return;
 402                         case 1:
 403                                 pd_claimed = 2;
 404                                 pi_current->proto->connect(pi_current);
 405                 }
 406
 407                 switch(res = phase()) {
 408                         case Ok: case Fail:
 409                                 pi_disconnect(pi_current);
 410                                 pd_claimed = 0;
 411                                 phase = NULL;
 412                                 spin_lock_irqsave(&pd_lock, saved_flags);
 413                                 if (!__blk_end_request_cur(pd_req,
 414                                                 res == Ok ? 0 : -EIO)) {
 415                                         pd_req = elv_next_request(pd_queue);
 416                                         if (!pd_req)
 417                                                 stop = 1;
 418                                         else
 419                                                 blkdev_dequeue_request(pd_req);
 420                                 }
 421                                 spin_unlock_irqrestore(&pd_lock, saved_flags);
 422                                 if (stop)
 423                                         return;
 424                         case Hold:
 425                                 schedule_fsm();
 426                                 return;
 427                         case Wait:
 428                                 pi_disconnect(pi_current);
 429                                 pd_claimed = 0;
 430                 }
 431         }
 432 }
 433
 434 static int pd_retries = 0;      /* i/o error retry count */
 435 static int pd_block;            /* address of next requested block */
 436 static int pd_count;            /* number of blocks still to do */
 437 static int pd_run;              /* sectors in current cluster */
 438 static int pd_cmd;              /* current command READ/WRITE */
 439 static char *pd_buf;            /* buffer for request in progress */
 440
 441 static enum action do_pd_io_start(void)
 442 {
 443         if (blk_special_request(pd_req)) {
 444                 phase = pd_special;
 445                 return pd_special();
 446         }
 447
 448         pd_cmd = rq_data_dir(pd_req);
 449         if (pd_cmd == READ || pd_cmd == WRITE) {
 450                 pd_block = blk_rq_pos(pd_req);
 451                 pd_count = blk_rq_cur_sectors(pd_req);
 452                 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
 453                         return Fail;
 454                 pd_run = blk_rq_sectors(pd_req);
 455                 pd_buf = pd_req->buffer;
 456                 pd_retries = 0;
 457                 if (pd_cmd == READ)
 458                         return do_pd_read_start();
 459                 else
 460                         return do_pd_write_start();
 461         }
 462         return Fail;
 463 }
 464
 465 static enum action pd_special(void)
 466 {
 467         enum action (*func)(struct pd_unit *) = pd_req->special;
 468         return func(pd_current);
 469 }
 470
 471 static int pd_next_buf(void)
 472 {
 473         unsigned long saved_flags;
 474
 475         pd_count--;
 476         pd_run--;
 477         pd_buf += 512;
 478         pd_block++;
 479         if (!pd_run)
 480                 return 1;
 481         if (pd_count)
 482                 return 0;
 483         spin_lock_irqsave(&pd_lock, saved_flags);
 484         __blk_end_request_cur(pd_req, 0);
 485         pd_count = blk_rq_cur_sectors(pd_req);
 486         pd_buf = pd_req->buffer;
 487         spin_unlock_irqrestore(&pd_lock, saved_flags);
 488         return 0;
 489 }
 490
 491 static unsigned long pd_timeout;
 492
 493 static enum action do_pd_read_start(void)
 494 {
 495         if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
 496                 if (pd_retries < PD_MAX_RETRIES) {
 497                         pd_retries++;
 498                         return Wait;
 499                 }
 500                 return Fail;
 501         }
 502         pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
 503         phase = do_pd_read_drq;
 504         pd_timeout = jiffies + PD_TMO;
 505         return Hold;
 506 }
 507
 508 static enum action do_pd_write_start(void)
 509 {
 510         if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
 511                 if (pd_retries < PD_MAX_RETRIES) {
 512                         pd_retries++;
 513                         return Wait;
 514                 }
 515                 return Fail;
 516         }
 517         pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
 518         while (1) {
 519                 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
 520                         if (pd_retries < PD_MAX_RETRIES) {
 521                                 pd_retries++;
 522                                 return Wait;
 523                         }
 524                         return Fail;
 525                 }
 526                 pi_write_block(pd_current->pi, pd_buf, 512);
 527                 if (pd_next_buf())
 528                         break;
 529         }
 530         phase = do_pd_write_done;
 531         pd_timeout = jiffies + PD_TMO;
 532         return Hold;
 533 }
 534
 535 static inline int pd_ready(void)
 536 {
 537         return !(status_reg(pd_current) & STAT_BUSY);
 538 }
 539
 540 static enum action do_pd_read_drq(void)
 541 {
 542         if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
 543                 return Hold;
 544
 545         while (1) {
 546                 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
 547                         if (pd_retries < PD_MAX_RETRIES) {
 548                                 pd_retries++;
 549                                 phase = do_pd_read_start;
 550                                 return Wait;
 551                         }
 552                         return Fail;
 553                 }
 554                 pi_read_block(pd_current->pi, pd_buf, 512);
 555                 if (pd_next_buf())
 556                         break;
 557         }
 558         return Ok;
 559 }
 560
 561 static enum action do_pd_write_done(void)
 562 {
 563         if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
 564                 return Hold;
 565
 566         if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
 567                 if (pd_retries < PD_MAX_RETRIES) {
 568                         pd_retries++;
 569                         phase = do_pd_write_start;
 570                         return Wait;
 571                 }
 572                 return Fail;
 573         }
 574         return Ok;
 575 }
 576
 577 /* special io requests */
 578
 579 /* According to the ATA standard, the default CHS geometry should be
 580    available following a reset.  Some Western Digital drives come up
 581    in a mode where only LBA addresses are accepted until the device
 582    parameters are initialised.
 583 */
 584
 585 static void pd_init_dev_parms(struct pd_unit *disk)
 586 {
 587         pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
 588         pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
 589                         IDE_INIT_DEV_PARMS);
 590         udelay(300);
 591         pd_wait_for(disk, 0, "Initialise device parameters");
 592 }
 593
 594 static enum action pd_door_lock(struct pd_unit *disk)
 595 {
 596         if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
 597                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
 598                 pd_wait_for(disk, STAT_READY, "Lock done");
 599         }
 600         return Ok;
 601 }
 602
 603 static enum action pd_door_unlock(struct pd_unit *disk)
 604 {
 605         if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
 606                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
 607                 pd_wait_for(disk, STAT_READY, "Lock done");
 608         }
 609         return Ok;
 610 }
 611
 612 static enum action pd_eject(struct pd_unit *disk)
 613 {
 614         pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
 615         pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
 616         pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
 617         pd_wait_for(disk, 0, DBMSG("before eject"));
 618         pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
 619         pd_wait_for(disk, 0, DBMSG("after eject"));
 620         return Ok;
 621 }
 622
 623 static enum action pd_media_check(struct pd_unit *disk)
 624 {
 625         int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
 626         if (!(r & STAT_ERR)) {
 627                 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
 628                 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
 629         } else
 630                 disk->changed = 1;      /* say changed if other error */
 631         if (r & ERR_MC) {
 632                 disk->changed = 1;
 633                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
 634                 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
 635                 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
 636                 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
 637         }
 638         return Ok;
 639 }
 640
 641 static void pd_standby_off(struct pd_unit *disk)
 642 {
 643         pd_wait_for(disk, 0, DBMSG("before STANDBY"));
 644         pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
 645         pd_wait_for(disk, 0, DBMSG("after STANDBY"));
 646 }
 647
 648 static enum action pd_identify(struct pd_unit *disk)
 649 {
 650         int j;
 651         char id[PD_ID_LEN + 1];
 652
 653 /* WARNING:  here there may be dragons.  reset() applies to both drives,
 654    but we call it only on probing the MASTER. This should allow most
 655    common configurations to work, but be warned that a reset can clear
 656    settings on the SLAVE drive.
 657 */
 658
 659         if (disk->drive == 0)
 660                 pd_reset(disk);
 661
 662         write_reg(disk, 6, DRIVE(disk));
 663         pd_wait_for(disk, 0, DBMSG("before IDENT"));
 664         pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
 665
 666         if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
 667                 return Fail;
 668         pi_read_block(disk->pi, pd_scratch, 512);
 669         disk->can_lba = pd_scratch[99] & 2;
 670         disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
 671         disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
 672         disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
 673         if (disk->can_lba)
 674                 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
 675         else
 676                 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
 677
 678         for (j = 0; j < PD_ID_LEN; j++)
 679                 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
 680         j = PD_ID_LEN - 1;
 681         while ((j >= 0) && (id[j] <= 0x20))
 682                 j--;
 683         j++;
 684         id[j] = 0;
 685
 686         disk->removable = pd_scratch[0] & 0x80;
 687
 688         printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
 689                disk->name, id,
 690                disk->drive ? "slave" : "master",
 691                disk->capacity, disk->capacity / 2048,
 692                disk->cylinders, disk->heads, disk->sectors,
 693                disk->removable ? "removable" : "fixed");
 694
 695         if (disk->capacity)
 696                 pd_init_dev_parms(disk);
 697         if (!disk->standby)
 698                 pd_standby_off(disk);
 699
 700         return Ok;
 701 }
 702
 703 /* end of io request engine */
 704
 705 static void do_pd_request(struct request_queue * q)
 706 {
 707         if (pd_req)
 708                 return;
 709         pd_req = elv_next_request(q);
 710         if (!pd_req)
 711                 return;
 712         blkdev_dequeue_request(pd_req);
 713
 714         schedule_fsm();
 715 }
 716
 717 static int pd_special_command(struct pd_unit *disk,
 718                       enum action (*func)(struct pd_unit *disk))
 719 {
 720         struct request *rq;
 721         int err = 0;
 722
 723         rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
 724
 725         rq->cmd_type = REQ_TYPE_SPECIAL;
 726         rq->special = func;
 727
 728         err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
 729
 730         blk_put_request(rq);
 731         return err;
 732 }
 733
 734 /* kernel glue structures */
 735
 736 static int pd_open(struct block_device *bdev, fmode_t mode)
 737 {
 738         struct pd_unit *disk = bdev->bd_disk->private_data;
 739
 740         disk->access++;
 741
 742         if (disk->removable) {
 743                 pd_special_command(disk, pd_media_check);
 744                 pd_special_command(disk, pd_door_lock);
 745         }
 746         return 0;
 747 }
 748
 749 static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 750 {
 751         struct pd_unit *disk = bdev->bd_disk->private_data;
 752
 753         if (disk->alt_geom) {
 754                 geo->heads = PD_LOG_HEADS;
 755                 geo->sectors = PD_LOG_SECTS;
 756                 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
 757         } else {
 758                 geo->heads = disk->heads;
 759                 geo->sectors = disk->sectors;
 760                 geo->cylinders = disk->cylinders;
 761         }
 762
 763         return 0;
 764 }
 765
 766 static int pd_ioctl(struct block_device *bdev, fmode_t mode,
 767          unsigned int cmd, unsigned long arg)
 768 {
 769         struct pd_unit *disk = bdev->bd_disk->private_data;
 770
 771         switch (cmd) {
 772         case CDROMEJECT:
 773                 if (disk->access == 1)
 774                         pd_special_command(disk, pd_eject);
 775                 return 0;
 776         default:
 777                 return -EINVAL;
 778         }
 779 }
 780
 781 static int pd_release(struct gendisk *p, fmode_t mode)
 782 {
 783         struct pd_unit *disk = p->private_data;
 784
 785         if (!--disk->access && disk->removable)
 786                 pd_special_command(disk, pd_door_unlock);
 787
 788         return 0;
 789 }
 790
 791 static int pd_check_media(struct gendisk *p)
 792 {
 793         struct pd_unit *disk = p->private_data;
 794         int r;
 795         if (!disk->removable)
 796                 return 0;
 797         pd_special_command(disk, pd_media_check);
 798         r = disk->changed;
 799         disk->changed = 0;
 800         return r;
 801 }
 802
 803 static int pd_revalidate(struct gendisk *p)
 804 {
 805         struct pd_unit *disk = p->private_data;
 806         if (pd_special_command(disk, pd_identify) == 0)
 807                 set_capacity(p, disk->capacity);
 808         else
 809                 set_capacity(p, 0);
 810         return 0;
 811 }
 812
 813 static struct block_device_operations pd_fops = {
 814         .owner          = THIS_MODULE,
 815         .open           = pd_open,
 816         .release        = pd_release,
 817         .locked_ioctl   = pd_ioctl,
 818         .getgeo         = pd_getgeo,
 819         .media_changed  = pd_check_media,
 820         .revalidate_disk= pd_revalidate
 821 };
 822
 823 /* probing */
 824
 825 static void pd_probe_drive(struct pd_unit *disk)
 826 {
 827         struct gendisk *p = alloc_disk(1 << PD_BITS);
 828         if (!p)
 829                 return;
 830         strcpy(p->disk_name, disk->name);
 831         p->fops = &pd_fops;
 832         p->major = major;
 833         p->first_minor = (disk - pd) << PD_BITS;
 834         disk->gd = p;
 835         p->private_data = disk;
 836         p->queue = pd_queue;
 837
 838         if (disk->drive == -1) {
 839                 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
 840                         if (pd_special_command(disk, pd_identify) == 0)
 841                                 return;
 842         } else if (pd_special_command(disk, pd_identify) == 0)
 843                 return;
 844         disk->gd = NULL;
 845         put_disk(p);
 846 }
 847
 848 static int pd_detect(void)
 849 {
 850         int found = 0, unit, pd_drive_count = 0;
 851         struct pd_unit *disk;
 852
 853         for (unit = 0; unit < PD_UNITS; unit++) {
 854                 int *parm = *drives[unit];
 855                 struct pd_unit *disk = pd + unit;
 856                 disk->pi = &disk->pia;
 857                 disk->access = 0;
 858                 disk->changed = 1;
 859                 disk->capacity = 0;
 860                 disk->drive = parm[D_SLV];
 861                 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit);
 862                 disk->alt_geom = parm[D_GEO];
 863                 disk->standby = parm[D_SBY];
 864                 if (parm[D_PRT])
 865                         pd_drive_count++;
 866         }
 867
 868         if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
 869                 disk = pd;
 870                 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch,
 871                             PI_PD, verbose, disk->name)) {
 872                         pd_probe_drive(disk);
 873                         if (!disk->gd)
 874                                 pi_release(disk->pi);
 875                 }
 876
 877         } else {
 878                 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 879                         int *parm = *drives[unit];
 880                         if (!parm[D_PRT])
 881                                 continue;
 882                         if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD],
 883                                      parm[D_UNI], parm[D_PRO], parm[D_DLY],
 884                                      pd_scratch, PI_PD, verbose, disk->name)) {
 885                                 pd_probe_drive(disk);
 886                                 if (!disk->gd)
 887                                         pi_release(disk->pi);
 888                         }
 889                 }
 890         }
 891         for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 892                 if (disk->gd) {
 893                         set_capacity(disk->gd, disk->capacity);
 894                         add_disk(disk->gd);
 895                         found = 1;
 896                 }
 897         }
 898         if (!found)
 899                 printk("%s: no valid drive found\n", name);
 900         return found;
 901 }
 902
 903 static int __init pd_init(void)
 904 {
 905         if (disable)
 906                 goto out1;
 907
 908         pd_queue = blk_init_queue(do_pd_request, &pd_lock);
 909         if (!pd_queue)
 910                 goto out1;
 911
 912         blk_queue_max_sectors(pd_queue, cluster);
 913
 914         if (register_blkdev(major, name))
 915                 goto out2;
 916
 917         printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 918                name, name, PD_VERSION, major, cluster, nice);
 919         if (!pd_detect())
 920                 goto out3;
 921
 922         return 0;
 923
 924 out3:
 925         unregister_blkdev(major, name);
 926 out2:
 927         blk_cleanup_queue(pd_queue);
 928 out1:
 929         return -ENODEV;
 930 }
 931
 932 static void __exit pd_exit(void)
 933 {
 934         struct pd_unit *disk;
 935         int unit;
 936         unregister_blkdev(major, name);
 937         for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 938                 struct gendisk *p = disk->gd;
 939                 if (p) {
 940                         disk->gd = NULL;
 941                         del_gendisk(p);
 942                         put_disk(p);
 943                         pi_release(disk->pi);
 944                 }
 945         }
 946         blk_cleanup_queue(pd_queue);
 947 }
 948
 949 MODULE_LICENSE("GPL");
 950 module_init(pd_init)
 951 module_exit(pd_exit)