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