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 overide 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 kernel
  73         the following 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/blkdev.h>
 141 #include <linux/smp_lock.h>
 142 #include <asm/uaccess.h>
 143
 144 static DEFINE_SPINLOCK(pcd_lock);
 145
 146 module_param(verbose, bool, 0644);
 147 module_param(major, int, 0);
 148 module_param(name, charp, 0);
 149 module_param(nice, int, 0);
 150 module_param_array(drive0, int, NULL, 0);
 151 module_param_array(drive1, int, NULL, 0);
 152 module_param_array(drive2, int, NULL, 0);
 153 module_param_array(drive3, int, NULL, 0);
 154
 155 #include "paride.h"
 156 #include "pseudo.h"
 157
 158 #define PCD_RETRIES          5
 159 #define PCD_TMO            800  /* timeout in jiffies */
 160 #define PCD_DELAY           50  /* spin delay in uS */
 161 #define PCD_READY_TMO       20  /* in seconds */
 162 #define PCD_RESET_TMO      100  /* in tenths of a second */
 163
 164 #define PCD_SPIN        (1000000*PCD_TMO)/(HZ*PCD_DELAY)
 165
 166 #define IDE_ERR         0x01
 167 #define IDE_DRQ         0x08
 168 #define IDE_READY       0x40
 169 #define IDE_BUSY        0x80
 170
 171 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
 172 static void pcd_release(struct cdrom_device_info *cdi);
 173 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
 174 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr);
 175 static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
 176 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
 177 static int pcd_drive_reset(struct cdrom_device_info *cdi);
 178 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn);
 179 static int pcd_audio_ioctl(struct cdrom_device_info *cdi,
 180                            unsigned int cmd, void *arg);
 181 static int pcd_packet(struct cdrom_device_info *cdi,
 182                       struct packet_command *cgc);
 183
 184 static int pcd_detect(void);
 185 static void pcd_probe_capabilities(void);
 186 static void do_pcd_read_drq(void);
 187 static void do_pcd_request(struct request_queue * q);
 188 static void do_pcd_read(void);
 189
 190 struct pcd_unit {
 191         struct pi_adapter pia;  /* interface to paride layer */
 192         struct pi_adapter *pi;
 193         int drive;              /* master/slave */
 194         int last_sense;         /* result of last request sense */
 195         int changed;            /* media change seen */
 196         int present;            /* does this unit exist ? */
 197         char *name;             /* pcd0, pcd1, etc */
 198         struct cdrom_device_info info;  /* uniform cdrom interface */
 199         struct gendisk *disk;
 200 };
 201
 202 static struct pcd_unit pcd[PCD_UNITS];
 203
 204 static char pcd_scratch[64];
 205 static char pcd_buffer[2048];   /* raw block buffer */
 206 static int pcd_bufblk = -1;     /* block in buffer, in CD units,
 207                                    -1 for nothing there. See also
 208                                    pd_unit.
 209                                  */
 210
 211 /* the variables below are used mainly in the I/O request engine, which
 212    processes only one request at a time.
 213 */
 214
 215 static struct pcd_unit *pcd_current; /* current request's drive */
 216 static struct request *pcd_req;
 217 static int pcd_retries;         /* retries on current request */
 218 static int pcd_busy;            /* request being processed ? */
 219 static int pcd_sector;          /* address of next requested sector */
 220 static int pcd_count;           /* number of blocks still to do */
 221 static char *pcd_buf;           /* buffer for request in progress */
 222
 223 /* kernel glue structures */
 224
 225 static int pcd_block_open(struct block_device *bdev, fmode_t mode)
 226 {
 227         struct pcd_unit *cd = bdev->bd_disk->private_data;
 228         int ret;
 229
 230         lock_kernel();
 231         ret = cdrom_open(&cd->info, bdev, mode);
 232         unlock_kernel();
 233
 234         return ret;
 235 }
 236
 237 static int pcd_block_release(struct gendisk *disk, fmode_t mode)
 238 {
 239         struct pcd_unit *cd = disk->private_data;
 240         lock_kernel();
 241         cdrom_release(&cd->info, mode);
 242         unlock_kernel();
 243         return 0;
 244 }
 245
 246 static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
 247                                 unsigned cmd, unsigned long arg)
 248 {
 249         struct pcd_unit *cd = bdev->bd_disk->private_data;
 250         int ret;
 251
 252         lock_kernel();
 253         ret = cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
 254         unlock_kernel();
 255
 256         return ret;
 257 }
 258
 259 static int pcd_block_media_changed(struct gendisk *disk)
 260 {
 261         struct pcd_unit *cd = disk->private_data;
 262         return cdrom_media_changed(&cd->info);
 263 }
 264
 265 static const struct block_device_operations pcd_bdops = {
 266         .owner          = THIS_MODULE,
 267         .open           = pcd_block_open,
 268         .release        = pcd_block_release,
 269         .ioctl          = pcd_block_ioctl,
 270         .media_changed  = pcd_block_media_changed,
 271 };
 272
 273 static struct cdrom_device_ops pcd_dops = {
 274         .open           = pcd_open,
 275         .release        = pcd_release,
 276         .drive_status   = pcd_drive_status,
 277         .media_changed  = pcd_media_changed,
 278         .tray_move      = pcd_tray_move,
 279         .lock_door      = pcd_lock_door,
 280         .get_mcn        = pcd_get_mcn,
 281         .reset          = pcd_drive_reset,
 282         .audio_ioctl    = pcd_audio_ioctl,
 283         .generic_packet = pcd_packet,
 284         .capability     = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
 285                           CDC_MCN | CDC_MEDIA_CHANGED | CDC_RESET |
 286                           CDC_PLAY_AUDIO | CDC_GENERIC_PACKET | CDC_CD_R |
 287                           CDC_CD_RW,
 288 };
 289
 290 static void pcd_init_units(void)
 291 {
 292         struct pcd_unit *cd;
 293         int unit;
 294
 295         pcd_drive_count = 0;
 296         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 297                 struct gendisk *disk = alloc_disk(1);
 298                 if (!disk)
 299                         continue;
 300                 cd->disk = disk;
 301                 cd->pi = &cd->pia;
 302                 cd->present = 0;
 303                 cd->last_sense = 0;
 304                 cd->changed = 1;
 305                 cd->drive = (*drives[unit])[D_SLV];
 306                 if ((*drives[unit])[D_PRT])
 307                         pcd_drive_count++;
 308
 309                 cd->name = &cd->info.name[0];
 310                 snprintf(cd->name, sizeof(cd->info.name), "%s%d", name, unit);
 311                 cd->info.ops = &pcd_dops;
 312                 cd->info.handle = cd;
 313                 cd->info.speed = 0;
 314                 cd->info.capacity = 1;
 315                 cd->info.mask = 0;
 316                 disk->major = major;
 317                 disk->first_minor = unit;
 318                 strcpy(disk->disk_name, cd->name);      /* umm... */
 319                 disk->fops = &pcd_bdops;
 320         }
 321 }
 322
 323 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
 324 {
 325         struct pcd_unit *cd = cdi->handle;
 326         if (!cd->present)
 327                 return -ENODEV;
 328         return 0;
 329 }
 330
 331 static void pcd_release(struct cdrom_device_info *cdi)
 332 {
 333 }
 334
 335 static inline int status_reg(struct pcd_unit *cd)
 336 {
 337         return pi_read_regr(cd->pi, 1, 6);
 338 }
 339
 340 static inline int read_reg(struct pcd_unit *cd, int reg)
 341 {
 342         return pi_read_regr(cd->pi, 0, reg);
 343 }
 344
 345 static inline void write_reg(struct pcd_unit *cd, int reg, int val)
 346 {
 347         pi_write_regr(cd->pi, 0, reg, val);
 348 }
 349
 350 static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
 351 {
 352         int j, r, e, s, p;
 353
 354         j = 0;
 355         while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop))))
 356                && (j++ < PCD_SPIN))
 357                 udelay(PCD_DELAY);
 358
 359         if ((r & (IDE_ERR & stop)) || (j > PCD_SPIN)) {
 360                 s = read_reg(cd, 7);
 361                 e = read_reg(cd, 1);
 362                 p = read_reg(cd, 2);
 363                 if (j > PCD_SPIN)
 364                         e |= 0x100;
 365                 if (fun)
 366                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 367                                " loop=%d phase=%d\n",
 368                                cd->name, fun, msg, r, s, e, j, p);
 369                 return (s << 8) + r;
 370         }
 371         return 0;
 372 }
 373
 374 static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun)
 375 {
 376         pi_connect(cd->pi);
 377
 378         write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
 379
 380         if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) {
 381                 pi_disconnect(cd->pi);
 382                 return -1;
 383         }
 384
 385         write_reg(cd, 4, dlen % 256);
 386         write_reg(cd, 5, dlen / 256);
 387         write_reg(cd, 7, 0xa0); /* ATAPI packet command */
 388
 389         if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) {
 390                 pi_disconnect(cd->pi);
 391                 return -1;
 392         }
 393
 394         if (read_reg(cd, 2) != 1) {
 395                 printk("%s: %s: command phase error\n", cd->name, fun);
 396                 pi_disconnect(cd->pi);
 397                 return -1;
 398         }
 399
 400         pi_write_block(cd->pi, cmd, 12);
 401
 402         return 0;
 403 }
 404
 405 static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun)
 406 {
 407         int r, d, p, n, k, j;
 408
 409         r = -1;
 410         k = 0;
 411         j = 0;
 412
 413         if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR,
 414                       fun, "completion")) {
 415                 r = 0;
 416                 while (read_reg(cd, 7) & IDE_DRQ) {
 417                         d = read_reg(cd, 4) + 256 * read_reg(cd, 5);
 418                         n = (d + 3) & 0xfffc;
 419                         p = read_reg(cd, 2) & 3;
 420
 421                         if ((p == 2) && (n > 0) && (j == 0)) {
 422                                 pi_read_block(cd->pi, buf, n);
 423                                 if (verbose > 1)
 424                                         printk("%s: %s: Read %d bytes\n",
 425                                                cd->name, fun, n);
 426                                 r = 0;
 427                                 j++;
 428                         } else {
 429                                 if (verbose > 1)
 430                                         printk
 431                                             ("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
 432                                              cd->name, fun, p, d, k);
 433                                 if (verbose < 2)
 434                                         printk_once(
 435                                             "%s: WARNING: ATAPI phase errors\n",
 436                                             cd->name);
 437                                 mdelay(1);
 438                         }
 439                         if (k++ > PCD_TMO) {
 440                                 printk("%s: Stuck DRQ\n", cd->name);
 441                                 break;
 442                         }
 443                         if (pcd_wait
 444                             (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun,
 445                              "completion")) {
 446                                 r = -1;
 447                                 break;
 448                         }
 449                 }
 450         }
 451
 452         pi_disconnect(cd->pi);
 453
 454         return r;
 455 }
 456
 457 static void pcd_req_sense(struct pcd_unit *cd, char *fun)
 458 {
 459         char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 460         char buf[16];
 461         int r, c;
 462
 463         r = pcd_command(cd, rs_cmd, 16, "Request sense");
 464         mdelay(1);
 465         if (!r)
 466                 pcd_completion(cd, buf, "Request sense");
 467
 468         cd->last_sense = -1;
 469         c = 2;
 470         if (!r) {
 471                 if (fun)
 472                         printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
 473                                cd->name, fun, buf[2] & 0xf, buf[12], buf[13]);
 474                 c = buf[2] & 0xf;
 475                 cd->last_sense =
 476                     c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16);
 477         }
 478         if ((c == 2) || (c == 6))
 479                 cd->changed = 1;
 480 }
 481
 482 static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun)
 483 {
 484         int r;
 485
 486         r = pcd_command(cd, cmd, dlen, fun);
 487         mdelay(1);
 488         if (!r)
 489                 r = pcd_completion(cd, buf, fun);
 490         if (r)
 491                 pcd_req_sense(cd, fun);
 492
 493         return r;
 494 }
 495
 496 static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
 497 {
 498         return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer,
 499                          "generic packet");
 500 }
 501
 502 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 503
 504 static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)
 505 {
 506         struct pcd_unit *cd = cdi->handle;
 507         int res = cd->changed;
 508         if (res)
 509                 cd->changed = 0;
 510         return res;
 511 }
 512
 513 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
 514 {
 515         char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 };
 516
 517         return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch,
 518                          lock ? "lock door" : "unlock door");
 519 }
 520
 521 static int pcd_tray_move(struct cdrom_device_info *cdi, int position)
 522 {
 523         char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 };
 524
 525         return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch,
 526                          position ? "eject" : "close tray");
 527 }
 528
 529 static void pcd_sleep(int cs)
 530 {
 531         schedule_timeout_interruptible(cs);
 532 }
 533
 534 static int pcd_reset(struct pcd_unit *cd)
 535 {
 536         int i, k, flg;
 537         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 538
 539         pi_connect(cd->pi);
 540         write_reg(cd, 6, 0xa0 + 0x10 * cd->drive);
 541         write_reg(cd, 7, 8);
 542
 543         pcd_sleep(20 * HZ / 1000);      /* delay a bit */
 544
 545         k = 0;
 546         while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY))
 547                 pcd_sleep(HZ / 10);
 548
 549         flg = 1;
 550         for (i = 0; i < 5; i++)
 551                 flg &= (read_reg(cd, i + 1) == expect[i]);
 552
 553         if (verbose) {
 554                 printk("%s: Reset (%d) signature = ", cd->name, k);
 555                 for (i = 0; i < 5; i++)
 556                         printk("%3x", read_reg(cd, i + 1));
 557                 if (!flg)
 558                         printk(" (incorrect)");
 559                 printk("\n");
 560         }
 561
 562         pi_disconnect(cd->pi);
 563         return flg - 1;
 564 }
 565
 566 static int pcd_drive_reset(struct cdrom_device_info *cdi)
 567 {
 568         return pcd_reset(cdi->handle);
 569 }
 570
 571 static int pcd_ready_wait(struct pcd_unit *cd, int tmo)
 572 {
 573         char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 574         int k, p;
 575
 576         k = 0;
 577         while (k < tmo) {
 578                 cd->last_sense = 0;
 579                 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready"));
 580                 p = cd->last_sense;
 581                 if (!p)
 582                         return 0;
 583                 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
 584                         return p;
 585                 k++;
 586                 pcd_sleep(HZ);
 587         }
 588         return 0x000020;        /* timeout */
 589 }
 590
 591 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
 592 {
 593         char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 594         struct pcd_unit *cd = cdi->handle;
 595
 596         if (pcd_ready_wait(cd, PCD_READY_TMO))
 597                 return CDS_DRIVE_NOT_READY;
 598         if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media")))
 599                 return CDS_NO_DISC;
 600         return CDS_DISC_OK;
 601 }
 602
 603 static int pcd_identify(struct pcd_unit *cd, char *id)
 604 {
 605         int k, s;
 606         char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 607
 608         pcd_bufblk = -1;
 609
 610         s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify");
 611
 612         if (s)
 613                 return -1;
 614         if ((pcd_buffer[0] & 0x1f) != 5) {
 615                 if (verbose)
 616                         printk("%s: %s is not a CD-ROM\n",
 617                                cd->name, cd->drive ? "Slave" : "Master");
 618                 return -1;
 619         }
 620         memcpy(id, pcd_buffer + 16, 16);
 621         id[16] = 0;
 622         k = 16;
 623         while ((k >= 0) && (id[k] <= 0x20)) {
 624                 id[k] = 0;
 625                 k--;
 626         }
 627
 628         printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id);
 629
 630         return 0;
 631 }
 632
 633 /*
 634  * returns  0, with id set if drive is detected
 635  *          -1, if drive detection failed
 636  */
 637 static int pcd_probe(struct pcd_unit *cd, int ms, char *id)
 638 {
 639         if (ms == -1) {
 640                 for (cd->drive = 0; cd->drive <= 1; cd->drive++)
 641                         if (!pcd_reset(cd) && !pcd_identify(cd, id))
 642                                 return 0;
 643         } else {
 644                 cd->drive = ms;
 645                 if (!pcd_reset(cd) && !pcd_identify(cd, id))
 646                         return 0;
 647         }
 648         return -1;
 649 }
 650
 651 static void pcd_probe_capabilities(void)
 652 {
 653         int unit, r;
 654         char buffer[32];
 655         char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 };
 656         struct pcd_unit *cd;
 657
 658         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 659                 if (!cd->present)
 660                         continue;
 661                 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities");
 662                 if (r)
 663                         continue;
 664                 /* we should now have the cap page */
 665                 if ((buffer[11] & 1) == 0)
 666                         cd->info.mask |= CDC_CD_R;
 667                 if ((buffer[11] & 2) == 0)
 668                         cd->info.mask |= CDC_CD_RW;
 669                 if ((buffer[12] & 1) == 0)
 670                         cd->info.mask |= CDC_PLAY_AUDIO;
 671                 if ((buffer[14] & 1) == 0)
 672                         cd->info.mask |= CDC_LOCK;
 673                 if ((buffer[14] & 8) == 0)
 674                         cd->info.mask |= CDC_OPEN_TRAY;
 675                 if ((buffer[14] >> 6) == 0)
 676                         cd->info.mask |= CDC_CLOSE_TRAY;
 677         }
 678 }
 679
 680 static int pcd_detect(void)
 681 {
 682         char id[18];
 683         int k, unit;
 684         struct pcd_unit *cd;
 685
 686         printk("%s: %s version %s, major %d, nice %d\n",
 687                name, name, PCD_VERSION, major, nice);
 688
 689         k = 0;
 690         if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
 691                 cd = pcd;
 692                 if (pi_init(cd->pi, 1, -1, -1, -1, -1, -1, pcd_buffer,
 693                             PI_PCD, verbose, cd->name)) {
 694                         if (!pcd_probe(cd, -1, id) && cd->disk) {
 695                                 cd->present = 1;
 696                                 k++;
 697                         } else
 698                                 pi_release(cd->pi);
 699                 }
 700         } else {
 701                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 702                         int *conf = *drives[unit];
 703                         if (!conf[D_PRT])
 704                                 continue;
 705                         if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD],
 706                                      conf[D_UNI], conf[D_PRO], conf[D_DLY],
 707                                      pcd_buffer, PI_PCD, verbose, cd->name))
 708                                 continue;
 709                         if (!pcd_probe(cd, conf[D_SLV], id) && cd->disk) {
 710                                 cd->present = 1;
 711                                 k++;
 712                         } else
 713                                 pi_release(cd->pi);
 714                 }
 715         }
 716         if (k)
 717                 return 0;
 718
 719         printk("%s: No CD-ROM drive found\n", name);
 720         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
 721                 put_disk(cd->disk);
 722         return -1;
 723 }
 724
 725 /* I/O request processing */
 726 static struct request_queue *pcd_queue;
 727
 728 static void do_pcd_request(struct request_queue * q)
 729 {
 730         if (pcd_busy)
 731                 return;
 732         while (1) {
 733                 if (!pcd_req) {
 734                         pcd_req = blk_fetch_request(q);
 735                         if (!pcd_req)
 736                                 return;
 737                 }
 738
 739                 if (rq_data_dir(pcd_req) == READ) {
 740                         struct pcd_unit *cd = pcd_req->rq_disk->private_data;
 741                         if (cd != pcd_current)
 742                                 pcd_bufblk = -1;
 743                         pcd_current = cd;
 744                         pcd_sector = blk_rq_pos(pcd_req);
 745                         pcd_count = blk_rq_cur_sectors(pcd_req);
 746                         pcd_buf = pcd_req->buffer;
 747                         pcd_busy = 1;
 748                         ps_set_intr(do_pcd_read, NULL, 0, nice);
 749                         return;
 750                 } else {
 751                         __blk_end_request_all(pcd_req, -EIO);
 752                         pcd_req = NULL;
 753                 }
 754         }
 755 }
 756
 757 static inline void next_request(int err)
 758 {
 759         unsigned long saved_flags;
 760
 761         spin_lock_irqsave(&pcd_lock, saved_flags);
 762         if (!__blk_end_request_cur(pcd_req, err))
 763                 pcd_req = NULL;
 764         pcd_busy = 0;
 765         do_pcd_request(pcd_queue);
 766         spin_unlock_irqrestore(&pcd_lock, saved_flags);
 767 }
 768
 769 static int pcd_ready(void)
 770 {
 771         return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ));
 772 }
 773
 774 static void pcd_transfer(void)
 775 {
 776
 777         while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) {
 778                 int o = (pcd_sector % 4) * 512;
 779                 memcpy(pcd_buf, pcd_buffer + o, 512);
 780                 pcd_count--;
 781                 pcd_buf += 512;
 782                 pcd_sector++;
 783         }
 784 }
 785
 786 static void pcd_start(void)
 787 {
 788         int b, i;
 789         char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
 790
 791         pcd_bufblk = pcd_sector / 4;
 792         b = pcd_bufblk;
 793         for (i = 0; i < 4; i++) {
 794                 rd_cmd[5 - i] = b & 0xff;
 795                 b = b >> 8;
 796         }
 797
 798         if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
 799                 pcd_bufblk = -1;
 800                 next_request(-EIO);
 801                 return;
 802         }
 803
 804         mdelay(1);
 805
 806         ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice);
 807 }
 808
 809 static void do_pcd_read(void)
 810 {
 811         pcd_busy = 1;
 812         pcd_retries = 0;
 813         pcd_transfer();
 814         if (!pcd_count) {
 815                 next_request(0);
 816                 return;
 817         }
 818
 819         pi_do_claimed(pcd_current->pi, pcd_start);
 820 }
 821
 822 static void do_pcd_read_drq(void)
 823 {
 824         unsigned long saved_flags;
 825
 826         if (pcd_completion(pcd_current, pcd_buffer, "read block")) {
 827                 if (pcd_retries < PCD_RETRIES) {
 828                         mdelay(1);
 829                         pcd_retries++;
 830                         pi_do_claimed(pcd_current->pi, pcd_start);
 831                         return;
 832                 }
 833                 pcd_bufblk = -1;
 834                 next_request(-EIO);
 835                 return;
 836         }
 837
 838         do_pcd_read();
 839         spin_lock_irqsave(&pcd_lock, saved_flags);
 840         do_pcd_request(pcd_queue);
 841         spin_unlock_irqrestore(&pcd_lock, saved_flags);
 842 }
 843
 844 /* the audio_ioctl stuff is adapted from sr_ioctl.c */
 845
 846 static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
 847 {
 848         struct pcd_unit *cd = cdi->handle;
 849
 850         switch (cmd) {
 851
 852         case CDROMREADTOCHDR:
 853
 854                 {
 855                         char cmd[12] =
 856                             { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
 857                          0, 0, 0 };
 858                         struct cdrom_tochdr *tochdr =
 859                             (struct cdrom_tochdr *) arg;
 860                         char buffer[32];
 861                         int r;
 862
 863                         r = pcd_atapi(cd, cmd, 12, buffer, "read toc header");
 864
 865                         tochdr->cdth_trk0 = buffer[2];
 866                         tochdr->cdth_trk1 = buffer[3];
 867
 868                         return r ? -EIO : 0;
 869                 }
 870
 871         case CDROMREADTOCENTRY:
 872
 873                 {
 874                         char cmd[12] =
 875                             { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12,
 876                          0, 0, 0 };
 877
 878                         struct cdrom_tocentry *tocentry =
 879                             (struct cdrom_tocentry *) arg;
 880                         unsigned char buffer[32];
 881                         int r;
 882
 883                         cmd[1] =
 884                             (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
 885                         cmd[6] = tocentry->cdte_track;
 886
 887                         r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry");
 888
 889                         tocentry->cdte_ctrl = buffer[5] & 0xf;
 890                         tocentry->cdte_adr = buffer[5] >> 4;
 891                         tocentry->cdte_datamode =
 892                             (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
 893                         if (tocentry->cdte_format == CDROM_MSF) {
 894                                 tocentry->cdte_addr.msf.minute = buffer[9];
 895                                 tocentry->cdte_addr.msf.second = buffer[10];
 896                                 tocentry->cdte_addr.msf.frame = buffer[11];
 897                         } else
 898                                 tocentry->cdte_addr.lba =
 899                                     (((((buffer[8] << 8) + buffer[9]) << 8)
 900                                       + buffer[10]) << 8) + buffer[11];
 901
 902                         return r ? -EIO : 0;
 903                 }
 904
 905         default:
 906
 907                 return -ENOSYS;
 908         }
 909 }
 910
 911 static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
 912 {
 913         char cmd[12] =
 914             { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 };
 915         char buffer[32];
 916
 917         if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn"))
 918                 return -EIO;
 919
 920         memcpy(mcn->medium_catalog_number, buffer + 9, 13);
 921         mcn->medium_catalog_number[13] = 0;
 922
 923         return 0;
 924 }
 925
 926 static int __init pcd_init(void)
 927 {
 928         struct pcd_unit *cd;
 929         int unit;
 930
 931         if (disable)
 932                 return -EINVAL;
 933
 934         pcd_init_units();
 935
 936         if (pcd_detect())
 937                 return -ENODEV;
 938
 939         /* get the atapi capabilities page */
 940         pcd_probe_capabilities();
 941
 942         if (register_blkdev(major, name)) {
 943                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
 944                         put_disk(cd->disk);
 945                 return -EBUSY;
 946         }
 947
 948         pcd_queue = blk_init_queue(do_pcd_request, &pcd_lock);
 949         if (!pcd_queue) {
 950                 unregister_blkdev(major, name);
 951                 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
 952                         put_disk(cd->disk);
 953                 return -ENOMEM;
 954         }
 955
 956         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 957                 if (cd->present) {
 958                         register_cdrom(&cd->info);
 959                         cd->disk->private_data = cd;
 960                         cd->disk->queue = pcd_queue;
 961                         add_disk(cd->disk);
 962                 }
 963         }
 964
 965         return 0;
 966 }
 967
 968 static void __exit pcd_exit(void)
 969 {
 970         struct pcd_unit *cd;
 971         int unit;
 972
 973         for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
 974                 if (cd->present) {
 975                         del_gendisk(cd->disk);
 976                         pi_release(cd->pi);
 977                         unregister_cdrom(&cd->info);
 978                 }
 979                 put_disk(cd->disk);
 980         }
 981         blk_cleanup_queue(pcd_queue);
 982         unregister_blkdev(major, name);
 983 }
 984
 985 MODULE_LICENSE("GPL");
 986 module_init(pcd_init)
 987 module_exit(pcd_exit)