drivers/block/paride/pf.c

   1 /*
   2         pf.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 ATAPI disk
   6         drives based on chips supported by the paride module.
   7
   8         By default, the driver will autoprobe for a single parallel
   9         port ATAPI disk drive, but if their individual parameters are
  10         specified, the driver can handle up to 4 drives.
  11
  12         The behaviour of the pf 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-7 integers as follows:
  18             drive2
  19             drive3      <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<dly>
  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                 <slv>   ATAPI CDroms can be jumpered to master or slave.
  42                         Set this to 0 to choose the master drive, 1 to
  43                         choose the slave, -1 (the default) to choose the
  44                         first drive found.
  45
  46                 <lun>   Some ATAPI devices support multiple LUNs.
  47                         One example is the ATAPI PD/CD drive from
  48                         Matshita/Panasonic.  This device has a
  49                         CD drive on LUN 0 and a PD drive on LUN 1.
  50                         By default, the driver will search for the
  51                         first LUN with a supported device.  Set
  52                         this parameter to force it to use a specific
  53                         LUN.  (default -1)
  54
  55                 <dly>   some parallel ports require the driver to
  56                         go more slowly.  -1 sets a default value that
  57                         should work with the chosen protocol.  Otherwise,
  58                         set this to a small integer, the larger it is
  59                         the slower the port i/o.  In some cases, setting
  60                         this to zero will speed up the device. (default -1)
  61
  62             major       You may use this parameter to override the
  63                         default major number (47) that this driver
  64                         will use.  Be sure to change the device
  65                         name as well.
  66
  67             name        This parameter is a character string that
  68                         contains the name the kernel will use for this
  69                         device (in /proc output, for instance).
  70                         (default "pf").
  71
  72             cluster     The driver will attempt to aggregate requests
  73                         for adjacent blocks into larger multi-block
  74                         clusters.  The maximum cluster size (in 512
  75                         byte sectors) is set with this parameter.
  76                         (default 64)
  77
  78             verbose     This parameter controls the amount of logging
  79                         that the driver will do.  Set it to 0 for
  80                         normal operation, 1 to see autoprobe progress
  81                         messages, or 2 to see additional debugging
  82                         output.  (default 0)
  83
  84             nice        This parameter controls the driver's use of
  85                         idle CPU time, at the expense of some speed.
  86
  87         If this driver is built into the kernel, you can use the
  88         following command line parameters, with the same values
  89         as the corresponding module parameters listed above:
  90
  91             pf.drive0
  92             pf.drive1
  93             pf.drive2
  94             pf.drive3
  95             pf.cluster
  96             pf.nice
  97
  98         In addition, you can use the parameter pf.disable to disable
  99         the driver entirely.
 100
 101 */
 102
 103 /* Changes:
 104
 105         1.01    GRG 1998.05.03  Changes for SMP.  Eliminate sti().
 106                                 Fix for drives that don't clear STAT_ERR
 107                                 until after next CDB delivered.
 108                                 Small change in pf_completion to round
 109                                 up transfer size.
 110         1.02    GRG 1998.06.16  Eliminated an Ugh
 111         1.03    GRG 1998.08.16  Use HZ in loop timings, extra debugging
 112         1.04    GRG 1998.09.24  Added jumbo support
 113
 114 */
 115
 116 #define PF_VERSION      "1.04"
 117 #define PF_MAJOR        47
 118 #define PF_NAME         "pf"
 119 #define PF_UNITS        4
 120
 121 #include <linux/types.h>
 122
 123 /* Here are things one can override from the insmod command.
 124    Most are autoprobed by paride unless set here.  Verbose is off
 125    by default.
 126
 127 */
 128
 129 static bool verbose = 0;
 130 static int major = PF_MAJOR;
 131 static char *name = PF_NAME;
 132 static int cluster = 64;
 133 static int nice = 0;
 134 static int disable = 0;
 135
 136 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
 137 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
 138 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
 139 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
 140
 141 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
 142 static int pf_drive_count;
 143
 144 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
 145
 146 /* end of parameters */
 147
 148 #include <linux/module.h>
 149 #include <linux/init.h>
 150 #include <linux/fs.h>
 151 #include <linux/delay.h>
 152 #include <linux/hdreg.h>
 153 #include <linux/cdrom.h>
 154 #include <linux/spinlock.h>
 155 #include <linux/blk-mq.h>
 156 #include <linux/blkpg.h>
 157 #include <linux/mutex.h>
 158 #include <linux/uaccess.h>
 159
 160 static DEFINE_MUTEX(pf_mutex);
 161 static DEFINE_SPINLOCK(pf_spin_lock);
 162
 163 module_param(verbose, bool, 0644);
 164 module_param(major, int, 0);
 165 module_param(name, charp, 0);
 166 module_param(cluster, int, 0);
 167 module_param(nice, int, 0);
 168 module_param_array(drive0, int, NULL, 0);
 169 module_param_array(drive1, int, NULL, 0);
 170 module_param_array(drive2, int, NULL, 0);
 171 module_param_array(drive3, int, NULL, 0);
 172
 173 #include "paride.h"
 174 #include "pseudo.h"
 175
 176 /* constants for faking geometry numbers */
 177
 178 #define PF_FD_MAX       8192    /* use FD geometry under this size */
 179 #define PF_FD_HDS       2
 180 #define PF_FD_SPT       18
 181 #define PF_HD_HDS       64
 182 #define PF_HD_SPT       32
 183
 184 #define PF_MAX_RETRIES  5
 185 #define PF_TMO          800     /* interrupt timeout in jiffies */
 186 #define PF_SPIN_DEL     50      /* spin delay in micro-seconds  */
 187
 188 #define PF_SPIN         (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
 189
 190 #define STAT_ERR        0x00001
 191 #define STAT_INDEX      0x00002
 192 #define STAT_ECC        0x00004
 193 #define STAT_DRQ        0x00008
 194 #define STAT_SEEK       0x00010
 195 #define STAT_WRERR      0x00020
 196 #define STAT_READY      0x00040
 197 #define STAT_BUSY       0x00080
 198
 199 #define ATAPI_REQ_SENSE         0x03
 200 #define ATAPI_LOCK              0x1e
 201 #define ATAPI_DOOR              0x1b
 202 #define ATAPI_MODE_SENSE        0x5a
 203 #define ATAPI_CAPACITY          0x25
 204 #define ATAPI_IDENTIFY          0x12
 205 #define ATAPI_READ_10           0x28
 206 #define ATAPI_WRITE_10          0x2a
 207
 208 static int pf_open(struct block_device *bdev, fmode_t mode);
 209 static blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
 210                                 const struct blk_mq_queue_data *bd);
 211 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
 212                     unsigned int cmd, unsigned long arg);
 213 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 214
 215 static void pf_release(struct gendisk *disk, fmode_t mode);
 216
 217 static int pf_detect(void);
 218 static void do_pf_read(void);
 219 static void do_pf_read_start(void);
 220 static void do_pf_write(void);
 221 static void do_pf_write_start(void);
 222 static void do_pf_read_drq(void);
 223 static void do_pf_write_done(void);
 224
 225 #define PF_NM           0
 226 #define PF_RO           1
 227 #define PF_RW           2
 228
 229 #define PF_NAMELEN      8
 230
 231 struct pf_unit {
 232         struct pi_adapter pia;  /* interface to paride layer */
 233         struct pi_adapter *pi;
 234         int removable;          /* removable media device  ?  */
 235         int media_status;       /* media present ?  WP ? */
 236         int drive;              /* drive */
 237         int lun;
 238         int access;             /* count of active opens ... */
 239         int present;            /* device present ? */
 240         char name[PF_NAMELEN];  /* pf0, pf1, ... */
 241         struct gendisk *disk;
 242         struct blk_mq_tag_set tag_set;
 243         struct list_head rq_list;
 244 };
 245
 246 static struct pf_unit units[PF_UNITS];
 247
 248 static int pf_identify(struct pf_unit *pf);
 249 static void pf_lock(struct pf_unit *pf, int func);
 250 static void pf_eject(struct pf_unit *pf);
 251 static unsigned int pf_check_events(struct gendisk *disk,
 252                                     unsigned int clearing);
 253
 254 static char pf_scratch[512];    /* scratch block buffer */
 255
 256 /* the variables below are used mainly in the I/O request engine, which
 257    processes only one request at a time.
 258 */
 259
 260 static int pf_retries = 0;      /* i/o error retry count */
 261 static int pf_busy = 0;         /* request being processed ? */
 262 static struct request *pf_req;  /* current request */
 263 static int pf_block;            /* address of next requested block */
 264 static int pf_count;            /* number of blocks still to do */
 265 static int pf_run;              /* sectors in current cluster */
 266 static int pf_cmd;              /* current command READ/WRITE */
 267 static struct pf_unit *pf_current;/* unit of current request */
 268 static int pf_mask;             /* stopper for pseudo-int */
 269 static char *pf_buf;            /* buffer for request in progress */
 270 static void *par_drv;           /* reference of parport driver */
 271
 272 /* kernel glue structures */
 273
 274 static const struct block_device_operations pf_fops = {
 275         .owner          = THIS_MODULE,
 276         .open           = pf_open,
 277         .release        = pf_release,
 278         .ioctl          = pf_ioctl,
 279         .compat_ioctl   = pf_ioctl,
 280         .getgeo         = pf_getgeo,
 281         .check_events   = pf_check_events,
 282 };
 283
 284 static const struct blk_mq_ops pf_mq_ops = {
 285         .queue_rq       = pf_queue_rq,
 286 };
 287
 288 static void __init pf_init_units(void)
 289 {
 290         struct pf_unit *pf;
 291         int unit;
 292
 293         pf_drive_count = 0;
 294         for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
 295                 struct gendisk *disk;
 296
 297                 disk = alloc_disk(1);
 298                 if (!disk)
 299                         continue;
 300
 301                 disk->queue = blk_mq_init_sq_queue(&pf->tag_set, &pf_mq_ops,
 302                                                         1, BLK_MQ_F_SHOULD_MERGE);
 303                 if (IS_ERR(disk->queue)) {
 304                         disk->queue = NULL;
 305                         put_disk(disk);
 306                         continue;
 307                 }
 308
 309                 INIT_LIST_HEAD(&pf->rq_list);
 310                 disk->queue->queuedata = pf;
 311                 blk_queue_max_segments(disk->queue, cluster);
 312                 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
 313                 pf->disk = disk;
 314                 pf->pi = &pf->pia;
 315                 pf->media_status = PF_NM;
 316                 pf->drive = (*drives[unit])[D_SLV];
 317                 pf->lun = (*drives[unit])[D_LUN];
 318                 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
 319                 disk->major = major;
 320                 disk->first_minor = unit;
 321                 strcpy(disk->disk_name, pf->name);
 322                 disk->fops = &pf_fops;
 323                 disk->events = DISK_EVENT_MEDIA_CHANGE;
 324                 if (!(*drives[unit])[D_PRT])
 325                         pf_drive_count++;
 326         }
 327 }
 328
 329 static int pf_open(struct block_device *bdev, fmode_t mode)
 330 {
 331         struct pf_unit *pf = bdev->bd_disk->private_data;
 332         int ret;
 333
 334         mutex_lock(&pf_mutex);
 335         pf_identify(pf);
 336
 337         ret = -ENODEV;
 338         if (pf->media_status == PF_NM)
 339                 goto out;
 340
 341         ret = -EROFS;
 342         if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
 343                 goto out;
 344
 345         ret = 0;
 346         pf->access++;
 347         if (pf->removable)
 348                 pf_lock(pf, 1);
 349 out:
 350         mutex_unlock(&pf_mutex);
 351         return ret;
 352 }
 353
 354 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 355 {
 356         struct pf_unit *pf = bdev->bd_disk->private_data;
 357         sector_t capacity = get_capacity(pf->disk);
 358
 359         if (capacity < PF_FD_MAX) {
 360                 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
 361                 geo->heads = PF_FD_HDS;
 362                 geo->sectors = PF_FD_SPT;
 363         } else {
 364                 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
 365                 geo->heads = PF_HD_HDS;
 366                 geo->sectors = PF_HD_SPT;
 367         }
 368
 369         return 0;
 370 }
 371
 372 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
 373 {
 374         struct pf_unit *pf = bdev->bd_disk->private_data;
 375
 376         if (cmd != CDROMEJECT)
 377                 return -EINVAL;
 378
 379         if (pf->access != 1)
 380                 return -EBUSY;
 381         mutex_lock(&pf_mutex);
 382         pf_eject(pf);
 383         mutex_unlock(&pf_mutex);
 384
 385         return 0;
 386 }
 387
 388 static void pf_release(struct gendisk *disk, fmode_t mode)
 389 {
 390         struct pf_unit *pf = disk->private_data;
 391
 392         mutex_lock(&pf_mutex);
 393         if (pf->access <= 0) {
 394                 mutex_unlock(&pf_mutex);
 395                 WARN_ON(1);
 396                 return;
 397         }
 398
 399         pf->access--;
 400
 401         if (!pf->access && pf->removable)
 402                 pf_lock(pf, 0);
 403
 404         mutex_unlock(&pf_mutex);
 405 }
 406
 407 static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
 408 {
 409         return DISK_EVENT_MEDIA_CHANGE;
 410 }
 411
 412 static inline int status_reg(struct pf_unit *pf)
 413 {
 414         return pi_read_regr(pf->pi, 1, 6);
 415 }
 416
 417 static inline int read_reg(struct pf_unit *pf, int reg)
 418 {
 419         return pi_read_regr(pf->pi, 0, reg);
 420 }
 421
 422 static inline void write_reg(struct pf_unit *pf, int reg, int val)
 423 {
 424         pi_write_regr(pf->pi, 0, reg, val);
 425 }
 426
 427 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
 428 {
 429         int j, r, e, s, p;
 430
 431         j = 0;
 432         while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
 433                && (j++ < PF_SPIN))
 434                 udelay(PF_SPIN_DEL);
 435
 436         if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
 437                 s = read_reg(pf, 7);
 438                 e = read_reg(pf, 1);
 439                 p = read_reg(pf, 2);
 440                 if (j > PF_SPIN)
 441                         e |= 0x100;
 442                 if (fun)
 443                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 444                                " loop=%d phase=%d\n",
 445                                pf->name, fun, msg, r, s, e, j, p);
 446                 return (e << 8) + s;
 447         }
 448         return 0;
 449 }
 450
 451 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
 452 {
 453         pi_connect(pf->pi);
 454
 455         write_reg(pf, 6, 0xa0+0x10*pf->drive);
 456
 457         if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
 458                 pi_disconnect(pf->pi);
 459                 return -1;
 460         }
 461
 462         write_reg(pf, 4, dlen % 256);
 463         write_reg(pf, 5, dlen / 256);
 464         write_reg(pf, 7, 0xa0); /* ATAPI packet command */
 465
 466         if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
 467                 pi_disconnect(pf->pi);
 468                 return -1;
 469         }
 470
 471         if (read_reg(pf, 2) != 1) {
 472                 printk("%s: %s: command phase error\n", pf->name, fun);
 473                 pi_disconnect(pf->pi);
 474                 return -1;
 475         }
 476
 477         pi_write_block(pf->pi, cmd, 12);
 478
 479         return 0;
 480 }
 481
 482 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
 483 {
 484         int r, s, n;
 485
 486         r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
 487                     fun, "completion");
 488
 489         if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
 490                 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
 491                       3) & 0xfffc);
 492                 pi_read_block(pf->pi, buf, n);
 493         }
 494
 495         s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
 496
 497         pi_disconnect(pf->pi);
 498
 499         return (r ? r : s);
 500 }
 501
 502 static void pf_req_sense(struct pf_unit *pf, int quiet)
 503 {
 504         char rs_cmd[12] =
 505             { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 506         char buf[16];
 507         int r;
 508
 509         r = pf_command(pf, rs_cmd, 16, "Request sense");
 510         mdelay(1);
 511         if (!r)
 512                 pf_completion(pf, buf, "Request sense");
 513
 514         if ((!r) && (!quiet))
 515                 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
 516                        pf->name, buf[2] & 0xf, buf[12], buf[13]);
 517 }
 518
 519 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
 520 {
 521         int r;
 522
 523         r = pf_command(pf, cmd, dlen, fun);
 524         mdelay(1);
 525         if (!r)
 526                 r = pf_completion(pf, buf, fun);
 527         if (r)
 528                 pf_req_sense(pf, !fun);
 529
 530         return r;
 531 }
 532
 533 static void pf_lock(struct pf_unit *pf, int func)
 534 {
 535         char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
 536
 537         pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
 538 }
 539
 540 static void pf_eject(struct pf_unit *pf)
 541 {
 542         char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
 543
 544         pf_lock(pf, 0);
 545         pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
 546 }
 547
 548 #define PF_RESET_TMO   30       /* in tenths of a second */
 549
 550 static void pf_sleep(int cs)
 551 {
 552         schedule_timeout_interruptible(cs);
 553 }
 554
 555 /* the ATAPI standard actually specifies the contents of all 7 registers
 556    after a reset, but the specification is ambiguous concerning the last
 557    two bytes, and different drives interpret the standard differently.
 558  */
 559
 560 static int pf_reset(struct pf_unit *pf)
 561 {
 562         int i, k, flg;
 563         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 564
 565         pi_connect(pf->pi);
 566         write_reg(pf, 6, 0xa0+0x10*pf->drive);
 567         write_reg(pf, 7, 8);
 568
 569         pf_sleep(20 * HZ / 1000);
 570
 571         k = 0;
 572         while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
 573                 pf_sleep(HZ / 10);
 574
 575         flg = 1;
 576         for (i = 0; i < 5; i++)
 577                 flg &= (read_reg(pf, i + 1) == expect[i]);
 578
 579         if (verbose) {
 580                 printk("%s: Reset (%d) signature = ", pf->name, k);
 581                 for (i = 0; i < 5; i++)
 582                         printk("%3x", read_reg(pf, i + 1));
 583                 if (!flg)
 584                         printk(" (incorrect)");
 585                 printk("\n");
 586         }
 587
 588         pi_disconnect(pf->pi);
 589         return flg - 1;
 590 }
 591
 592 static void pf_mode_sense(struct pf_unit *pf)
 593 {
 594         char ms_cmd[12] =
 595             { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
 596         char buf[8];
 597
 598         pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
 599         pf->media_status = PF_RW;
 600         if (buf[3] & 0x80)
 601                 pf->media_status = PF_RO;
 602 }
 603
 604 static void xs(char *buf, char *targ, int offs, int len)
 605 {
 606         int j, k, l;
 607
 608         j = 0;
 609         l = 0;
 610         for (k = 0; k < len; k++)
 611                 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
 612                         l = targ[j++] = buf[k + offs];
 613         if (l == 0x20)
 614                 j--;
 615         targ[j] = 0;
 616 }
 617
 618 static int xl(char *buf, int offs)
 619 {
 620         int v, k;
 621
 622         v = 0;
 623         for (k = 0; k < 4; k++)
 624                 v = v * 256 + (buf[k + offs] & 0xff);
 625         return v;
 626 }
 627
 628 static void pf_get_capacity(struct pf_unit *pf)
 629 {
 630         char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 631         char buf[8];
 632         int bs;
 633
 634         if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
 635                 pf->media_status = PF_NM;
 636                 return;
 637         }
 638         set_capacity(pf->disk, xl(buf, 0) + 1);
 639         bs = xl(buf, 4);
 640         if (bs != 512) {
 641                 set_capacity(pf->disk, 0);
 642                 if (verbose)
 643                         printk("%s: Drive %d, LUN %d,"
 644                                " unsupported block size %d\n",
 645                                pf->name, pf->drive, pf->lun, bs);
 646         }
 647 }
 648
 649 static int pf_identify(struct pf_unit *pf)
 650 {
 651         int dt, s;
 652         char *ms[2] = { "master", "slave" };
 653         char mf[10], id[18];
 654         char id_cmd[12] =
 655             { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 656         char buf[36];
 657
 658         s = pf_atapi(pf, id_cmd, 36, buf, "identify");
 659         if (s)
 660                 return -1;
 661
 662         dt = buf[0] & 0x1f;
 663         if ((dt != 0) && (dt != 7)) {
 664                 if (verbose)
 665                         printk("%s: Drive %d, LUN %d, unsupported type %d\n",
 666                                pf->name, pf->drive, pf->lun, dt);
 667                 return -1;
 668         }
 669
 670         xs(buf, mf, 8, 8);
 671         xs(buf, id, 16, 16);
 672
 673         pf->removable = (buf[1] & 0x80);
 674
 675         pf_mode_sense(pf);
 676         pf_mode_sense(pf);
 677         pf_mode_sense(pf);
 678
 679         pf_get_capacity(pf);
 680
 681         printk("%s: %s %s, %s LUN %d, type %d",
 682                pf->name, mf, id, ms[pf->drive], pf->lun, dt);
 683         if (pf->removable)
 684                 printk(", removable");
 685         if (pf->media_status == PF_NM)
 686                 printk(", no media\n");
 687         else {
 688                 if (pf->media_status == PF_RO)
 689                         printk(", RO");
 690                 printk(", %llu blocks\n",
 691                         (unsigned long long)get_capacity(pf->disk));
 692         }
 693         return 0;
 694 }
 695
 696 /*      returns  0, with id set if drive is detected
 697                 -1, if drive detection failed
 698 */
 699 static int pf_probe(struct pf_unit *pf)
 700 {
 701         if (pf->drive == -1) {
 702                 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
 703                         if (!pf_reset(pf)) {
 704                                 if (pf->lun != -1)
 705                                         return pf_identify(pf);
 706                                 else
 707                                         for (pf->lun = 0; pf->lun < 8; pf->lun++)
 708                                                 if (!pf_identify(pf))
 709                                                         return 0;
 710                         }
 711         } else {
 712                 if (pf_reset(pf))
 713                         return -1;
 714                 if (pf->lun != -1)
 715                         return pf_identify(pf);
 716                 for (pf->lun = 0; pf->lun < 8; pf->lun++)
 717                         if (!pf_identify(pf))
 718                                 return 0;
 719         }
 720         return -1;
 721 }
 722
 723 static int pf_detect(void)
 724 {
 725         struct pf_unit *pf = units;
 726         int k, unit;
 727
 728         printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 729                name, name, PF_VERSION, major, cluster, nice);
 730
 731         par_drv = pi_register_driver(name);
 732         if (!par_drv) {
 733                 pr_err("failed to register %s driver\n", name);
 734                 return -1;
 735         }
 736         k = 0;
 737         if (pf_drive_count == 0) {
 738                 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
 739                             verbose, pf->name)) {
 740                         if (!pf_probe(pf) && pf->disk) {
 741                                 pf->present = 1;
 742                                 k++;
 743                         } else
 744                                 pi_release(pf->pi);
 745                 }
 746
 747         } else
 748                 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
 749                         int *conf = *drives[unit];
 750                         if (!conf[D_PRT])
 751                                 continue;
 752                         if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
 753                                     conf[D_UNI], conf[D_PRO], conf[D_DLY],
 754                                     pf_scratch, PI_PF, verbose, pf->name)) {
 755                                 if (pf->disk && !pf_probe(pf)) {
 756                                         pf->present = 1;
 757                                         k++;
 758                                 } else
 759                                         pi_release(pf->pi);
 760                         }
 761                 }
 762         if (k)
 763                 return 0;
 764
 765         printk("%s: No ATAPI disk detected\n", name);
 766         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
 767                 if (!pf->disk)
 768                         continue;
 769                 blk_cleanup_queue(pf->disk->queue);
 770                 pf->disk->queue = NULL;
 771                 blk_mq_free_tag_set(&pf->tag_set);
 772                 put_disk(pf->disk);
 773         }
 774         pi_unregister_driver(par_drv);
 775         return -1;
 776 }
 777
 778 /* The i/o request engine */
 779
 780 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
 781 {
 782         int i;
 783         char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 784
 785         for (i = 0; i < 4; i++) {
 786                 io_cmd[5 - i] = b & 0xff;
 787                 b = b >> 8;
 788         }
 789
 790         io_cmd[8] = c & 0xff;
 791         io_cmd[7] = (c >> 8) & 0xff;
 792
 793         i = pf_command(pf, io_cmd, c * 512, "start i/o");
 794
 795         mdelay(1);
 796
 797         return i;
 798 }
 799
 800 static int pf_ready(void)
 801 {
 802         return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
 803 }
 804
 805 static int pf_queue;
 806
 807 static int set_next_request(void)
 808 {
 809         struct pf_unit *pf;
 810         int old_pos = pf_queue;
 811
 812         do {
 813                 pf = &units[pf_queue];
 814                 if (++pf_queue == PF_UNITS)
 815                         pf_queue = 0;
 816                 if (pf->present && !list_empty(&pf->rq_list)) {
 817                         pf_req = list_first_entry(&pf->rq_list, struct request,
 818                                                         queuelist);
 819                         list_del_init(&pf_req->queuelist);
 820                         blk_mq_start_request(pf_req);
 821                         break;
 822                 }
 823         } while (pf_queue != old_pos);
 824
 825         return pf_req != NULL;
 826 }
 827
 828 static void pf_end_request(blk_status_t err)
 829 {
 830         if (!pf_req)
 831                 return;
 832         if (!blk_update_request(pf_req, err, blk_rq_cur_bytes(pf_req))) {
 833                 __blk_mq_end_request(pf_req, err);
 834                 pf_req = NULL;
 835         }
 836 }
 837
 838 static void pf_request(void)
 839 {
 840         if (pf_busy)
 841                 return;
 842 repeat:
 843         if (!pf_req && !set_next_request())
 844                 return;
 845
 846         pf_current = pf_req->rq_disk->private_data;
 847         pf_block = blk_rq_pos(pf_req);
 848         pf_run = blk_rq_sectors(pf_req);
 849         pf_count = blk_rq_cur_sectors(pf_req);
 850
 851         if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
 852                 pf_end_request(BLK_STS_IOERR);
 853                 goto repeat;
 854         }
 855
 856         pf_cmd = rq_data_dir(pf_req);
 857         pf_buf = bio_data(pf_req->bio);
 858         pf_retries = 0;
 859
 860         pf_busy = 1;
 861         if (pf_cmd == READ)
 862                 pi_do_claimed(pf_current->pi, do_pf_read);
 863         else if (pf_cmd == WRITE)
 864                 pi_do_claimed(pf_current->pi, do_pf_write);
 865         else {
 866                 pf_busy = 0;
 867                 pf_end_request(BLK_STS_IOERR);
 868                 goto repeat;
 869         }
 870 }
 871
 872 static blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
 873                                 const struct blk_mq_queue_data *bd)
 874 {
 875         struct pf_unit *pf = hctx->queue->queuedata;
 876
 877         spin_lock_irq(&pf_spin_lock);
 878         list_add_tail(&bd->rq->queuelist, &pf->rq_list);
 879         pf_request();
 880         spin_unlock_irq(&pf_spin_lock);
 881
 882         return BLK_STS_OK;
 883 }
 884
 885 static int pf_next_buf(void)
 886 {
 887         unsigned long saved_flags;
 888
 889         pf_count--;
 890         pf_run--;
 891         pf_buf += 512;
 892         pf_block++;
 893         if (!pf_run)
 894                 return 1;
 895         if (!pf_count) {
 896                 spin_lock_irqsave(&pf_spin_lock, saved_flags);
 897                 pf_end_request(0);
 898                 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
 899                 if (!pf_req)
 900                         return 1;
 901                 pf_count = blk_rq_cur_sectors(pf_req);
 902                 pf_buf = bio_data(pf_req->bio);
 903         }
 904         return 0;
 905 }
 906
 907 static inline void next_request(blk_status_t err)
 908 {
 909         unsigned long saved_flags;
 910
 911         spin_lock_irqsave(&pf_spin_lock, saved_flags);
 912         pf_end_request(err);
 913         pf_busy = 0;
 914         pf_request();
 915         spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
 916 }
 917
 918 /* detach from the calling context - in case the spinlock is held */
 919 static void do_pf_read(void)
 920 {
 921         ps_set_intr(do_pf_read_start, NULL, 0, nice);
 922 }
 923
 924 static void do_pf_read_start(void)
 925 {
 926         pf_busy = 1;
 927
 928         if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
 929                 pi_disconnect(pf_current->pi);
 930                 if (pf_retries < PF_MAX_RETRIES) {
 931                         pf_retries++;
 932                         pi_do_claimed(pf_current->pi, do_pf_read_start);
 933                         return;
 934                 }
 935                 next_request(BLK_STS_IOERR);
 936                 return;
 937         }
 938         pf_mask = STAT_DRQ;
 939         ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
 940 }
 941
 942 static void do_pf_read_drq(void)
 943 {
 944         while (1) {
 945                 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
 946                             "read block", "completion") & STAT_ERR) {
 947                         pi_disconnect(pf_current->pi);
 948                         if (pf_retries < PF_MAX_RETRIES) {
 949                                 pf_req_sense(pf_current, 0);
 950                                 pf_retries++;
 951                                 pi_do_claimed(pf_current->pi, do_pf_read_start);
 952                                 return;
 953                         }
 954                         next_request(BLK_STS_IOERR);
 955                         return;
 956                 }
 957                 pi_read_block(pf_current->pi, pf_buf, 512);
 958                 if (pf_next_buf())
 959                         break;
 960         }
 961         pi_disconnect(pf_current->pi);
 962         next_request(0);
 963 }
 964
 965 static void do_pf_write(void)
 966 {
 967         ps_set_intr(do_pf_write_start, NULL, 0, nice);
 968 }
 969
 970 static void do_pf_write_start(void)
 971 {
 972         pf_busy = 1;
 973
 974         if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
 975                 pi_disconnect(pf_current->pi);
 976                 if (pf_retries < PF_MAX_RETRIES) {
 977                         pf_retries++;
 978                         pi_do_claimed(pf_current->pi, do_pf_write_start);
 979                         return;
 980                 }
 981                 next_request(BLK_STS_IOERR);
 982                 return;
 983         }
 984
 985         while (1) {
 986                 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
 987                             "write block", "data wait") & STAT_ERR) {
 988                         pi_disconnect(pf_current->pi);
 989                         if (pf_retries < PF_MAX_RETRIES) {
 990                                 pf_retries++;
 991                                 pi_do_claimed(pf_current->pi, do_pf_write_start);
 992                                 return;
 993                         }
 994                         next_request(BLK_STS_IOERR);
 995                         return;
 996                 }
 997                 pi_write_block(pf_current->pi, pf_buf, 512);
 998                 if (pf_next_buf())
 999                         break;
1000         }
1001         pf_mask = 0;
1002         ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
1003 }
1004
1005 static void do_pf_write_done(void)
1006 {
1007         if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
1008                 pi_disconnect(pf_current->pi);
1009                 if (pf_retries < PF_MAX_RETRIES) {
1010                         pf_retries++;
1011                         pi_do_claimed(pf_current->pi, do_pf_write_start);
1012                         return;
1013                 }
1014                 next_request(BLK_STS_IOERR);
1015                 return;
1016         }
1017         pi_disconnect(pf_current->pi);
1018         next_request(0);
1019 }
1020
1021 static int __init pf_init(void)
1022 {                               /* preliminary initialisation */
1023         struct pf_unit *pf;
1024         int unit;
1025
1026         if (disable)
1027                 return -EINVAL;
1028
1029         pf_init_units();
1030
1031         if (pf_detect())
1032                 return -ENODEV;
1033         pf_busy = 0;
1034
1035         if (register_blkdev(major, name)) {
1036                 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1037                         if (!pf->disk)
1038                                 continue;
1039                         blk_cleanup_queue(pf->disk->queue);
1040                         blk_mq_free_tag_set(&pf->tag_set);
1041                         put_disk(pf->disk);
1042                 }
1043                 return -EBUSY;
1044         }
1045
1046         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1047                 struct gendisk *disk = pf->disk;
1048
1049                 if (!pf->present)
1050                         continue;
1051                 disk->private_data = pf;
1052                 add_disk(disk);
1053         }
1054         return 0;
1055 }
1056
1057 static void __exit pf_exit(void)
1058 {
1059         struct pf_unit *pf;
1060         int unit;
1061         unregister_blkdev(major, name);
1062         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1063                 if (!pf->disk)
1064                         continue;
1065
1066                 if (pf->present)
1067                         del_gendisk(pf->disk);
1068
1069                 blk_cleanup_queue(pf->disk->queue);
1070                 blk_mq_free_tag_set(&pf->tag_set);
1071                 put_disk(pf->disk);
1072
1073                 if (pf->present)
1074                         pi_release(pf->pi);
1075         }
1076 }
1077
1078 MODULE_LICENSE("GPL");
1079 module_init(pf_init)
1080 module_exit(pf_exit)