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