drivers/block/paride/pcd.c

   1 /*
   2         pcd.c   (c) 1997-8  Grant R. Guenther <grant@torque.net>
   3                             Under the terms of the GNU General Public License.
   4
   5         This is a high-level driver for parallel port ATAPI CD-ROM
   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 CD-ROM drive, but if their individual parameters are
  10         specified, the driver can handle up to 4 drives.
  11
  12         The behaviour of the pcd 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-6 integers as follows:
  18             drive2
  19             drive3      <prt>,<pro>,<uni>,<mod>,<slv>,<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 CD-ROMs 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                 <dly>   some parallel ports require the driver to
  47                         go more slowly.  -1 sets a default value that
  48                         should work with the chosen protocol.  Otherwise,
  49                         set this to a small integer, the larger it is
  50                         the slower the port i/o.  In some cases, setting
  51                         this to zero will speed up the device. (default -1)
  52
  53             major       You may use this parameter to override the
  54                         default major number (46) that this driver
  55                         will use.  Be sure to change the device
  56                         name as well.
  57
  58             name        This parameter is a character string that
  59                         contains the name the kernel will use for this
  60                         device (in /proc output, for instance).
  61                         (default "pcd")
  62
  63             verbose     This parameter controls the amount of logging
  64                         that the driver will do.  Set it to 0 for
  65                         normal operation, 1 to see autoprobe progress
  66                         messages, or 2 to see additional debugging
  67                         output.  (default 0)
  68
  69             nice        This parameter controls the driver's use of
  70                         idle CPU time, at the expense of some speed.
  71
  72         If this driver is built into the kernel, you can use the
  73         following kernel command line parameters, with the same values
  74         as the corresponding module parameters listed above:
  75
  76             pcd.drive0
  77             pcd.drive1
  78             pcd.drive2
  79             pcd.drive3
  80             pcd.nice
  81
  82         In addition, you can use the parameter pcd.disable to disable
  83         the driver entirely.
  84
  85 */
  86
  87 /* Changes:
  88
  89         1.01    GRG 1998.01.24  Added test unit ready support
  90         1.02    GRG 1998.05.06  Changes to pcd_completion, ready_wait,
  91                                 and loosen interpretation of ATAPI
  92                                 standard for clearing error status.
  93                                 Use spinlocks. Eliminate sti().
  94         1.03    GRG 1998.06.16  Eliminated an Ugh
  95         1.04    GRG 1998.08.15  Added extra debugging, improvements to
  96                                 pcd_completion, use HZ in loop timing
  97         1.05    GRG 1998.08.16  Conformed to "Uniform CD-ROM" standard
  98         1.06    GRG 1998.08.19  Added audio ioctl support
  99         1.07    GRG 1998.09.24  Increased reset timeout, added jumbo support
 100
 101 */
 102
 103 #define PCD_VERSION     "1.07"
 104 #define PCD_MAJOR       46
 105 #define PCD_NAME        "pcd"
 106 #define PCD_UNITS       4
 107
 108 /* Here are things one can override from the insmod command.
 109    Most are autoprobed by paride unless set here.  Verbose is off
 110    by default.
 111
 112 */
 113
 114 static int verbose = 0;
 115 static int major = PCD_MAJOR;
 116 static char *name = PCD_NAME;
 117 static int nice = 0;
 118 static int disable = 0;
 119
 120 static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
 121 static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
 122 static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
 123 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
 124
 125 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
 126 static int pcd_drive_count;
 127
 128 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
 129
 130 /* end of parameters */
 131
 132 #include <linux/module.h>
 133 #include <linux/init.h>
 134 #include <linux/errno.h>
 135 #include <linux/fs.h>
 136 #include <linux/kernel.h>
 137 #include <linux/delay.h>
 138 #include <linux/cdrom.h>
 139 #include <linux/spinlock.h>
 140 #include <linux/blk-mq.h>
 141 #include <linux/mutex.h>
 142 #include <linux/uaccess.h>
 143
 144 static DEFINE_MUTEX(pcd_mutex);
 145 static DEFINE_SPINLOCK(pcd_lock);
 146
 147 module_param(verbose, int, 0644);
 148 module_param(major, int, 0);
 149 module_param(name, charp, 0);
 150 module_param(nice, int, 0);
 151 module_param_array(drive0, int, NULL, 0);
 152 module_param_array(drive1, int, NULL, 0);
 153 module_param_array(drive2, int, NULL, 0);
 154 module_param_array(drive3, int, NULL, 0);
 155
 156 #include "paride.h"
 157 #include "pseudo.h"
 158
 159 #define PCD_RETRIES          5
 160 #define PCD_TMO            800  /* timeout in jiffies */
 161 #define PCD_DELAY           50  /* spin delay in uS */
 162 #define PCD_READY_TMO       20  /* in seconds */
 163 #define PCD_RESET_TMO      100  /* in tenths of a second */
 164
 165 #define PCD_SPIN        (1000000*PCD_TMO)/(HZ*PCD_DELAY)
 166
 167 #define IDE_ERR         0x01
 168 #define IDE_DRQ         0x08
 169 #define IDE_READY       0x40
 170 #define IDE_BUSY        0x80
 171
 172 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
 173 static void pcd_release(struct cdrom_device_info *cdi);
 174 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
 175 static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
 176                                      unsigned int clearing, int slot_nr);
 177 static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
 178 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
 179 static int pcd_drive_reset(struct cdrom_device_info *cdi);
 180 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn);
 181 static int pcd_audio_ioctl(struct cdrom_device_info *cdi,
 182                            unsigned int cmd, void *arg);
 183 static int pcd_packet(struct cdrom_device_info *cdi,
 184                       struct packet_command *cgc);
 185
 186 static int pcd_detect(void);
 187 static void pcd_probe_capabilities(void);
 188 static void do_pcd_read_drq(void);
 189 static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
 190                                  const struct blk_mq_queue_data *bd);
 191 static void do_pcd_read(void);
 192
 193 struct pcd_unit {
 194         struct pi_adapter pia;  /* interface to paride layer */
 195         struct pi_adapter *pi;
 196         int drive;              /* master/slave */
 197         int last_sense;         /* result of last request sense */
 198         int changed;            /* media change seen */
 199         int present;            /* does this unit exist ? */
 200         char *name;             /* pcd0, pcd1, etc */
 201         struct cdrom_device_info info;  /* uniform cdrom interface */
 202         struct gendisk *disk;
 203         struct blk_mq_tag_set tag_set;
 204         struct list_head rq_list;
 205 };
 206
 207 static struct pcd_unit pcd[PCD_UNITS];
 208
 209 static char pcd_scratch[64];
 210 static char pcd_buffer[2048];   /* raw block buffer */
 211 static int pcd_bufblk = -1;     /* block in buffer, in CD units,
 212                                    -1 for nothing there. See also
 213                                    pd_unit.
 214                                  */
 215
 216 /* the variables below are used mainly in the I/O request engine, which
 217    processes only one request at a time.
 218 */
 219
 220 static struct pcd_unit *pcd_current; /* current request's drive */
 221 static struct request *pcd_req;
 222 static int pcd_retries;         /* retries on current request */
 223 static int pcd_busy;            /* request being processed ? */
 224 static int pcd_sector;          /* address of next requested sector */
 225 static int pcd_count;           /* number of blocks still to do */
 226 static char *pcd_buf;           /* buffer for request in progress */
 227 static void *par_drv;           /* reference of parport driver */
 228
 229 /* kernel glue structures */
 230
 231 static int pcd_block_open(struct block_device *bdev, fmode_t mode)
 232 {
 233         struct pcd_unit *cd = bdev->bd_disk->private_data;
 234         int ret;
 235
 236         bdev_check_media_change(bdev);
 237
 238         mutex_lock(&pcd_mutex);
 239         ret = cdrom_open(&cd->info, bdev, mode);
 240         mutex_unlock(&pcd_mutex);
 241
 242         return ret;
 243 }
 244
 245 static void pcd_block_release(struct gendisk *disk, fmode_t mode)
 246 {
 247         struct pcd_unit *cd = disk->private_data;
 248         mutex_lock(&pcd_mutex);
 249         cdrom_release(&cd->info, mode);
 250         mutex_unlock(&pcd_mutex);
 251 }
 252
 253 static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
 254                                 unsigned cmd, unsigned long arg)
 255 {
 256         struct pcd_unit *cd = bdev->bd_disk->private_data;
 257         int ret;
 258
 259         mutex_lock(&pcd_mutex);
 260         ret = cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
 261         mutex_unlock(&pcd_mutex);
 262
 263         return ret;
 264 }
 265
 266 static unsigned int pcd_block_check_events(struct gendisk *disk,
 267                                            unsigned int clearing)
 268 {
 269         struct pcd_unit *cd = disk->private_data;
 270         return cdrom_check_events(&cd->info, clearing);
 271 }
 272
 273 static const struct block_device_operations pcd_bdops = {
 274         .owner          = THIS_MODULE,
 275         .open           = pcd_block_open,
 276         .release        = pcd_block_release,
 277         .ioctl          = pcd_block_ioctl,
 278 #ifdef CONFIG_COMPAT
 279         .compat_ioctl   = blkdev_compat_ptr_ioctl,
 280 #endif
 281         .check_events   = pcd_block_check_events,
 282 };
 283
 284 static const struct cdrom_device_ops pcd_dops = {
 285         .open           = pcd_open,
 286         .release        = pcd_release,
 287         .drive_status   = pcd_drive_status,
 288         .check_events   = pcd_check_events,
 289         .tray_move      = pcd_tray_move,
 290         .lock_door      = pcd_lock_door,
 291         .get_mcn        = pcd_get_mcn,
 292         .reset          = pcd_drive_reset,
 293         .audio_ioctl    = pcd_audio_ioctl,
 294         .generic_packet = pcd_packet,
 295         .capability     = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
 296                           CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
 297                           CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
 298                           CDC_CD_RW,
 299 };
 300
 301 static const struct blk_mq_ops pcd_mq_ops = {
 302         .queue_rq       = pcd_queue_rq,
 303 };
 304
 305 static void pcd_init_units(void)
 306 {
 307         struct pcd_unit *cd;
 308         int unit;
 309
 310         pcd_drive_count = 0;
 311         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 312                 struct gendisk *disk = alloc_disk(1);
 313
 314                 if (!disk)
 315                         continue;
 316
 317                 disk->queue = blk_mq_init_sq_queue(&cd->tag_set, &pcd_mq_ops,
 318                                                    1, BLK_MQ_F_SHOULD_MERGE);
 319                 if (IS_ERR(disk->queue)) {
 320                         disk->queue = NULL;
 321                         put_disk(disk);
 322                         continue;
 323                 }
 324
 325                 INIT_LIST_HEAD(&cd->rq_list);
 326                 disk->queue->queuedata = cd;
 327                 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
 328                 cd->disk = disk;
 329                 cd->pi = &cd->pia;
 330                 cd->present = 0;
 331                 cd->last_sense = 0;
 332                 cd->changed = 1;
 333                 cd->drive = (*drives[unit])[D_SLV];
 334                 if ((*drives[unit])[D_PRT])
 335                         pcd_drive_count++;
 336
 337                 cd->name = &cd->info.name[0];
 338                 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
 339                 cd->info.ops = &pcd_dops;
 340                 cd->info.handle = cd;
 341                 cd->info.speed = 0;
 342                 cd->info.capacity = 1;
 343                 cd->info.mask = 0;
 344                 disk->major = major;
 345                 disk->first_minor = unit;
 346                 strcpy(disk->disk_name, cd->name);      /* umm... */
 347                 disk->fops = &pcd_bdops;
 348                 disk->flags = GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
 349                 disk->events = DISK_EVENT_MEDIA_CHANGE;
 350         }
 351 }
 352
 353 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
 354 {
 355         struct pcd_unit *cd = cdi->handle;
 356         if (!cd->present)
 357                 return -ENODEV;
 358         return 0;
 359 }
 360
 361 static void pcd_release(struct cdrom_device_info *cdi)
 362 {
 363 }
 364
 365 static inline int status_reg(struct pcd_unit *cd)
 366 {
 367         return pi_read_regr(cd->pi, 1, 6);
 368 }
 369
 370 static inline int read_reg(struct pcd_unit *cd, int reg)
 371 {
 372         return pi_read_regr(cd->pi, 0, reg);
 373 }
 374
 375 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
 376 {
 377         pi_write_regr(cd->pi, 0, reg, val);
 378 }
 379
 380 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
 381 {
 382         int j, r, e, s, p;
 383
 384         j = 0;
 385         while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
 386                && (j++ < PCD_SPIN))
 387                 udelay(PCD_DELAY);
 388
 389         if ((r & (IDE_ERR & stop)) || (j > PCD_SPIN)) {
 390                 s = read_reg(cd, 7);
 391                 e = read_reg(cd, 1);
 392                 p = read_reg(cd, 2);
 393                 if (j > PCD_SPIN)
 394                         e |= 0x100;
 395                 if (fun)
 396                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 397                                " loop=%d phase=%d\n",
 398                                cd->name, fun, msg, r, s, e, j, p);
 399                 return (s << 8) + r;
 400         }
 401         return 0;
 402 }
 403
 404 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
 405 {
 406         pi_connect(cd->pi);
 407
 408         write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
 409
 410         if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
 411                 pi_disconnect(cd->pi);
 412                 return -1;
 413         }
 414
 415         write_reg(cd, 4, dlen % 256);
 416         write_reg(cd, 5, dlen / 256);
 417         write_reg(cd, 7, 0xa0); /* ATAPI packet command */
 418
 419         if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
 420                 pi_disconnect(cd->pi);
 421                 return -1;
 422         }
 423
 424         if (read_reg(cd, 2) != 1) {
 425                 printk("%s: %s: command phase error\n", cd->name, fun);
 426                 pi_disconnect(cd->pi);
 427                 return -1;
 428         }
 429
 430         pi_write_block(cd->pi, cmd, 12);
 431
 432         return 0;
 433 }
 434
 435 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
 436 {
 437         int r, d, p, n, k, j;
 438
 439         r = -1;
 440         k = 0;
 441         j = 0;
 442
 443         if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
 444                       fun, "completion")) {
 445                 r = 0;
 446                 while (read_reg(cd, 7) & IDE_DRQ) {
 447                         d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
 448                         n = (d + 3) & 0xfffc;
 449                         p = read_reg(cd, 2) & 3;
 450
 451                         if ((p == 2) && (n > 0) && (j == 0)) {
 452                                 pi_read_block(cd->pi, buf, n);
 453                                 if (verbose > 1)
 454                                         printk("%s: %s: Read %d bytes\n",
 455                                                cd->name, fun, n);
 456                                 r = 0;
 457                                 j++;
 458                         } else {
 459                                 if (verbose > 1)
 460                                         printk
 461                                             ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
 462                                              cd->name, fun, p, d, k);
 463                                 if (verbose < 2)
 464                                         printk_once(
 465                                             "%s: WARNING: ATAPI phase errors\n",
 466                                             cd->name);
 467                                 mdelay(1);
 468                         }
 469                         if (k++ > PCD_TMO) {
 470                                 printk("%s: Stuck DRQ\n", cd->name);
 471                                 break;
 472                         }
 473                         if (pcd_wait
 474                             (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
 475                              "completion")) {
 476                                 r = -1;
 477                                 break;
 478                         }
 479                 }
 480         }
 481
 482         pi_disconnect(cd->pi);
 483
 484         return r;
 485 }
 486
 487 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
 488 {
 489         char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 490         char buf[16];
 491         int r, c;
 492
 493         r = pcd_command(cd, rs_cmd, 16, "Request sense");
 494         mdelay(1);
 495         if (!r)
 496                 pcd_completion(cd, buf, "Request sense");
 497
 498         cd->last_sense = -1;
 499         c = 2;
 500         if (!r) {
 501                 if (fun)
 502                         printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
 503                                cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
 504                 c = buf[2] & 0xf;
 505                 cd->last_sense =
 506                     c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
 507         }
 508         if ((c == 2) || (c == 6))
 509                 cd->changed = 1;
 510 }
 511
 512 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
 513 {
 514         int r;
 515
 516         r = pcd_command(cd, cmd, dlen, fun);
 517         mdelay(1);
 518         if (!r)
 519                 r = pcd_completion(cd, buf, fun);
 520         if (r)
 521                 pcd_req_sense(cd, fun);
 522
 523         return r;
 524 }
 525
 526 static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
 527 {
 528         return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
 529                          "generic packet");
 530 }
 531
 532 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 533
 534 static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
 535                                      unsigned int clearing, int slot_nr)
 536 {
 537         struct pcd_unit *cd = cdi->handle;
 538         int res = cd->changed;
 539         if (res)
 540                 cd->changed = 0;
 541         return res ? DISK_EVENT_MEDIA_CHANGE : 0;
 542 }
 543
 544 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
 545 {
 546         char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
 547
 548         return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
 549                          lock ? "lock door" : "unlock door");
 550 }
 551
 552 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
 553 {
 554         char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
 555
 556         return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
 557                          position ? "eject" : "close tray");
 558 }
 559
 560 static void pcd_sleep(int cs)
 561 {
 562         schedule_timeout_interruptible(cs);
 563 }
 564
 565 static int pcd_reset(struct pcd_unit *cd)
 566 {
 567         int i, k, flg;
 568         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 569
 570         pi_connect(cd->pi);
 571         write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
 572         write_reg(cd, 7, 8);
 573
 574         pcd_sleep(20 * HZ / 1000);      /* delay a bit */
 575
 576         k = 0;
 577         while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
 578                 pcd_sleep(HZ / 10);
 579
 580         flg = 1;
 581         for (i = 0; i < 5; i++)
 582                 flg &= (read_reg(cd, i + 1) == expect[i]);
 583
 584         if (verbose) {
 585                 printk("%s: Reset (%d) signature = ", cd->name, k);
 586                 for (i = 0; i < 5; i++)
 587                         printk("%3x", read_reg(cd, i + 1));
 588                 if (!flg)
 589                         printk(" (incorrect)");
 590                 printk("\n");
 591         }
 592
 593         pi_disconnect(cd->pi);
 594         return flg - 1;
 595 }
 596
 597 static int pcd_drive_reset(struct cdrom_device_info *cdi)
 598 {
 599         return pcd_reset(cdi->handle);
 600 }
 601
 602 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
 603 {
 604         char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 605         int k, p;
 606
 607         k = 0;
 608         while (k < tmo) {
 609                 cd->last_sense = 0;
 610                 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
 611                 p = cd->last_sense;
 612                 if (!p)
 613                         return 0;
 614                 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
 615                         return p;
 616                 k++;
 617                 pcd_sleep(HZ);
 618         }
 619         return 0x000020;        /* timeout */
 620 }
 621
 622 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
 623 {
 624         char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 625         struct pcd_unit *cd = cdi->handle;
 626
 627         if (pcd_ready_wait(cd, PCD_READY_TMO))
 628                 return CDS_DRIVE_NOT_READY;
 629         if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
 630                 return CDS_NO_DISC;
 631         return CDS_DISC_OK;
 632 }
 633
 634 static int pcd_identify(struct pcd_unit *cd, char *id)
 635 {
 636         int k, s;
 637         char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 638
 639         pcd_bufblk = -1;
 640
 641         s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
 642
 643         if (s)
 644                 return -1;
 645         if ((pcd_buffer[0] & 0x1f) != 5) {
 646                 if (verbose)
 647                         printk("%s: %s is not a CD-ROM\n",
 648                                cd->name, cd->drive ? "Slave" : "Master");
 649                 return -1;
 650         }
 651         memcpy(id, pcd_buffer + 16, 16);
 652         id[16] = 0;
 653         k = 16;
 654         while ((k >= 0) && (id[k] <= 0x20)) {
 655                 id[k] = 0;
 656                 k--;
 657         }
 658
 659         printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
 660
 661         return 0;
 662 }
 663
 664 /*
 665  * returns  0, with id set if drive is detected
 666  *          -1, if drive detection failed
 667  */
 668 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
 669 {
 670         if (ms == -1) {
 671                 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
 672                         if (!pcd_reset(cd) && !pcd_identify(cd, id))
 673                                 return 0;
 674         } else {
 675                 cd->drive = ms;
 676                 if (!pcd_reset(cd) && !pcd_identify(cd, id))
 677                         return 0;
 678         }
 679         return -1;
 680 }
 681
 682 static void pcd_probe_capabilities(void)
 683 {
 684         int unit, r;
 685         char buffer[32];
 686         char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
 687         struct pcd_unit *cd;
 688
 689         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 690                 if (!cd->present)
 691                         continue;
 692                 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
 693                 if (r)
 694                         continue;
 695                 /* we should now have the cap page */
 696                 if ((buffer[11] & 1) == 0)
 697                         cd->info.mask |= CDC_CD_R;
 698                 if ((buffer[11] & 2) == 0)
 699                         cd->info.mask |= CDC_CD_RW;
 700                 if ((buffer[12] & 1) == 0)
 701                         cd->info.mask |= CDC_PLAY_AUDIO;
 702                 if ((buffer[14] & 1) == 0)
 703                         cd->info.mask |= CDC_LOCK;
 704                 if ((buffer[14] & 8) == 0)
 705                         cd->info.mask |= CDC_OPEN_TRAY;
 706                 if ((buffer[14] >> 6) == 0)
 707                         cd->info.mask |= CDC_CLOSE_TRAY;
 708         }
 709 }
 710
 711 static int pcd_detect(void)
 712 {
 713         char id[18];
 714         int k, unit;
 715         struct pcd_unit *cd;
 716
 717         printk("%s: %s version %s, major %d, nice %d\n",
 718                name, name, PCD_VERSION, major, nice);
 719
 720         par_drv = pi_register_driver(name);
 721         if (!par_drv) {
 722                 pr_err("failed to register %s driver\n", name);
 723                 return -1;
 724         }
 725
 726         k = 0;
 727         if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
 728                 cd = pcd;
 729                 if (cd->disk && pi_init(cd->pi, 1, -1, -1, -1, -1, -1,
 730                             pcd_buffer, PI_PCD, verbose, cd->name)) {
 731                         if (!pcd_probe(cd, -1, id)) {
 732                                 cd->present = 1;
 733                                 k++;
 734                         } else
 735                                 pi_release(cd->pi);
 736                 }
 737         } else {
 738                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 739                         int *conf = *drives[unit];
 740                         if (!conf[D_PRT])
 741                                 continue;
 742                         if (!cd->disk)
 743                                 continue;
 744                         if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
 745                                      conf[D_UNI], conf[D_PRO], conf[D_DLY],
 746                                      pcd_buffer, PI_PCD, verbose, cd->name))
 747                                 continue;
 748                         if (!pcd_probe(cd, conf[D_SLV], id)) {
 749                                 cd->present = 1;
 750                                 k++;
 751                         } else
 752                                 pi_release(cd->pi);
 753                 }
 754         }
 755         if (k)
 756                 return 0;
 757
 758         printk("%s: No CD-ROM drive found\n", name);
 759         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 760                 if (!cd->disk)
 761                         continue;
 762                 blk_cleanup_queue(cd->disk->queue);
 763                 cd->disk->queue = NULL;
 764                 blk_mq_free_tag_set(&cd->tag_set);
 765                 put_disk(cd->disk);
 766         }
 767         pi_unregister_driver(par_drv);
 768         return -1;
 769 }
 770
 771 /* I/O request processing */
 772 static int pcd_queue;
 773
 774 static int set_next_request(void)
 775 {
 776         struct pcd_unit *cd;
 777         int old_pos = pcd_queue;
 778
 779         do {
 780                 cd = &pcd[pcd_queue];
 781                 if (++pcd_queue == PCD_UNITS)
 782                         pcd_queue = 0;
 783                 if (cd->present && !list_empty(&cd->rq_list)) {
 784                         pcd_req = list_first_entry(&cd->rq_list, struct request,
 785                                                         queuelist);
 786                         list_del_init(&pcd_req->queuelist);
 787                         blk_mq_start_request(pcd_req);
 788                         break;
 789                 }
 790         } while (pcd_queue != old_pos);
 791
 792         return pcd_req != NULL;
 793 }
 794
 795 static void pcd_request(void)
 796 {
 797         struct pcd_unit *cd;
 798
 799         if (pcd_busy)
 800                 return;
 801
 802         if (!pcd_req && !set_next_request())
 803                 return;
 804
 805         cd = pcd_req->rq_disk->private_data;
 806         if (cd != pcd_current)
 807                 pcd_bufblk = -1;
 808         pcd_current = cd;
 809         pcd_sector = blk_rq_pos(pcd_req);
 810         pcd_count = blk_rq_cur_sectors(pcd_req);
 811         pcd_buf = bio_data(pcd_req->bio);
 812         pcd_busy = 1;
 813         ps_set_intr(do_pcd_read, NULL, 0, nice);
 814 }
 815
 816 static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
 817                                  const struct blk_mq_queue_data *bd)
 818 {
 819         struct pcd_unit *cd = hctx->queue->queuedata;
 820
 821         if (rq_data_dir(bd->rq) != READ) {
 822                 blk_mq_start_request(bd->rq);
 823                 return BLK_STS_IOERR;
 824         }
 825
 826         spin_lock_irq(&pcd_lock);
 827         list_add_tail(&bd->rq->queuelist, &cd->rq_list);
 828         pcd_request();
 829         spin_unlock_irq(&pcd_lock);
 830
 831         return BLK_STS_OK;
 832 }
 833
 834 static inline void next_request(blk_status_t err)
 835 {
 836         unsigned long saved_flags;
 837
 838         spin_lock_irqsave(&pcd_lock, saved_flags);
 839         if (!blk_update_request(pcd_req, err, blk_rq_cur_bytes(pcd_req))) {
 840                 __blk_mq_end_request(pcd_req, err);
 841                 pcd_req = NULL;
 842         }
 843         pcd_busy = 0;
 844         pcd_request();
 845         spin_unlock_irqrestore(&pcd_lock, saved_flags);
 846 }
 847
 848 static int pcd_ready(void)
 849 {
 850         return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
 851 }
 852
 853 static void pcd_transfer(void)
 854 {
 855
 856         while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
 857                 int o = (pcd_sector % 4) * 512;
 858                 memcpy(pcd_buf, pcd_buffer + o, 512);
 859                 pcd_count--;
 860                 pcd_buf += 512;
 861                 pcd_sector++;
 862         }
 863 }
 864
 865 static void pcd_start(void)
 866 {
 867         int b, i;
 868         char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
 869
 870         pcd_bufblk = pcd_sector / 4;
 871         b = pcd_bufblk;
 872         for (i = 0; i < 4; i++) {
 873                 rd_cmd[5 - i] = b & 0xff;
 874                 b = b >> 8;
 875         }
 876
 877         if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
 878                 pcd_bufblk = -1;
 879                 next_request(BLK_STS_IOERR);
 880                 return;
 881         }
 882
 883         mdelay(1);
 884
 885         ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
 886 }
 887
 888 static void do_pcd_read(void)
 889 {
 890         pcd_busy = 1;
 891         pcd_retries = 0;
 892         pcd_transfer();
 893         if (!pcd_count) {
 894                 next_request(0);
 895                 return;
 896         }
 897
 898         pi_do_claimed(pcd_current->pi, pcd_start);
 899 }
 900
 901 static void do_pcd_read_drq(void)
 902 {
 903         unsigned long saved_flags;
 904
 905         if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
 906                 if (pcd_retries < PCD_RETRIES) {
 907                         mdelay(1);
 908                         pcd_retries++;
 909                         pi_do_claimed(pcd_current->pi, pcd_start);
 910                         return;
 911                 }
 912                 pcd_bufblk = -1;
 913                 next_request(BLK_STS_IOERR);
 914                 return;
 915         }
 916
 917         do_pcd_read();
 918         spin_lock_irqsave(&pcd_lock, saved_flags);
 919         pcd_request();
 920         spin_unlock_irqrestore(&pcd_lock, saved_flags);
 921 }
 922
 923 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
 924
 925 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
 926 {
 927         struct pcd_unit *cd = cdi->handle;
 928
 929         switch (cmd) {
 930
 931         case CDROMREADTOCHDR:
 932
 933                 {
 934                         char cmd[12] =
 935                             { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
 936                          0, 0, 0 };
 937                         struct cdrom_tochdr *tochdr =
 938                             (struct cdrom_tochdr *) arg;
 939                         char buffer[32];
 940                         int r;
 941
 942                         r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
 943
 944                         tochdr->cdth_trk0 = buffer[2];
 945                         tochdr->cdth_trk1 = buffer[3];
 946
 947                         return r ? -EIO : 0;
 948                 }
 949
 950         case CDROMREADTOCENTRY:
 951
 952                 {
 953                         char cmd[12] =
 954                             { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
 955                          0, 0, 0 };
 956
 957                         struct cdrom_tocentry *tocentry =
 958                             (struct cdrom_tocentry *) arg;
 959                         unsigned char buffer[32];
 960                         int r;
 961
 962                         cmd[1] =
 963                             (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
 964                         cmd[6] = tocentry->cdte_track;
 965
 966                         r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
 967
 968                         tocentry->cdte_ctrl = buffer[5] & 0xf;
 969                         tocentry->cdte_adr = buffer[5] >> 4;
 970                         tocentry->cdte_datamode =
 971                             (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
 972                         if (tocentry->cdte_format == CDROM_MSF) {
 973                                 tocentry->cdte_addr.msf.minute = buffer[9];
 974                                 tocentry->cdte_addr.msf.second = buffer[10];
 975                                 tocentry->cdte_addr.msf.frame = buffer[11];
 976                         } else
 977                                 tocentry->cdte_addr.lba =
 978                                     (((((buffer[8] << 8) + buffer[9]) << 8)
 979                                       + buffer[10]) << 8) + buffer[11];
 980
 981                         return r ? -EIO : 0;
 982                 }
 983
 984         default:
 985
 986                 return -ENOSYS;
 987         }
 988 }
 989
 990 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
 991 {
 992         char cmd[12] =
 993             { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
 994         char buffer[32];
 995
 996         if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
 997                 return -EIO;
 998
 999         memcpy(mcn->medium_catalog_number, buffer + 9, 13);
1000         mcn->medium_catalog_number[13] = 0;
1001
1002         return 0;
1003 }
1004
1005 static int __init pcd_init(void)
1006 {
1007         struct pcd_unit *cd;
1008         int unit;
1009
1010         if (disable)
1011                 return -EINVAL;
1012
1013         pcd_init_units();
1014
1015         if (pcd_detect())
1016                 return -ENODEV;
1017
1018         /* get the atapi capabilities page */
1019         pcd_probe_capabilities();
1020
1021         if (register_blkdev(major, name)) {
1022                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1023                         if (!cd->disk)
1024                                 continue;
1025
1026                         blk_cleanup_queue(cd->disk->queue);
1027                         blk_mq_free_tag_set(&cd->tag_set);
1028                         put_disk(cd->disk);
1029                 }
1030                 return -EBUSY;
1031         }
1032
1033         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1034                 if (cd->present) {
1035                         register_cdrom(cd->disk, &cd->info);
1036                         cd->disk->private_data = cd;
1037                         add_disk(cd->disk);
1038                 }
1039         }
1040
1041         return 0;
1042 }
1043
1044 static void __exit pcd_exit(void)
1045 {
1046         struct pcd_unit *cd;
1047         int unit;
1048
1049         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1050                 if (!cd->disk)
1051                         continue;
1052
1053                 if (cd->present) {
1054                         del_gendisk(cd->disk);
1055                         pi_release(cd->pi);
1056                         unregister_cdrom(&cd->info);
1057                 }
1058                 blk_cleanup_queue(cd->disk->queue);
1059                 blk_mq_free_tag_set(&cd->tag_set);
1060                 put_disk(cd->disk);
1061         }
1062         unregister_blkdev(major, name);
1063         pi_unregister_driver(par_drv);
1064 }
1065
1066 MODULE_LICENSE("GPL");
1067 module_init(pcd_init)
1068 module_exit(pcd_exit)