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 the 73 following kernel command line parameters, with the same values 74 as the corresponding module parameters listed above: 75 76 pcd.drive0 77 pcd.drive1 78 pcd.drive2 79 pcd.drive3 80 pcd.nice 81 82 In addition, you can use the parameter pcd.disable to disable 83 the driver entirely. 84 85*/ 86 87/* Changes: 88 89 1.01 GRG 1998.01.24 Added test unit ready support 90 1.02 GRG 1998.05.06 Changes to pcd_completion, ready_wait, 91 and loosen interpretation of ATAPI 92 standard for clearing error status. 93 Use spinlocks. Eliminate sti(). 94 1.03 GRG 1998.06.16 Eliminated an Ugh 95 1.04 GRG 1998.08.15 Added extra debugging, improvements to 96 pcd_completion, use HZ in loop timing 97 1.05 GRG 1998.08.16 Conformed to "Uniform CD-ROM" standard 98 1.06 GRG 1998.08.19 Added audio ioctl support 99 1.07 GRG 1998.09.24 Increased reset timeout, added jumbo support 100 101*/ 102 103#define PCD_VERSION "1.07" 104#define PCD_MAJOR 46 105#define PCD_NAME "pcd" 106#define PCD_UNITS 4 107 108/* Here are things one can override from the insmod command. 109 Most are autoprobed by paride unless set here. Verbose is off 110 by default. 111 112*/ 113 114static int verbose = 0; 115static int major = PCD_MAJOR; 116static char *name = PCD_NAME; 117static int nice = 0; 118static int disable = 0; 119 120static int drive0[6] = { 0, 0, 0, -1, -1, -1 }; 121static int drive1[6] = { 0, 0, 0, -1, -1, -1 }; 122static int drive2[6] = { 0, 0, 0, -1, -1, -1 }; 123static int drive3[6] = { 0, 0, 0, -1, -1, -1 }; 124 125static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3}; 126static int pcd_drive_count; 127 128enum {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 144static DEFINE_MUTEX(pcd_mutex); 145static DEFINE_SPINLOCK(pcd_lock); 146 147module_param(verbose, int, 0644); 148module_param(major, int, 0); 149module_param(name, charp, 0); 150module_param(nice, int, 0); 151module_param_array(drive0, int, NULL, 0); 152module_param_array(drive1, int, NULL, 0); 153module_param_array(drive2, int, NULL, 0); 154module_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 172static int pcd_open(struct cdrom_device_info *cdi, int purpose); 173static void pcd_release(struct cdrom_device_info *cdi); 174static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr); 175static unsigned int pcd_check_events(struct cdrom_device_info *cdi, 176 unsigned int clearing, int slot_nr); 177static int pcd_tray_move(struct cdrom_device_info *cdi, int position); 178static int pcd_lock_door(struct cdrom_device_info *cdi, int lock); 179static int pcd_drive_reset(struct cdrom_device_info *cdi); 180static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn); 181static int pcd_audio_ioctl(struct cdrom_device_info *cdi, 182 unsigned int cmd, void *arg); 183static int pcd_packet(struct cdrom_device_info *cdi, 184 struct packet_command *cgc); 185 186static int pcd_detect(void); 187static void pcd_probe_capabilities(void); 188static void do_pcd_read_drq(void); 189static void do_pcd_request(struct request_queue * q); 190static void do_pcd_read(void); 191 192struct 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 204static struct pcd_unit pcd[PCD_UNITS]; 205 206static char pcd_scratch[64]; 207static char pcd_buffer[2048]; /* raw block buffer */ 208static 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 217static struct pcd_unit *pcd_current; /* current request's drive */ 218static struct request *pcd_req; 219static int pcd_retries; /* retries on current request */ 220static int pcd_busy; /* request being processed ? */ 221static int pcd_sector; /* address of next requested sector */ 222static int pcd_count; /* number of blocks still to do */ 223static char *pcd_buf; /* buffer for request in progress */ 224static void *par_drv; /* reference of parport driver */ 225 226/* kernel glue structures */ 227 228static int pcd_block_open(struct block_device *bdev, fmode_t mode) 229{ 230 struct pcd_unit *cd = bdev->bd_disk->private_data; 231 int ret; 232 233 mutex_lock(&pcd_mutex); 234 ret = cdrom_open(&cd->info, bdev, mode); 235 mutex_unlock(&pcd_mutex); 236 237 return ret; 238} 239 240static void pcd_block_release(struct gendisk *disk, fmode_t mode) 241{ 242 struct pcd_unit *cd = disk->private_data; 243 mutex_lock(&pcd_mutex); 244 cdrom_release(&cd->info, mode); 245 mutex_unlock(&pcd_mutex); 246} 247 248static 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 261static 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 268static 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 276static 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 293static 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 } 325} 326 327static int pcd_open(struct cdrom_device_info *cdi, int purpose) 328{ 329 struct pcd_unit *cd = cdi->handle; 330 if (!cd->present) 331 return -ENODEV; 332 return 0; 333} 334 335static void pcd_release(struct cdrom_device_info *cdi) 336{ 337} 338 339static inline int status_reg(struct pcd_unit *cd) 340{ 341 return pi_read_regr(cd->pi, 1, 6); 342} 343 344static inline int read_reg(struct pcd_unit *cd, int reg) 345{ 346 return pi_read_regr(cd->pi, 0, reg); 347} 348 349static inline void write_reg(struct pcd_unit *cd, int reg, int val) 350{ 351 pi_write_regr(cd->pi, 0, reg, val); 352} 353 354static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg) 355{ 356 int j, r, e, s, p; 357 358 j = 0; 359 while ((((r = status_reg(cd)) & go) || (stop && (!(r & stop)))) 360 && (j++ < PCD_SPIN)) 361 udelay(PCD_DELAY); 362 363 if ((r & (IDE_ERR & stop)) || (j > PCD_SPIN)) { 364 s = read_reg(cd, 7); 365 e = read_reg(cd, 1); 366 p = read_reg(cd, 2); 367 if (j > PCD_SPIN) 368 e |= 0x100; 369 if (fun) 370 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x" 371 " loop=%d phase=%d\n", 372 cd->name, fun, msg, r, s, e, j, p); 373 return (s << 8) + r; 374 } 375 return 0; 376} 377 378static int pcd_command(struct pcd_unit *cd, char *cmd, int dlen, char *fun) 379{ 380 pi_connect(cd->pi); 381 382 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive); 383 384 if (pcd_wait(cd, IDE_BUSY | IDE_DRQ, 0, fun, "before command")) { 385 pi_disconnect(cd->pi); 386 return -1; 387 } 388 389 write_reg(cd, 4, dlen % 256); 390 write_reg(cd, 5, dlen / 256); 391 write_reg(cd, 7, 0xa0); /* ATAPI packet command */ 392 393 if (pcd_wait(cd, IDE_BUSY, IDE_DRQ, fun, "command DRQ")) { 394 pi_disconnect(cd->pi); 395 return -1; 396 } 397 398 if (read_reg(cd, 2) != 1) { 399 printk("%s: %s: command phase error\n", cd->name, fun); 400 pi_disconnect(cd->pi); 401 return -1; 402 } 403 404 pi_write_block(cd->pi, cmd, 12); 405 406 return 0; 407} 408 409static int pcd_completion(struct pcd_unit *cd, char *buf, char *fun) 410{ 411 int r, d, p, n, k, j; 412 413 r = -1; 414 k = 0; 415 j = 0; 416 417 if (!pcd_wait(cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, 418 fun, "completion")) { 419 r = 0; 420 while (read_reg(cd, 7) & IDE_DRQ) { 421 d = read_reg(cd, 4) + 256 * read_reg(cd, 5); 422 n = (d + 3) & 0xfffc; 423 p = read_reg(cd, 2) & 3; 424 425 if ((p == 2) && (n > 0) && (j == 0)) { 426 pi_read_block(cd->pi, buf, n); 427 if (verbose > 1) 428 printk("%s: %s: Read %d bytes\n", 429 cd->name, fun, n); 430 r = 0; 431 j++; 432 } else { 433 if (verbose > 1) 434 printk 435 ("%s: %s: Unexpected phase %d, d=%d, k=%d\n", 436 cd->name, fun, p, d, k); 437 if (verbose < 2) 438 printk_once( 439 "%s: WARNING: ATAPI phase errors\n", 440 cd->name); 441 mdelay(1); 442 } 443 if (k++ > PCD_TMO) { 444 printk("%s: Stuck DRQ\n", cd->name); 445 break; 446 } 447 if (pcd_wait 448 (cd, IDE_BUSY, IDE_DRQ | IDE_READY | IDE_ERR, fun, 449 "completion")) { 450 r = -1; 451 break; 452 } 453 } 454 } 455 456 pi_disconnect(cd->pi); 457 458 return r; 459} 460 461static void pcd_req_sense(struct pcd_unit *cd, char *fun) 462{ 463 char rs_cmd[12] = { 0x03, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 }; 464 char buf[16]; 465 int r, c; 466 467 r = pcd_command(cd, rs_cmd, 16, "Request sense"); 468 mdelay(1); 469 if (!r) 470 pcd_completion(cd, buf, "Request sense"); 471 472 cd->last_sense = -1; 473 c = 2; 474 if (!r) { 475 if (fun) 476 printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n", 477 cd->name, fun, buf[2] & 0xf, buf[12], buf[13]); 478 c = buf[2] & 0xf; 479 cd->last_sense = 480 c | ((buf[12] & 0xff) << 8) | ((buf[13] & 0xff) << 16); 481 } 482 if ((c == 2) || (c == 6)) 483 cd->changed = 1; 484} 485 486static int pcd_atapi(struct pcd_unit *cd, char *cmd, int dlen, char *buf, char *fun) 487{ 488 int r; 489 490 r = pcd_command(cd, cmd, dlen, fun); 491 mdelay(1); 492 if (!r) 493 r = pcd_completion(cd, buf, fun); 494 if (r) 495 pcd_req_sense(cd, fun); 496 497 return r; 498} 499 500static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc) 501{ 502 return pcd_atapi(cdi->handle, cgc->cmd, cgc->buflen, cgc->buffer, 503 "generic packet"); 504} 505 506#define DBMSG(msg) ((verbose>1)?(msg):NULL) 507 508static unsigned int pcd_check_events(struct cdrom_device_info *cdi, 509 unsigned int clearing, int slot_nr) 510{ 511 struct pcd_unit *cd = cdi->handle; 512 int res = cd->changed; 513 if (res) 514 cd->changed = 0; 515 return res ? DISK_EVENT_MEDIA_CHANGE : 0; 516} 517 518static int pcd_lock_door(struct cdrom_device_info *cdi, int lock) 519{ 520 char un_cmd[12] = { 0x1e, 0, 0, 0, lock, 0, 0, 0, 0, 0, 0, 0 }; 521 522 return pcd_atapi(cdi->handle, un_cmd, 0, pcd_scratch, 523 lock ? "lock door" : "unlock door"); 524} 525 526static int pcd_tray_move(struct cdrom_device_info *cdi, int position) 527{ 528 char ej_cmd[12] = { 0x1b, 0, 0, 0, 3 - position, 0, 0, 0, 0, 0, 0, 0 }; 529 530 return pcd_atapi(cdi->handle, ej_cmd, 0, pcd_scratch, 531 position ? "eject" : "close tray"); 532} 533 534static void pcd_sleep(int cs) 535{ 536 schedule_timeout_interruptible(cs); 537} 538 539static int pcd_reset(struct pcd_unit *cd) 540{ 541 int i, k, flg; 542 int expect[5] = { 1, 1, 1, 0x14, 0xeb }; 543 544 pi_connect(cd->pi); 545 write_reg(cd, 6, 0xa0 + 0x10 * cd->drive); 546 write_reg(cd, 7, 8); 547 548 pcd_sleep(20 * HZ / 1000); /* delay a bit */ 549 550 k = 0; 551 while ((k++ < PCD_RESET_TMO) && (status_reg(cd) & IDE_BUSY)) 552 pcd_sleep(HZ / 10); 553 554 flg = 1; 555 for (i = 0; i < 5; i++) 556 flg &= (read_reg(cd, i + 1) == expect[i]); 557 558 if (verbose) { 559 printk("%s: Reset (%d) signature = ", cd->name, k); 560 for (i = 0; i < 5; i++) 561 printk("%3x", read_reg(cd, i + 1)); 562 if (!flg) 563 printk(" (incorrect)"); 564 printk("\n"); 565 } 566 567 pi_disconnect(cd->pi); 568 return flg - 1; 569} 570 571static int pcd_drive_reset(struct cdrom_device_info *cdi) 572{ 573 return pcd_reset(cdi->handle); 574} 575 576static int pcd_ready_wait(struct pcd_unit *cd, int tmo) 577{ 578 char tr_cmd[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 579 int k, p; 580 581 k = 0; 582 while (k < tmo) { 583 cd->last_sense = 0; 584 pcd_atapi(cd, tr_cmd, 0, NULL, DBMSG("test unit ready")); 585 p = cd->last_sense; 586 if (!p) 587 return 0; 588 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6))) 589 return p; 590 k++; 591 pcd_sleep(HZ); 592 } 593 return 0x000020; /* timeout */ 594} 595 596static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr) 597{ 598 char rc_cmd[12] = { 0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 599 struct pcd_unit *cd = cdi->handle; 600 601 if (pcd_ready_wait(cd, PCD_READY_TMO)) 602 return CDS_DRIVE_NOT_READY; 603 if (pcd_atapi(cd, rc_cmd, 8, pcd_scratch, DBMSG("check media"))) 604 return CDS_NO_DISC; 605 return CDS_DISC_OK; 606} 607 608static int pcd_identify(struct pcd_unit *cd, char *id) 609{ 610 int k, s; 611 char id_cmd[12] = { 0x12, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 }; 612 613 pcd_bufblk = -1; 614 615 s = pcd_atapi(cd, id_cmd, 36, pcd_buffer, "identify"); 616 617 if (s) 618 return -1; 619 if ((pcd_buffer[0] & 0x1f) != 5) { 620 if (verbose) 621 printk("%s: %s is not a CD-ROM\n", 622 cd->name, cd->drive ? "Slave" : "Master"); 623 return -1; 624 } 625 memcpy(id, pcd_buffer + 16, 16); 626 id[16] = 0; 627 k = 16; 628 while ((k >= 0) && (id[k] <= 0x20)) { 629 id[k] = 0; 630 k--; 631 } 632 633 printk("%s: %s: %s\n", cd->name, cd->drive ? "Slave" : "Master", id); 634 635 return 0; 636} 637 638/* 639 * returns 0, with id set if drive is detected 640 * -1, if drive detection failed 641 */ 642static int pcd_probe(struct pcd_unit *cd, int ms, char *id) 643{ 644 if (ms == -1) { 645 for (cd->drive = 0; cd->drive <= 1; cd->drive++) 646 if (!pcd_reset(cd) && !pcd_identify(cd, id)) 647 return 0; 648 } else { 649 cd->drive = ms; 650 if (!pcd_reset(cd) && !pcd_identify(cd, id)) 651 return 0; 652 } 653 return -1; 654} 655 656static void pcd_probe_capabilities(void) 657{ 658 int unit, r; 659 char buffer[32]; 660 char cmd[12] = { 0x5a, 1 << 3, 0x2a, 0, 0, 0, 0, 18, 0, 0, 0, 0 }; 661 struct pcd_unit *cd; 662 663 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { 664 if (!cd->present) 665 continue; 666 r = pcd_atapi(cd, cmd, 18, buffer, "mode sense capabilities"); 667 if (r) 668 continue; 669 /* we should now have the cap page */ 670 if ((buffer[11] & 1) == 0) 671 cd->info.mask |= CDC_CD_R; 672 if ((buffer[11] & 2) == 0) 673 cd->info.mask |= CDC_CD_RW; 674 if ((buffer[12] & 1) == 0) 675 cd->info.mask |= CDC_PLAY_AUDIO; 676 if ((buffer[14] & 1) == 0) 677 cd->info.mask |= CDC_LOCK; 678 if ((buffer[14] & 8) == 0) 679 cd->info.mask |= CDC_OPEN_TRAY; 680 if ((buffer[14] >> 6) == 0) 681 cd->info.mask |= CDC_CLOSE_TRAY; 682 } 683} 684 685static int pcd_detect(void) 686{ 687 char id[18]; 688 int k, unit; 689 struct pcd_unit *cd; 690 691 printk("%s: %s version %s, major %d, nice %d\n", 692 name, name, PCD_VERSION, major, nice); 693 694 par_drv = pi_register_driver(name); 695 if (!par_drv) { 696 pr_err("failed to register %s driver\n", name); 697 return -1; 698 } 699 700 k = 0; 701 if (pcd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */ 702 cd = pcd; 703 if (pi_init(cd->pi, 1, -1, -1, -1, -1, -1, pcd_buffer, 704 PI_PCD, verbose, cd->name)) { 705 if (!pcd_probe(cd, -1, id) && cd->disk) { 706 cd->present = 1; 707 k++; 708 } else 709 pi_release(cd->pi); 710 } 711 } else { 712 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { 713 int *conf = *drives[unit]; 714 if (!conf[D_PRT]) 715 continue; 716 if (!pi_init(cd->pi, 0, conf[D_PRT], conf[D_MOD], 717 conf[D_UNI], conf[D_PRO], conf[D_DLY], 718 pcd_buffer, PI_PCD, verbose, cd->name)) 719 continue; 720 if (!pcd_probe(cd, conf[D_SLV], id) && cd->disk) { 721 cd->present = 1; 722 k++; 723 } else 724 pi_release(cd->pi); 725 } 726 } 727 if (k) 728 return 0; 729 730 printk("%s: No CD-ROM drive found\n", name); 731 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) 732 put_disk(cd->disk); 733 pi_unregister_driver(par_drv); 734 return -1; 735} 736 737/* I/O request processing */ 738static struct request_queue *pcd_queue; 739 740static void do_pcd_request(struct request_queue * q) 741{ 742 if (pcd_busy) 743 return; 744 while (1) { 745 if (!pcd_req) { 746 pcd_req = blk_fetch_request(q); 747 if (!pcd_req) 748 return; 749 } 750 751 if (rq_data_dir(pcd_req) == READ) { 752 struct pcd_unit *cd = pcd_req->rq_disk->private_data; 753 if (cd != pcd_current) 754 pcd_bufblk = -1; 755 pcd_current = cd; 756 pcd_sector = blk_rq_pos(pcd_req); 757 pcd_count = blk_rq_cur_sectors(pcd_req); 758 pcd_buf = bio_data(pcd_req->bio); 759 pcd_busy = 1; 760 ps_set_intr(do_pcd_read, NULL, 0, nice); 761 return; 762 } else { 763 __blk_end_request_all(pcd_req, -EIO); 764 pcd_req = NULL; 765 } 766 } 767} 768 769static inline void next_request(int err) 770{ 771 unsigned long saved_flags; 772 773 spin_lock_irqsave(&pcd_lock, saved_flags); 774 if (!__blk_end_request_cur(pcd_req, err)) 775 pcd_req = NULL; 776 pcd_busy = 0; 777 do_pcd_request(pcd_queue); 778 spin_unlock_irqrestore(&pcd_lock, saved_flags); 779} 780 781static int pcd_ready(void) 782{ 783 return (((status_reg(pcd_current) & (IDE_BUSY | IDE_DRQ)) == IDE_DRQ)); 784} 785 786static void pcd_transfer(void) 787{ 788 789 while (pcd_count && (pcd_sector / 4 == pcd_bufblk)) { 790 int o = (pcd_sector % 4) * 512; 791 memcpy(pcd_buf, pcd_buffer + o, 512); 792 pcd_count--; 793 pcd_buf += 512; 794 pcd_sector++; 795 } 796} 797 798static void pcd_start(void) 799{ 800 int b, i; 801 char rd_cmd[12] = { 0xa8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }; 802 803 pcd_bufblk = pcd_sector / 4; 804 b = pcd_bufblk; 805 for (i = 0; i < 4; i++) { 806 rd_cmd[5 - i] = b & 0xff; 807 b = b >> 8; 808 } 809 810 if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) { 811 pcd_bufblk = -1; 812 next_request(-EIO); 813 return; 814 } 815 816 mdelay(1); 817 818 ps_set_intr(do_pcd_read_drq, pcd_ready, PCD_TMO, nice); 819} 820 821static void do_pcd_read(void) 822{ 823 pcd_busy = 1; 824 pcd_retries = 0; 825 pcd_transfer(); 826 if (!pcd_count) { 827 next_request(0); 828 return; 829 } 830 831 pi_do_claimed(pcd_current->pi, pcd_start); 832} 833 834static void do_pcd_read_drq(void) 835{ 836 unsigned long saved_flags; 837 838 if (pcd_completion(pcd_current, pcd_buffer, "read block")) { 839 if (pcd_retries < PCD_RETRIES) { 840 mdelay(1); 841 pcd_retries++; 842 pi_do_claimed(pcd_current->pi, pcd_start); 843 return; 844 } 845 pcd_bufblk = -1; 846 next_request(-EIO); 847 return; 848 } 849 850 do_pcd_read(); 851 spin_lock_irqsave(&pcd_lock, saved_flags); 852 do_pcd_request(pcd_queue); 853 spin_unlock_irqrestore(&pcd_lock, saved_flags); 854} 855 856/* the audio_ioctl stuff is adapted from sr_ioctl.c */ 857 858static int pcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg) 859{ 860 struct pcd_unit *cd = cdi->handle; 861 862 switch (cmd) { 863 864 case CDROMREADTOCHDR: 865 866 { 867 char cmd[12] = 868 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12, 869 0, 0, 0 }; 870 struct cdrom_tochdr *tochdr = 871 (struct cdrom_tochdr *) arg; 872 char buffer[32]; 873 int r; 874 875 r = pcd_atapi(cd, cmd, 12, buffer, "read toc header"); 876 877 tochdr->cdth_trk0 = buffer[2]; 878 tochdr->cdth_trk1 = buffer[3]; 879 880 return r ? -EIO : 0; 881 } 882 883 case CDROMREADTOCENTRY: 884 885 { 886 char cmd[12] = 887 { GPCMD_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 12, 888 0, 0, 0 }; 889 890 struct cdrom_tocentry *tocentry = 891 (struct cdrom_tocentry *) arg; 892 unsigned char buffer[32]; 893 int r; 894 895 cmd[1] = 896 (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0); 897 cmd[6] = tocentry->cdte_track; 898 899 r = pcd_atapi(cd, cmd, 12, buffer, "read toc entry"); 900 901 tocentry->cdte_ctrl = buffer[5] & 0xf; 902 tocentry->cdte_adr = buffer[5] >> 4; 903 tocentry->cdte_datamode = 904 (tocentry->cdte_ctrl & 0x04) ? 1 : 0; 905 if (tocentry->cdte_format == CDROM_MSF) { 906 tocentry->cdte_addr.msf.minute = buffer[9]; 907 tocentry->cdte_addr.msf.second = buffer[10]; 908 tocentry->cdte_addr.msf.frame = buffer[11]; 909 } else 910 tocentry->cdte_addr.lba = 911 (((((buffer[8] << 8) + buffer[9]) << 8) 912 + buffer[10]) << 8) + buffer[11]; 913 914 return r ? -EIO : 0; 915 } 916 917 default: 918 919 return -ENOSYS; 920 } 921} 922 923static int pcd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn) 924{ 925 char cmd[12] = 926 { GPCMD_READ_SUBCHANNEL, 0, 0x40, 2, 0, 0, 0, 0, 24, 0, 0, 0 }; 927 char buffer[32]; 928 929 if (pcd_atapi(cdi->handle, cmd, 24, buffer, "get mcn")) 930 return -EIO; 931 932 memcpy(mcn->medium_catalog_number, buffer + 9, 13); 933 mcn->medium_catalog_number[13] = 0; 934 935 return 0; 936} 937 938static int __init pcd_init(void) 939{ 940 struct pcd_unit *cd; 941 int unit; 942 943 if (disable) 944 return -EINVAL; 945 946 pcd_init_units(); 947 948 if (pcd_detect()) 949 return -ENODEV; 950 951 /* get the atapi capabilities page */ 952 pcd_probe_capabilities(); 953 954 if (register_blkdev(major, name)) { 955 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) 956 put_disk(cd->disk); 957 return -EBUSY; 958 } 959 960 pcd_queue = blk_init_queue(do_pcd_request, &pcd_lock); 961 if (!pcd_queue) { 962 unregister_blkdev(major, name); 963 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) 964 put_disk(cd->disk); 965 return -ENOMEM; 966 } 967 968 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { 969 if (cd->present) { 970 register_cdrom(&cd->info); 971 cd->disk->private_data = cd; 972 cd->disk->queue = pcd_queue; 973 add_disk(cd->disk); 974 } 975 } 976 977 return 0; 978} 979 980static void __exit pcd_exit(void) 981{ 982 struct pcd_unit *cd; 983 int unit; 984 985 for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { 986 if (cd->present) { 987 del_gendisk(cd->disk); 988 pi_release(cd->pi); 989 unregister_cdrom(&cd->info); 990 } 991 put_disk(cd->disk); 992 } 993 blk_cleanup_queue(pcd_queue); 994 unregister_blkdev(major, name); 995 pi_unregister_driver(par_drv); 996} 997 998MODULE_LICENSE("GPL"); 999module_init(pcd_init) 1000module_exit(pcd_exit) 1001