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/blk-mq.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         struct blk_mq_tag_set tag_set;
 240         struct list_head rq_list;
 241 };
 242
 243 static struct pd_unit pd[PD_UNITS];
 244
 245 struct pd_req {
 246         /* for REQ_OP_DRV_IN: */
 247         enum action (*func)(struct pd_unit *disk);
 248 };
 249
 250 static char pd_scratch[512];    /* scratch block buffer */
 251
 252 static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
 253         "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
 254         "IDNF", "MC", "UNC", "???", "TMO"
 255 };
 256
 257 static void *par_drv;           /* reference of parport driver */
 258
 259 static inline int status_reg(struct pd_unit *disk)
 260 {
 261         return pi_read_regr(disk->pi, 1, 6);
 262 }
 263
 264 static inline int read_reg(struct pd_unit *disk, int reg)
 265 {
 266         return pi_read_regr(disk->pi, 0, reg);
 267 }
 268
 269 static inline void write_status(struct pd_unit *disk, int val)
 270 {
 271         pi_write_regr(disk->pi, 1, 6, val);
 272 }
 273
 274 static inline void write_reg(struct pd_unit *disk, int reg, int val)
 275 {
 276         pi_write_regr(disk->pi, 0, reg, val);
 277 }
 278
 279 static inline u8 DRIVE(struct pd_unit *disk)
 280 {
 281         return 0xa0+0x10*disk->drive;
 282 }
 283
 284 /*  ide command interface */
 285
 286 static void pd_print_error(struct pd_unit *disk, char *msg, int status)
 287 {
 288         int i;
 289
 290         printk("%s: %s: status = 0x%x =", disk->name, msg, status);
 291         for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
 292                 if (status & (1 << i))
 293                         printk(" %s", pd_errs[i]);
 294         printk("\n");
 295 }
 296
 297 static void pd_reset(struct pd_unit *disk)
 298 {                               /* called only for MASTER drive */
 299         write_status(disk, 4);
 300         udelay(50);
 301         write_status(disk, 0);
 302         udelay(250);
 303 }
 304
 305 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 306
 307 static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
 308 {                               /* polled wait */
 309         int k, r, e;
 310
 311         k = 0;
 312         while (k < PD_SPIN) {
 313                 r = status_reg(disk);
 314                 k++;
 315                 if (((r & w) == w) && !(r & STAT_BUSY))
 316                         break;
 317                 udelay(PD_SPIN_DEL);
 318         }
 319         e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
 320         if (k >= PD_SPIN)
 321                 e |= ERR_TMO;
 322         if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
 323                 pd_print_error(disk, msg, e);
 324         return e;
 325 }
 326
 327 static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
 328 {
 329         write_reg(disk, 6, DRIVE(disk) + h);
 330         write_reg(disk, 1, 0);          /* the IDE task file */
 331         write_reg(disk, 2, n);
 332         write_reg(disk, 3, s);
 333         write_reg(disk, 4, c0);
 334         write_reg(disk, 5, c1);
 335         write_reg(disk, 7, func);
 336
 337         udelay(1);
 338 }
 339
 340 static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
 341 {
 342         int c1, c0, h, s;
 343
 344         if (disk->can_lba) {
 345                 s = block & 255;
 346                 c0 = (block >>= 8) & 255;
 347                 c1 = (block >>= 8) & 255;
 348                 h = ((block >>= 8) & 15) + 0x40;
 349         } else {
 350                 s = (block % disk->sectors) + 1;
 351                 h = (block /= disk->sectors) % disk->heads;
 352                 c0 = (block /= disk->heads) % 256;
 353                 c1 = (block >>= 8);
 354         }
 355         pd_send_command(disk, count, s, h, c0, c1, func);
 356 }
 357
 358 /* The i/o request engine */
 359
 360 enum action {Fail = 0, Ok = 1, Hold, Wait};
 361
 362 static struct request *pd_req;  /* current request */
 363 static enum action (*phase)(void);
 364
 365 static void run_fsm(void);
 366
 367 static void ps_tq_int(struct work_struct *work);
 368
 369 static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
 370
 371 static void schedule_fsm(void)
 372 {
 373         if (!nice)
 374                 schedule_delayed_work(&fsm_tq, 0);
 375         else
 376                 schedule_delayed_work(&fsm_tq, nice-1);
 377 }
 378
 379 static void ps_tq_int(struct work_struct *work)
 380 {
 381         run_fsm();
 382 }
 383
 384 static enum action do_pd_io_start(void);
 385 static enum action pd_special(void);
 386 static enum action do_pd_read_start(void);
 387 static enum action do_pd_write_start(void);
 388 static enum action do_pd_read_drq(void);
 389 static enum action do_pd_write_done(void);
 390
 391 static int pd_queue;
 392 static int pd_claimed;
 393
 394 static struct pd_unit *pd_current; /* current request's drive */
 395 static PIA *pi_current; /* current request's PIA */
 396
 397 static int set_next_request(void)
 398 {
 399         struct gendisk *disk;
 400         struct request_queue *q;
 401         int old_pos = pd_queue;
 402
 403         do {
 404                 disk = pd[pd_queue].gd;
 405                 q = disk ? disk->queue : NULL;
 406                 if (++pd_queue == PD_UNITS)
 407                         pd_queue = 0;
 408                 if (q) {
 409                         struct pd_unit *disk = q->queuedata;
 410
 411                         if (list_empty(&disk->rq_list))
 412                                 continue;
 413
 414                         pd_req = list_first_entry(&disk->rq_list,
 415                                                         struct request,
 416                                                         queuelist);
 417                         list_del_init(&pd_req->queuelist);
 418                         blk_mq_start_request(pd_req);
 419                         break;
 420                 }
 421         } while (pd_queue != old_pos);
 422
 423         return pd_req != NULL;
 424 }
 425
 426 static void run_fsm(void)
 427 {
 428         while (1) {
 429                 enum action res;
 430                 int stop = 0;
 431
 432                 if (!phase) {
 433                         pd_current = pd_req->q->disk->private_data;
 434                         pi_current = pd_current->pi;
 435                         phase = do_pd_io_start;
 436                 }
 437
 438                 switch (pd_claimed) {
 439                         case 0:
 440                                 pd_claimed = 1;
 441                                 if (!pi_schedule_claimed(pi_current, run_fsm))
 442                                         return;
 443                                 fallthrough;
 444                         case 1:
 445                                 pd_claimed = 2;
 446                                 pi_current->proto->connect(pi_current);
 447                 }
 448
 449                 switch(res = phase()) {
 450                         case Ok: case Fail: {
 451                                 blk_status_t err;
 452
 453                                 err = res == Ok ? 0 : BLK_STS_IOERR;
 454                                 pi_disconnect(pi_current);
 455                                 pd_claimed = 0;
 456                                 phase = NULL;
 457                                 spin_lock_irq(&pd_lock);
 458                                 if (!blk_update_request(pd_req, err,
 459                                                 blk_rq_cur_bytes(pd_req))) {
 460                                         __blk_mq_end_request(pd_req, err);
 461                                         pd_req = NULL;
 462                                         stop = !set_next_request();
 463                                 }
 464                                 spin_unlock_irq(&pd_lock);
 465                                 if (stop)
 466                                         return;
 467                                 }
 468                                 fallthrough;
 469                         case Hold:
 470                                 schedule_fsm();
 471                                 return;
 472                         case Wait:
 473                                 pi_disconnect(pi_current);
 474                                 pd_claimed = 0;
 475                 }
 476         }
 477 }
 478
 479 static int pd_retries = 0;      /* i/o error retry count */
 480 static int pd_block;            /* address of next requested block */
 481 static int pd_count;            /* number of blocks still to do */
 482 static int pd_run;              /* sectors in current cluster */
 483 static char *pd_buf;            /* buffer for request in progress */
 484
 485 static enum action do_pd_io_start(void)
 486 {
 487         switch (req_op(pd_req)) {
 488         case REQ_OP_DRV_IN:
 489                 phase = pd_special;
 490                 return pd_special();
 491         case REQ_OP_READ:
 492         case REQ_OP_WRITE:
 493                 pd_block = blk_rq_pos(pd_req);
 494                 pd_count = blk_rq_cur_sectors(pd_req);
 495                 if (pd_block + pd_count > get_capacity(pd_req->q->disk))
 496                         return Fail;
 497                 pd_run = blk_rq_sectors(pd_req);
 498                 pd_buf = bio_data(pd_req->bio);
 499                 pd_retries = 0;
 500                 if (req_op(pd_req) == REQ_OP_READ)
 501                         return do_pd_read_start();
 502                 else
 503                         return do_pd_write_start();
 504         default:
 505                 break;
 506         }
 507         return Fail;
 508 }
 509
 510 static enum action pd_special(void)
 511 {
 512         struct pd_req *req = blk_mq_rq_to_pdu(pd_req);
 513
 514         return req->func(pd_current);
 515 }
 516
 517 static int pd_next_buf(void)
 518 {
 519         unsigned long saved_flags;
 520
 521         pd_count--;
 522         pd_run--;
 523         pd_buf += 512;
 524         pd_block++;
 525         if (!pd_run)
 526                 return 1;
 527         if (pd_count)
 528                 return 0;
 529         spin_lock_irqsave(&pd_lock, saved_flags);
 530         if (!blk_update_request(pd_req, 0, blk_rq_cur_bytes(pd_req))) {
 531                 __blk_mq_end_request(pd_req, 0);
 532                 pd_req = NULL;
 533                 pd_count = 0;
 534                 pd_buf = NULL;
 535         } else {
 536                 pd_count = blk_rq_cur_sectors(pd_req);
 537                 pd_buf = bio_data(pd_req->bio);
 538         }
 539         spin_unlock_irqrestore(&pd_lock, saved_flags);
 540         return !pd_count;
 541 }
 542
 543 static unsigned long pd_timeout;
 544
 545 static enum action do_pd_read_start(void)
 546 {
 547         if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
 548                 if (pd_retries < PD_MAX_RETRIES) {
 549                         pd_retries++;
 550                         return Wait;
 551                 }
 552                 return Fail;
 553         }
 554         pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
 555         phase = do_pd_read_drq;
 556         pd_timeout = jiffies + PD_TMO;
 557         return Hold;
 558 }
 559
 560 static enum action do_pd_write_start(void)
 561 {
 562         if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
 563                 if (pd_retries < PD_MAX_RETRIES) {
 564                         pd_retries++;
 565                         return Wait;
 566                 }
 567                 return Fail;
 568         }
 569         pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
 570         while (1) {
 571                 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
 572                         if (pd_retries < PD_MAX_RETRIES) {
 573                                 pd_retries++;
 574                                 return Wait;
 575                         }
 576                         return Fail;
 577                 }
 578                 pi_write_block(pd_current->pi, pd_buf, 512);
 579                 if (pd_next_buf())
 580                         break;
 581         }
 582         phase = do_pd_write_done;
 583         pd_timeout = jiffies + PD_TMO;
 584         return Hold;
 585 }
 586
 587 static inline int pd_ready(void)
 588 {
 589         return !(status_reg(pd_current) & STAT_BUSY);
 590 }
 591
 592 static enum action do_pd_read_drq(void)
 593 {
 594         if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
 595                 return Hold;
 596
 597         while (1) {
 598                 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
 599                         if (pd_retries < PD_MAX_RETRIES) {
 600                                 pd_retries++;
 601                                 phase = do_pd_read_start;
 602                                 return Wait;
 603                         }
 604                         return Fail;
 605                 }
 606                 pi_read_block(pd_current->pi, pd_buf, 512);
 607                 if (pd_next_buf())
 608                         break;
 609         }
 610         return Ok;
 611 }
 612
 613 static enum action do_pd_write_done(void)
 614 {
 615         if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
 616                 return Hold;
 617
 618         if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
 619                 if (pd_retries < PD_MAX_RETRIES) {
 620                         pd_retries++;
 621                         phase = do_pd_write_start;
 622                         return Wait;
 623                 }
 624                 return Fail;
 625         }
 626         return Ok;
 627 }
 628
 629 /* special io requests */
 630
 631 /* According to the ATA standard, the default CHS geometry should be
 632    available following a reset.  Some Western Digital drives come up
 633    in a mode where only LBA addresses are accepted until the device
 634    parameters are initialised.
 635 */
 636
 637 static void pd_init_dev_parms(struct pd_unit *disk)
 638 {
 639         pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
 640         pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
 641                         IDE_INIT_DEV_PARMS);
 642         udelay(300);
 643         pd_wait_for(disk, 0, "Initialise device parameters");
 644 }
 645
 646 static enum action pd_door_lock(struct pd_unit *disk)
 647 {
 648         if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
 649                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
 650                 pd_wait_for(disk, STAT_READY, "Lock done");
 651         }
 652         return Ok;
 653 }
 654
 655 static enum action pd_door_unlock(struct pd_unit *disk)
 656 {
 657         if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
 658                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
 659                 pd_wait_for(disk, STAT_READY, "Lock done");
 660         }
 661         return Ok;
 662 }
 663
 664 static enum action pd_eject(struct pd_unit *disk)
 665 {
 666         pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
 667         pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
 668         pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
 669         pd_wait_for(disk, 0, DBMSG("before eject"));
 670         pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
 671         pd_wait_for(disk, 0, DBMSG("after eject"));
 672         return Ok;
 673 }
 674
 675 static enum action pd_media_check(struct pd_unit *disk)
 676 {
 677         int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
 678         if (!(r & STAT_ERR)) {
 679                 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
 680                 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
 681         } else
 682                 disk->changed = 1;      /* say changed if other error */
 683         if (r & ERR_MC) {
 684                 disk->changed = 1;
 685                 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
 686                 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
 687                 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
 688                 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
 689         }
 690         return Ok;
 691 }
 692
 693 static void pd_standby_off(struct pd_unit *disk)
 694 {
 695         pd_wait_for(disk, 0, DBMSG("before STANDBY"));
 696         pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
 697         pd_wait_for(disk, 0, DBMSG("after STANDBY"));
 698 }
 699
 700 static enum action pd_identify(struct pd_unit *disk)
 701 {
 702         int j;
 703         char id[PD_ID_LEN + 1];
 704
 705 /* WARNING:  here there may be dragons.  reset() applies to both drives,
 706    but we call it only on probing the MASTER. This should allow most
 707    common configurations to work, but be warned that a reset can clear
 708    settings on the SLAVE drive.
 709 */
 710
 711         if (disk->drive == 0)
 712                 pd_reset(disk);
 713
 714         write_reg(disk, 6, DRIVE(disk));
 715         pd_wait_for(disk, 0, DBMSG("before IDENT"));
 716         pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
 717
 718         if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
 719                 return Fail;
 720         pi_read_block(disk->pi, pd_scratch, 512);
 721         disk->can_lba = pd_scratch[99] & 2;
 722         disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
 723         disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
 724         disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
 725         if (disk->can_lba)
 726                 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
 727         else
 728                 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
 729
 730         for (j = 0; j < PD_ID_LEN; j++)
 731                 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
 732         j = PD_ID_LEN - 1;
 733         while ((j >= 0) && (id[j] <= 0x20))
 734                 j--;
 735         j++;
 736         id[j] = 0;
 737
 738         disk->removable = pd_scratch[0] & 0x80;
 739
 740         printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
 741                disk->name, id,
 742                disk->drive ? "slave" : "master",
 743                disk->capacity, disk->capacity / 2048,
 744                disk->cylinders, disk->heads, disk->sectors,
 745                disk->removable ? "removable" : "fixed");
 746
 747         if (disk->capacity)
 748                 pd_init_dev_parms(disk);
 749         if (!disk->standby)
 750                 pd_standby_off(disk);
 751
 752         return Ok;
 753 }
 754
 755 /* end of io request engine */
 756
 757 static blk_status_t pd_queue_rq(struct blk_mq_hw_ctx *hctx,
 758                                 const struct blk_mq_queue_data *bd)
 759 {
 760         struct pd_unit *disk = hctx->queue->queuedata;
 761
 762         spin_lock_irq(&pd_lock);
 763         if (!pd_req) {
 764                 pd_req = bd->rq;
 765                 blk_mq_start_request(pd_req);
 766         } else
 767                 list_add_tail(&bd->rq->queuelist, &disk->rq_list);
 768         spin_unlock_irq(&pd_lock);
 769
 770         run_fsm();
 771         return BLK_STS_OK;
 772 }
 773
 774 static int pd_special_command(struct pd_unit *disk,
 775                       enum action (*func)(struct pd_unit *disk))
 776 {
 777         struct request *rq;
 778         struct pd_req *req;
 779
 780         rq = blk_mq_alloc_request(disk->gd->queue, REQ_OP_DRV_IN, 0);
 781         if (IS_ERR(rq))
 782                 return PTR_ERR(rq);
 783         req = blk_mq_rq_to_pdu(rq);
 784
 785         req->func = func;
 786         blk_execute_rq(rq, false);
 787         blk_mq_free_request(rq);
 788         return 0;
 789 }
 790
 791 /* kernel glue structures */
 792
 793 static int pd_open(struct block_device *bdev, fmode_t mode)
 794 {
 795         struct pd_unit *disk = bdev->bd_disk->private_data;
 796
 797         mutex_lock(&pd_mutex);
 798         disk->access++;
 799
 800         if (disk->removable) {
 801                 pd_special_command(disk, pd_media_check);
 802                 pd_special_command(disk, pd_door_lock);
 803         }
 804         mutex_unlock(&pd_mutex);
 805         return 0;
 806 }
 807
 808 static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 809 {
 810         struct pd_unit *disk = bdev->bd_disk->private_data;
 811
 812         if (disk->alt_geom) {
 813                 geo->heads = PD_LOG_HEADS;
 814                 geo->sectors = PD_LOG_SECTS;
 815                 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
 816         } else {
 817                 geo->heads = disk->heads;
 818                 geo->sectors = disk->sectors;
 819                 geo->cylinders = disk->cylinders;
 820         }
 821
 822         return 0;
 823 }
 824
 825 static int pd_ioctl(struct block_device *bdev, fmode_t mode,
 826          unsigned int cmd, unsigned long arg)
 827 {
 828         struct pd_unit *disk = bdev->bd_disk->private_data;
 829
 830         switch (cmd) {
 831         case CDROMEJECT:
 832                 mutex_lock(&pd_mutex);
 833                 if (disk->access == 1)
 834                         pd_special_command(disk, pd_eject);
 835                 mutex_unlock(&pd_mutex);
 836                 return 0;
 837         default:
 838                 return -EINVAL;
 839         }
 840 }
 841
 842 static void pd_release(struct gendisk *p, fmode_t mode)
 843 {
 844         struct pd_unit *disk = p->private_data;
 845
 846         mutex_lock(&pd_mutex);
 847         if (!--disk->access && disk->removable)
 848                 pd_special_command(disk, pd_door_unlock);
 849         mutex_unlock(&pd_mutex);
 850 }
 851
 852 static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)
 853 {
 854         struct pd_unit *disk = p->private_data;
 855         int r;
 856         if (!disk->removable)
 857                 return 0;
 858         pd_special_command(disk, pd_media_check);
 859         r = disk->changed;
 860         disk->changed = 0;
 861         return r ? DISK_EVENT_MEDIA_CHANGE : 0;
 862 }
 863
 864 static const struct block_device_operations pd_fops = {
 865         .owner          = THIS_MODULE,
 866         .open           = pd_open,
 867         .release        = pd_release,
 868         .ioctl          = pd_ioctl,
 869         .compat_ioctl   = pd_ioctl,
 870         .getgeo         = pd_getgeo,
 871         .check_events   = pd_check_events,
 872 };
 873
 874 /* probing */
 875
 876 static const struct blk_mq_ops pd_mq_ops = {
 877         .queue_rq       = pd_queue_rq,
 878 };
 879
 880 static int pd_probe_drive(struct pd_unit *disk, int autoprobe, int port,
 881                 int mode, int unit, int protocol, int delay)
 882 {
 883         int index = disk - pd;
 884         int *parm = *drives[index];
 885         struct gendisk *p;
 886         int ret;
 887
 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' + index);
 894         disk->alt_geom = parm[D_GEO];
 895         disk->standby = parm[D_SBY];
 896         INIT_LIST_HEAD(&disk->rq_list);
 897
 898         if (!pi_init(disk->pi, autoprobe, port, mode, unit, protocol, delay,
 899                         pd_scratch, PI_PD, verbose, disk->name))
 900                 return -ENXIO;
 901
 902         memset(&disk->tag_set, 0, sizeof(disk->tag_set));
 903         disk->tag_set.ops = &pd_mq_ops;
 904         disk->tag_set.cmd_size = sizeof(struct pd_req);
 905         disk->tag_set.nr_hw_queues = 1;
 906         disk->tag_set.nr_maps = 1;
 907         disk->tag_set.queue_depth = 2;
 908         disk->tag_set.numa_node = NUMA_NO_NODE;
 909         disk->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
 910         ret = blk_mq_alloc_tag_set(&disk->tag_set);
 911         if (ret)
 912                 goto pi_release;
 913
 914         p = blk_mq_alloc_disk(&disk->tag_set, disk);
 915         if (IS_ERR(p)) {
 916                 ret = PTR_ERR(p);
 917                 goto free_tag_set;
 918         }
 919         disk->gd = p;
 920
 921         strcpy(p->disk_name, disk->name);
 922         p->fops = &pd_fops;
 923         p->major = major;
 924         p->first_minor = (disk - pd) << PD_BITS;
 925         p->minors = 1 << PD_BITS;
 926         p->events = DISK_EVENT_MEDIA_CHANGE;
 927         p->private_data = disk;
 928         blk_queue_max_hw_sectors(p->queue, cluster);
 929         blk_queue_bounce_limit(p->queue, BLK_BOUNCE_HIGH);
 930
 931         if (disk->drive == -1) {
 932                 for (disk->drive = 0; disk->drive <= 1; disk->drive++) {
 933                         ret = pd_special_command(disk, pd_identify);
 934                         if (ret == 0)
 935                                 break;
 936                 }
 937         } else {
 938                 ret = pd_special_command(disk, pd_identify);
 939         }
 940         if (ret)
 941                 goto put_disk;
 942         set_capacity(disk->gd, disk->capacity);
 943         ret = add_disk(disk->gd);
 944         if (ret)
 945                 goto cleanup_disk;
 946         return 0;
 947 cleanup_disk:
 948         put_disk(disk->gd);
 949 put_disk:
 950         put_disk(p);
 951         disk->gd = NULL;
 952 free_tag_set:
 953         blk_mq_free_tag_set(&disk->tag_set);
 954 pi_release:
 955         pi_release(disk->pi);
 956         return ret;
 957 }
 958
 959 static int __init pd_init(void)
 960 {
 961         int found = 0, unit, pd_drive_count = 0;
 962         struct pd_unit *disk;
 963
 964         if (disable)
 965                 return -ENODEV;
 966
 967         if (register_blkdev(major, name))
 968                 return -ENODEV;
 969
 970         printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 971                name, name, PD_VERSION, major, cluster, nice);
 972
 973         par_drv = pi_register_driver(name);
 974         if (!par_drv) {
 975                 pr_err("failed to register %s driver\n", name);
 976                 goto out_unregister_blkdev;
 977         }
 978
 979         for (unit = 0; unit < PD_UNITS; unit++) {
 980                 int *parm = *drives[unit];
 981
 982                 if (parm[D_PRT])
 983                         pd_drive_count++;
 984         }
 985
 986         if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
 987                 if (!pd_probe_drive(pd, 1, -1, -1, -1, -1, -1))
 988                         found++;
 989         } else {
 990                 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
 991                         int *parm = *drives[unit];
 992                         if (!parm[D_PRT])
 993                                 continue;
 994                         if (!pd_probe_drive(disk, 0, parm[D_PRT], parm[D_MOD],
 995                                         parm[D_UNI], parm[D_PRO], parm[D_DLY]))
 996                                 found++;
 997                 }
 998         }
 999         if (!found) {
1000                 printk("%s: no valid drive found\n", name);
1001                 goto out_pi_unregister_driver;
1002         }
1003
1004         return 0;
1005
1006 out_pi_unregister_driver:
1007         pi_unregister_driver(par_drv);
1008 out_unregister_blkdev:
1009         unregister_blkdev(major, name);
1010         return -ENODEV;
1011 }
1012
1013 static void __exit pd_exit(void)
1014 {
1015         struct pd_unit *disk;
1016         int unit;
1017         unregister_blkdev(major, name);
1018         for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
1019                 struct gendisk *p = disk->gd;
1020                 if (p) {
1021                         disk->gd = NULL;
1022                         del_gendisk(p);
1023                         put_disk(p);
1024                         blk_mq_free_tag_set(&disk->tag_set);
1025                         pi_release(disk->pi);
1026                 }
1027         }
1028 }
1029
1030 MODULE_LICENSE("GPL");
1031 module_init(pd_init)
1032 module_exit(pd_exit)