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