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         check_disk_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         .check_events   = pcd_block_check_events,
 279 };
 280
 281 static const struct cdrom_device_ops pcd_dops = {
 282         .open           = pcd_open,
 283         .release        = pcd_release,
 284         .drive_status   = pcd_drive_status,
 285         .check_events   = pcd_check_events,
 286         .tray_move      = pcd_tray_move,
 287         .lock_door      = pcd_lock_door,
 288         .get_mcn        = pcd_get_mcn,
 289         .reset          = pcd_drive_reset,
 290         .audio_ioctl    = pcd_audio_ioctl,
 291         .generic_packet = pcd_packet,
 292         .capability     = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
 293                           CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
 294                           CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
 295                           CDC_CD_RW,
 296 };
 297
 298 static const struct blk_mq_ops pcd_mq_ops = {
 299         .queue_rq       = pcd_queue_rq,
 300 };
 301
 302 static void pcd_init_units(void)
 303 {
 304         struct pcd_unit *cd;
 305         int unit;
 306
 307         pcd_drive_count = 0;
 308         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 309                 struct gendisk *disk = alloc_disk(1);
 310
 311                 if (!disk)
 312                         continue;
 313
 314                 disk->queue = blk_mq_init_sq_queue(&cd->tag_set, &pcd_mq_ops,
 315                                                    1, BLK_MQ_F_SHOULD_MERGE);
 316                 if (IS_ERR(disk->queue)) {
 317                         disk->queue = NULL;
 318                         continue;
 319                 }
 320
 321                 INIT_LIST_HEAD(&cd->rq_list);
 322                 disk->queue->queuedata = cd;
 323                 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
 324                 cd->disk = disk;
 325                 cd->pi = &cd->pia;
 326                 cd->present = 0;
 327                 cd->last_sense = 0;
 328                 cd->changed = 1;
 329                 cd->drive = (*drives[unit])[D_SLV];
 330                 if ((*drives[unit])[D_PRT])
 331                         pcd_drive_count++;
 332
 333                 cd->name = &cd->info.name[0];
 334                 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
 335                 cd->info.ops = &pcd_dops;
 336                 cd->info.handle = cd;
 337                 cd->info.speed = 0;
 338                 cd->info.capacity = 1;
 339                 cd->info.mask = 0;
 340                 disk->major = major;
 341                 disk->first_minor = unit;
 342                 strcpy(disk->disk_name, cd->name);      /* umm... */
 343                 disk->fops = &pcd_bdops;
 344                 disk->flags = GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
 345         }
 346 }
 347
 348 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
 349 {
 350         struct pcd_unit *cd = cdi->handle;
 351         if (!cd->present)
 352                 return -ENODEV;
 353         return 0;
 354 }
 355
 356 static void pcd_release(struct cdrom_device_info *cdi)
 357 {
 358 }
 359
 360 static inline int status_reg(struct pcd_unit *cd)
 361 {
 362         return pi_read_regr(cd->pi, 1, 6);
 363 }
 364
 365 static inline int read_reg(struct pcd_unit *cd, int reg)
 366 {
 367         return pi_read_regr(cd->pi, 0, reg);
 368 }
 369
 370 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
 371 {
 372         pi_write_regr(cd->pi, 0, reg, val);
 373 }
 374
 375 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
 376 {
 377         int j, r, e, s, p;
 378
 379         j = 0;
 380         while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
 381                && (j++ < PCD_SPIN))
 382                 udelay(PCD_DELAY);
 383
 384         if ((r & (IDE_ERR & stop)) || (j > PCD_SPIN)) {
 385                 s = read_reg(cd, 7);
 386                 e = read_reg(cd, 1);
 387                 p = read_reg(cd, 2);
 388                 if (j > PCD_SPIN)
 389                         e |= 0x100;
 390                 if (fun)
 391                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 392                                " loop=%d phase=%d\n",
 393                                cd->name, fun, msg, r, s, e, j, p);
 394                 return (s << 8) + r;
 395         }
 396         return 0;
 397 }
 398
 399 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
 400 {
 401         pi_connect(cd->pi);
 402
 403         write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
 404
 405         if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
 406                 pi_disconnect(cd->pi);
 407                 return -1;
 408         }
 409
 410         write_reg(cd, 4, dlen % 256);
 411         write_reg(cd, 5, dlen / 256);
 412         write_reg(cd, 7, 0xa0); /* ATAPI packet command */
 413
 414         if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
 415                 pi_disconnect(cd->pi);
 416                 return -1;
 417         }
 418
 419         if (read_reg(cd, 2) != 1) {
 420                 printk("%s: %s: command phase error\n", cd->name, fun);
 421                 pi_disconnect(cd->pi);
 422                 return -1;
 423         }
 424
 425         pi_write_block(cd->pi, cmd, 12);
 426
 427         return 0;
 428 }
 429
 430 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
 431 {
 432         int r, d, p, n, k, j;
 433
 434         r = -1;
 435         k = 0;
 436         j = 0;
 437
 438         if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
 439                       fun, "completion")) {
 440                 r = 0;
 441                 while (read_reg(cd, 7) & IDE_DRQ) {
 442                         d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
 443                         n = (d + 3) & 0xfffc;
 444                         p = read_reg(cd, 2) & 3;
 445
 446                         if ((p == 2) && (n > 0) && (j == 0)) {
 447                                 pi_read_block(cd->pi, buf, n);
 448                                 if (verbose > 1)
 449                                         printk("%s: %s: Read %d bytes\n",
 450                                                cd->name, fun, n);
 451                                 r = 0;
 452                                 j++;
 453                         } else {
 454                                 if (verbose > 1)
 455                                         printk
 456                                             ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
 457                                              cd->name, fun, p, d, k);
 458                                 if (verbose < 2)
 459                                         printk_once(
 460                                             "%s: WARNING: ATAPI phase errors\n",
 461                                             cd->name);
 462                                 mdelay(1);
 463                         }
 464                         if (k++ > PCD_TMO) {
 465                                 printk("%s: Stuck DRQ\n", cd->name);
 466                                 break;
 467                         }
 468                         if (pcd_wait
 469                             (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
 470                              "completion")) {
 471                                 r = -1;
 472                                 break;
 473                         }
 474                 }
 475         }
 476
 477         pi_disconnect(cd->pi);
 478
 479         return r;
 480 }
 481
 482 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
 483 {
 484         char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 485         char buf[16];
 486         int r, c;
 487
 488         r = pcd_command(cd, rs_cmd, 16, "Request sense");
 489         mdelay(1);
 490         if (!r)
 491                 pcd_completion(cd, buf, "Request sense");
 492
 493         cd->last_sense = -1;
 494         c = 2;
 495         if (!r) {
 496                 if (fun)
 497                         printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
 498                                cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
 499                 c = buf[2] & 0xf;
 500                 cd->last_sense =
 501                     c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
 502         }
 503         if ((c == 2) || (c == 6))
 504                 cd->changed = 1;
 505 }
 506
 507 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
 508 {
 509         int r;
 510
 511         r = pcd_command(cd, cmd, dlen, fun);
 512         mdelay(1);
 513         if (!r)
 514                 r = pcd_completion(cd, buf, fun);
 515         if (r)
 516                 pcd_req_sense(cd, fun);
 517
 518         return r;
 519 }
 520
 521 static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
 522 {
 523         return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
 524                          "generic packet");
 525 }
 526
 527 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 528
 529 static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
 530                                      unsigned int clearing, int slot_nr)
 531 {
 532         struct pcd_unit *cd = cdi->handle;
 533         int res = cd->changed;
 534         if (res)
 535                 cd->changed = 0;
 536         return res ? DISK_EVENT_MEDIA_CHANGE : 0;
 537 }
 538
 539 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
 540 {
 541         char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
 542
 543         return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
 544                          lock ? "lock door" : "unlock door");
 545 }
 546
 547 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
 548 {
 549         char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
 550
 551         return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
 552                          position ? "eject" : "close tray");
 553 }
 554
 555 static void pcd_sleep(int cs)
 556 {
 557         schedule_timeout_interruptible(cs);
 558 }
 559
 560 static int pcd_reset(struct pcd_unit *cd)
 561 {
 562         int i, k, flg;
 563         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 564
 565         pi_connect(cd->pi);
 566         write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
 567         write_reg(cd, 7, 8);
 568
 569         pcd_sleep(20 * HZ / 1000);      /* delay a bit */
 570
 571         k = 0;
 572         while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
 573                 pcd_sleep(HZ / 10);
 574
 575         flg = 1;
 576         for (i = 0; i < 5; i++)
 577                 flg &= (read_reg(cd, i + 1) == expect[i]);
 578
 579         if (verbose) {
 580                 printk("%s: Reset (%d) signature = ", cd->name, k);
 581                 for (i = 0; i < 5; i++)
 582                         printk("%3x", read_reg(cd, i + 1));
 583                 if (!flg)
 584                         printk(" (incorrect)");
 585                 printk("\n");
 586         }
 587
 588         pi_disconnect(cd->pi);
 589         return flg - 1;
 590 }
 591
 592 static int pcd_drive_reset(struct cdrom_device_info *cdi)
 593 {
 594         return pcd_reset(cdi->handle);
 595 }
 596
 597 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
 598 {
 599         char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 600         int k, p;
 601
 602         k = 0;
 603         while (k < tmo) {
 604                 cd->last_sense = 0;
 605                 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
 606                 p = cd->last_sense;
 607                 if (!p)
 608                         return 0;
 609                 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
 610                         return p;
 611                 k++;
 612                 pcd_sleep(HZ);
 613         }
 614         return 0x000020;        /* timeout */
 615 }
 616
 617 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
 618 {
 619         char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 620         struct pcd_unit *cd = cdi->handle;
 621
 622         if (pcd_ready_wait(cd, PCD_READY_TMO))
 623                 return CDS_DRIVE_NOT_READY;
 624         if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
 625                 return CDS_NO_DISC;
 626         return CDS_DISC_OK;
 627 }
 628
 629 static int pcd_identify(struct pcd_unit *cd, char *id)
 630 {
 631         int k, s;
 632         char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 633
 634         pcd_bufblk = -1;
 635
 636         s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
 637
 638         if (s)
 639                 return -1;
 640         if ((pcd_buffer[0] & 0x1f) != 5) {
 641                 if (verbose)
 642                         printk("%s: %s is not a CD-ROM\n",
 643                                cd->name, cd->drive ? "Slave" : "Master");
 644                 return -1;
 645         }
 646         memcpy(id, pcd_buffer + 16, 16);
 647         id[16] = 0;
 648         k = 16;
 649         while ((k >= 0) && (id[k] <= 0x20)) {
 650                 id[k] = 0;
 651                 k--;
 652         }
 653
 654         printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
 655
 656         return 0;
 657 }
 658
 659 /*
 660  * returns  0, with id set if drive is detected
 661  *          -1, if drive detection failed
 662  */
 663 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
 664 {
 665         if (ms == -1) {
 666                 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
 667                         if (!pcd_reset(cd) && !pcd_identify(cd, id))
 668                                 return 0;
 669         } else {
 670                 cd->drive = ms;
 671                 if (!pcd_reset(cd) && !pcd_identify(cd, id))
 672                         return 0;
 673         }
 674         return -1;
 675 }
 676
 677 static void pcd_probe_capabilities(void)
 678 {
 679         int unit, r;
 680         char buffer[32];
 681         char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
 682         struct pcd_unit *cd;
 683
 684         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 685                 if (!cd->present)
 686                         continue;
 687                 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
 688                 if (r)
 689                         continue;
 690                 /* we should now have the cap page */
 691                 if ((buffer[11] & 1) == 0)
 692                         cd->info.mask |= CDC_CD_R;
 693                 if ((buffer[11] & 2) == 0)
 694                         cd->info.mask |= CDC_CD_RW;
 695                 if ((buffer[12] & 1) == 0)
 696                         cd->info.mask |= CDC_PLAY_AUDIO;
 697                 if ((buffer[14] & 1) == 0)
 698                         cd->info.mask |= CDC_LOCK;
 699                 if ((buffer[14] & 8) == 0)
 700                         cd->info.mask |= CDC_OPEN_TRAY;
 701                 if ((buffer[14] >> 6) == 0)
 702                         cd->info.mask |= CDC_CLOSE_TRAY;
 703         }
 704 }
 705
 706 static int pcd_detect(void)
 707 {
 708         char id[18];
 709         int k, unit;
 710         struct pcd_unit *cd;
 711
 712         printk("%s: %s version %s, major %d, nice %d\n",
 713                name, name, PCD_VERSION, major, nice);
 714
 715         par_drv = pi_register_driver(name);
 716         if (!par_drv) {
 717                 pr_err("failed to register %s driver\n", name);
 718                 return -1;
 719         }
 720
 721         k = 0;
 722         if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
 723                 cd = pcd;
 724                 if (pi_init(cd->pi, 1, -1, -1, -1, -1, -1, pcd_buffer,
 725                             PI_PCD, verbose, cd->name)) {
 726                         if (!pcd_probe(cd, -1, id) && cd->disk) {
 727                                 cd->present = 1;
 728                                 k++;
 729                         } else
 730                                 pi_release(cd->pi);
 731                 }
 732         } else {
 733                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 734                         int *conf = *drives[unit];
 735                         if (!conf[D_PRT])
 736                                 continue;
 737                         if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
 738                                      conf[D_UNI], conf[D_PRO], conf[D_DLY],
 739                                      pcd_buffer, PI_PCD, verbose, cd->name))
 740                                 continue;
 741                         if (!pcd_probe(cd, conf[D_SLV], id) && cd->disk) {
 742                                 cd->present = 1;
 743                                 k++;
 744                         } else
 745                                 pi_release(cd->pi);
 746                 }
 747         }
 748         if (k)
 749                 return 0;
 750
 751         printk("%s: No CD-ROM drive found\n", name);
 752         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 753                 blk_cleanup_queue(cd->disk->queue);
 754                 cd->disk->queue = NULL;
 755                 blk_mq_free_tag_set(&cd->tag_set);
 756                 put_disk(cd->disk);
 757         }
 758         pi_unregister_driver(par_drv);
 759         return -1;
 760 }
 761
 762 /* I/O request processing */
 763 static int pcd_queue;
 764
 765 static int set_next_request(void)
 766 {
 767         struct pcd_unit *cd;
 768         int old_pos = pcd_queue;
 769
 770         do {
 771                 cd = &pcd[pcd_queue];
 772                 if (++pcd_queue == PCD_UNITS)
 773                         pcd_queue = 0;
 774                 if (cd->present && !list_empty(&cd->rq_list)) {
 775                         pcd_req = list_first_entry(&cd->rq_list, struct request,
 776                                                         queuelist);
 777                         list_del_init(&pcd_req->queuelist);
 778                         blk_mq_start_request(pcd_req);
 779                         break;
 780                 }
 781         } while (pcd_queue != old_pos);
 782
 783         return pcd_req != NULL;
 784 }
 785
 786 static void pcd_request(void)
 787 {
 788         struct pcd_unit *cd;
 789
 790         if (pcd_busy)
 791                 return;
 792
 793         if (!pcd_req && !set_next_request())
 794                 return;
 795
 796         cd = pcd_req->rq_disk->private_data;
 797         if (cd != pcd_current)
 798                 pcd_bufblk = -1;
 799         pcd_current = cd;
 800         pcd_sector = blk_rq_pos(pcd_req);
 801         pcd_count = blk_rq_cur_sectors(pcd_req);
 802         pcd_buf = bio_data(pcd_req->bio);
 803         pcd_busy = 1;
 804         ps_set_intr(do_pcd_read, NULL, 0, nice);
 805 }
 806
 807 static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
 808                                  const struct blk_mq_queue_data *bd)
 809 {
 810         struct pcd_unit *cd = hctx->queue->queuedata;
 811
 812         if (rq_data_dir(bd->rq) != READ) {
 813                 blk_mq_start_request(bd->rq);
 814                 return BLK_STS_IOERR;
 815         }
 816
 817         spin_lock_irq(&pcd_lock);
 818         list_add_tail(&bd->rq->queuelist, &cd->rq_list);
 819         pcd_request();
 820         spin_unlock_irq(&pcd_lock);
 821
 822         return BLK_STS_OK;
 823 }
 824
 825 static inline void next_request(blk_status_t err)
 826 {
 827         unsigned long saved_flags;
 828
 829         spin_lock_irqsave(&pcd_lock, saved_flags);
 830         if (!blk_update_request(pcd_req, err, blk_rq_cur_bytes(pcd_req))) {
 831                 __blk_mq_end_request(pcd_req, err);
 832                 pcd_req = NULL;
 833         }
 834         pcd_busy = 0;
 835         pcd_request();
 836         spin_unlock_irqrestore(&pcd_lock, saved_flags);
 837 }
 838
 839 static int pcd_ready(void)
 840 {
 841         return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
 842 }
 843
 844 static void pcd_transfer(void)
 845 {
 846
 847         while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
 848                 int o = (pcd_sector % 4) * 512;
 849                 memcpy(pcd_buf, pcd_buffer + o, 512);
 850                 pcd_count--;
 851                 pcd_buf += 512;
 852                 pcd_sector++;
 853         }
 854 }
 855
 856 static void pcd_start(void)
 857 {
 858         int b, i;
 859         char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
 860
 861         pcd_bufblk = pcd_sector / 4;
 862         b = pcd_bufblk;
 863         for (i = 0; i < 4; i++) {
 864                 rd_cmd[5 - i] = b & 0xff;
 865                 b = b >> 8;
 866         }
 867
 868         if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
 869                 pcd_bufblk = -1;
 870                 next_request(BLK_STS_IOERR);
 871                 return;
 872         }
 873
 874         mdelay(1);
 875
 876         ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
 877 }
 878
 879 static void do_pcd_read(void)
 880 {
 881         pcd_busy = 1;
 882         pcd_retries = 0;
 883         pcd_transfer();
 884         if (!pcd_count) {
 885                 next_request(0);
 886                 return;
 887         }
 888
 889         pi_do_claimed(pcd_current->pi, pcd_start);
 890 }
 891
 892 static void do_pcd_read_drq(void)
 893 {
 894         unsigned long saved_flags;
 895
 896         if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
 897                 if (pcd_retries < PCD_RETRIES) {
 898                         mdelay(1);
 899                         pcd_retries++;
 900                         pi_do_claimed(pcd_current->pi, pcd_start);
 901                         return;
 902                 }
 903                 pcd_bufblk = -1;
 904                 next_request(BLK_STS_IOERR);
 905                 return;
 906         }
 907
 908         do_pcd_read();
 909         spin_lock_irqsave(&pcd_lock, saved_flags);
 910         pcd_request();
 911         spin_unlock_irqrestore(&pcd_lock, saved_flags);
 912 }
 913
 914 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
 915
 916 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
 917 {
 918         struct pcd_unit *cd = cdi->handle;
 919
 920         switch (cmd) {
 921
 922         case CDROMREADTOCHDR:
 923
 924                 {
 925                         char cmd[12] =
 926                             { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
 927                          0, 0, 0 };
 928                         struct cdrom_tochdr *tochdr =
 929                             (struct cdrom_tochdr *) arg;
 930                         char buffer[32];
 931                         int r;
 932
 933                         r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
 934
 935                         tochdr->cdth_trk0 = buffer[2];
 936                         tochdr->cdth_trk1 = buffer[3];
 937
 938                         return r ? -EIO : 0;
 939                 }
 940
 941         case CDROMREADTOCENTRY:
 942
 943                 {
 944                         char cmd[12] =
 945                             { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
 946                          0, 0, 0 };
 947
 948                         struct cdrom_tocentry *tocentry =
 949                             (struct cdrom_tocentry *) arg;
 950                         unsigned char buffer[32];
 951                         int r;
 952
 953                         cmd[1] =
 954                             (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
 955                         cmd[6] = tocentry->cdte_track;
 956
 957                         r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
 958
 959                         tocentry->cdte_ctrl = buffer[5] & 0xf;
 960                         tocentry->cdte_adr = buffer[5] >> 4;
 961                         tocentry->cdte_datamode =
 962                             (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
 963                         if (tocentry->cdte_format == CDROM_MSF) {
 964                                 tocentry->cdte_addr.msf.minute = buffer[9];
 965                                 tocentry->cdte_addr.msf.second = buffer[10];
 966                                 tocentry->cdte_addr.msf.frame = buffer[11];
 967                         } else
 968                                 tocentry->cdte_addr.lba =
 969                                     (((((buffer[8] << 8) + buffer[9]) << 8)
 970                                       + buffer[10]) << 8) + buffer[11];
 971
 972                         return r ? -EIO : 0;
 973                 }
 974
 975         default:
 976
 977                 return -ENOSYS;
 978         }
 979 }
 980
 981 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
 982 {
 983         char cmd[12] =
 984             { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
 985         char buffer[32];
 986
 987         if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
 988                 return -EIO;
 989
 990         memcpy(mcn->medium_catalog_number, buffer + 9, 13);
 991         mcn->medium_catalog_number[13] = 0;
 992
 993         return 0;
 994 }
 995
 996 static int __init pcd_init(void)
 997 {
 998         struct pcd_unit *cd;
 999         int unit;
1000
1001         if (disable)
1002                 return -EINVAL;
1003
1004         pcd_init_units();
1005
1006         if (pcd_detect())
1007                 return -ENODEV;
1008
1009         /* get the atapi capabilities page */
1010         pcd_probe_capabilities();
1011
1012         if (register_blkdev(major, name)) {
1013                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
1014                         put_disk(cd->disk);
1015                 return -EBUSY;
1016         }
1017
1018         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1019                 if (cd->present) {
1020                         register_cdrom(&cd->info);
1021                         cd->disk->private_data = cd;
1022                         add_disk(cd->disk);
1023                 }
1024         }
1025
1026         return 0;
1027 }
1028
1029 static void __exit pcd_exit(void)
1030 {
1031         struct pcd_unit *cd;
1032         int unit;
1033
1034         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
1035                 if (cd->present) {
1036                         del_gendisk(cd->disk);
1037                         pi_release(cd->pi);
1038                         unregister_cdrom(&cd->info);
1039                 }
1040                 blk_cleanup_queue(cd->disk->queue);
1041                 blk_mq_free_tag_set(&cd->tag_set);
1042                 put_disk(cd->disk);
1043         }
1044         unregister_blkdev(major, name);
1045         pi_unregister_driver(par_drv);
1046 }
1047
1048 MODULE_LICENSE("GPL");
1049 module_init(pcd_init)
1050 module_exit(pcd_exit)