1 /* $OpenBSD: cd.c,v 1.56 2001/06/22 14:35:42 deraadt Exp $ */ 2 /* $NetBSD: cd.c,v 1.100 1997/04/02 02:29:30 mycroft Exp $ */ 3 4 /* 5 * Copyright (c) 1994, 1995, 1997 Charles M. Hannum. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Charles M. Hannum. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Originally written by Julian Elischer (julian@tfs.com) 35 * for TRW Financial Systems for use under the MACH(2.5) operating system. 36 * 37 * TRW Financial Systems, in accordance with their agreement with Carnegie 38 * Mellon University, makes this software available to CMU to distribute 39 * or use in any manner that they see fit as long as this message is kept with 40 * the software. For this reason TFS also grants any other persons or 41 * organisations permission to use or modify this software. 42 * 43 * TFS supplies this software to be publicly redistributed 44 * on the understanding that TFS is not responsible for the correct 45 * functioning of this software in any circumstances. 46 * 47 * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992 48 */ 49 50 #include <sys/types.h> 51 #include <sys/param.h> 52 #include <sys/systm.h> 53 #include <sys/kernel.h> 54 #include <sys/file.h> 55 #include <sys/stat.h> 56 #include <sys/ioctl.h> 57 #include <sys/mtio.h> 58 #include <sys/buf.h> 59 #include <sys/uio.h> 60 #include <sys/malloc.h> 61 #include <sys/errno.h> 62 #include <sys/device.h> 63 #include <sys/disklabel.h> 64 #include <sys/disk.h> 65 #include <sys/cdio.h> 66 #include <sys/proc.h> 67 #include <sys/conf.h> 68 #include <sys/scsiio.h> 69 #include <sys/vnode.h> 70 71 #include <scsi/scsi_all.h> 72 #include <scsi/cd.h> 73 #include <scsi/scsi_cd.h> 74 #include <scsi/scsi_disk.h> /* rw_big and start_stop come from there */ 75 #include <scsi/scsiconf.h> 76 77 78 #include <ufs/ffs/fs.h> /* for BBSIZE and SBSIZE */ 79 80 #include "cdvar.h" 81 82 #define CDOUTSTANDING 4 83 84 #define CDUNIT(z) DISKUNIT(z) 85 #define CDMINOR(unit, part) DISKMINOR(unit, part) 86 #define CDPART(z) DISKPART(z) 87 #define MAKECDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part) 88 89 #define MAXTRACK 99 90 #define CD_BLOCK_OFFSET 150 91 #define CD_FRAMES 75 92 #define CD_SECS 60 93 94 #define TOC_HEADER_LEN 0 95 #define TOC_HEADER_STARTING_TRACK 2 96 #define TOC_HEADER_ENDING_TRACK 3 97 #define TOC_HEADER_SZ 4 98 99 #define TOC_ENTRY_CONTROL_ADDR_TYPE 1 100 #define TOC_ENTRY_TRACK 2 101 #define TOC_ENTRY_MSF_LBA 4 102 #define TOC_ENTRY_SZ 8 103 104 105 struct cd_toc { 106 struct ioc_toc_header header; 107 struct cd_toc_entry entries[MAXTRACK+1]; /* One extra for the */ 108 /* leadout */ 109 }; 110 111 #define CDLABELDEV(dev) (MAKECDDEV(major(dev), CDUNIT(dev), RAW_PART)) 112 113 int cdmatch __P((struct device *, void *, void *)); 114 void cdattach __P((struct device *, struct device *, void *)); 115 int cdactivate __P((struct device *, enum devact)); 116 int cddetach __P((struct device *, int)); 117 void cdzeroref __P((struct device *)); 118 119 void cdstart __P((void *)); 120 void cdminphys __P((struct buf *)); 121 void cdgetdisklabel __P((dev_t, struct cd_softc *, struct disklabel *, 122 struct cpu_disklabel *, int)); 123 void cddone __P((struct scsi_xfer *)); 124 u_long cd_size __P((struct cd_softc *, int)); 125 void lba2msf __P((u_long, u_char *, u_char *, u_char *)); 126 u_long msf2lba __P((u_char, u_char, u_char)); 127 int cd_play __P((struct cd_softc *, int, int)); 128 int cd_play_tracks __P((struct cd_softc *, int, int, int, int)); 129 int cd_play_msf __P((struct cd_softc *, int, int, int, int, int, int)); 130 int cd_pause __P((struct cd_softc *, int)); 131 int cd_reset __P((struct cd_softc *)); 132 int cd_read_subchannel __P((struct cd_softc *, int, int, int, 133 struct cd_sub_channel_info *, int )); 134 int cd_read_toc __P((struct cd_softc *, int, int, void *, 135 int, int )); 136 int cd_get_parms __P((struct cd_softc *, int)); 137 int cd_load_toc __P((struct cd_softc *, struct cd_toc *)); 138 139 int dvd_auth __P((struct cd_softc *, union dvd_authinfo *)); 140 int dvd_read_physical __P((struct cd_softc *, union dvd_struct *)); 141 int dvd_read_copyright __P((struct cd_softc *, union dvd_struct *)); 142 int dvd_read_disckey __P((struct cd_softc *, union dvd_struct *)); 143 int dvd_read_bca __P((struct cd_softc *, union dvd_struct *)); 144 int dvd_read_manufact __P((struct cd_softc *, union dvd_struct *)); 145 int dvd_read_struct __P((struct cd_softc *, union dvd_struct *)); 146 147 struct cfattach cd_ca = { 148 sizeof(struct cd_softc), cdmatch, cdattach, 149 cddetach, cdactivate, cdzeroref 150 }; 151 152 struct cfdriver cd_cd = { 153 NULL, "cd", DV_DISK 154 }; 155 156 struct dkdriver cddkdriver = { cdstrategy }; 157 158 struct scsi_device cd_switch = { 159 NULL, /* use default error handler */ 160 cdstart, /* we have a queue, which is started by this */ 161 NULL, /* we do not have an async handler */ 162 cddone, /* deal with stats at interrupt time */ 163 }; 164 165 struct scsi_inquiry_pattern cd_patterns[] = { 166 {T_CDROM, T_REMOV, 167 "", "", ""}, 168 {T_WORM, T_REMOV, 169 "", "", ""}, 170 {T_DIRECT, T_REMOV, 171 "NEC CD-ROM DRIVE:260", "", ""}, 172 #if 0 173 {T_CDROM, T_REMOV, /* more luns */ 174 "PIONEER ", "CD-ROM DRM-600 ", ""}, 175 #endif 176 }; 177 178 extern struct cd_ops cd_atapibus_ops; 179 extern struct cd_ops cd_scsibus_ops; 180 181 #define cdlock(softc) disk_lock(&(softc)->sc_dk) 182 #define cdunlock(softc) disk_unlock(&(softc)->sc_dk) 183 #define cdlookup(unit) (struct cd_softc *)device_lookup(&cd_cd, (unit)) 184 185 int 186 cdmatch(parent, match, aux) 187 struct device *parent; 188 void *match, *aux; 189 { 190 struct scsibus_attach_args *sa = aux; 191 int priority; 192 193 (void)scsi_inqmatch(sa->sa_inqbuf, 194 (caddr_t)cd_patterns, sizeof(cd_patterns)/sizeof(cd_patterns[0]), 195 sizeof(cd_patterns[0]), &priority); 196 return (priority); 197 } 198 199 /* 200 * The routine called by the low level scsi routine when it discovers 201 * A device suitable for this driver 202 */ 203 void 204 cdattach(parent, self, aux) 205 struct device *parent, *self; 206 void *aux; 207 { 208 struct cd_softc *cd = (void *)self; 209 struct scsibus_attach_args *sa = aux; 210 struct scsi_link *sc_link = sa->sa_sc_link; 211 212 SC_DEBUG(sc_link, SDEV_DB2, ("cdattach: ")); 213 214 /* 215 * Store information needed to contact our base driver 216 */ 217 cd->sc_link = sc_link; 218 sc_link->device = &cd_switch; 219 sc_link->device_softc = cd; 220 if (sc_link->openings > CDOUTSTANDING) 221 sc_link->openings = CDOUTSTANDING; 222 223 /* 224 * Initialize and attach the disk structure. 225 */ 226 cd->sc_dk.dk_driver = &cddkdriver; 227 cd->sc_dk.dk_name = cd->sc_dev.dv_xname; 228 disk_attach(&cd->sc_dk); 229 230 dk_establish(&cd->sc_dk, &cd->sc_dev); 231 232 /* 233 * Note if this device is ancient. This is used in cdminphys(). 234 */ 235 if (!(sc_link->flags & SDEV_ATAPI) && 236 (sa->sa_inqbuf->version & SID_ANSII) == 0) 237 cd->flags |= CDF_ANCIENT; 238 239 if (sc_link->flags & SDEV_ATAPI) { 240 cd->sc_ops = &cd_atapibus_ops; 241 } else { 242 cd->sc_ops = &cd_scsibus_ops; 243 } 244 245 printf("\n"); 246 } 247 248 249 int 250 cdactivate(self, act) 251 struct device *self; 252 enum devact act; 253 { 254 int rv = 0; 255 256 switch (act) { 257 case DVACT_ACTIVATE: 258 break; 259 260 case DVACT_DEACTIVATE: 261 /* 262 * Nothing to do; we key off the device's DVF_ACTIVATE. 263 */ 264 break; 265 } 266 return (rv); 267 } 268 269 270 int 271 cddetach(self, flags) 272 struct device *self; 273 int flags; 274 { 275 struct cd_softc *sc = (struct cd_softc *)self; 276 struct buf *dp, *bp; 277 int s, bmaj, cmaj, mn; 278 279 /* Remove unprocessed buffers from queue */ 280 s = splbio(); 281 for (dp = &sc->buf_queue; (bp = dp->b_actf) != NULL; ) { 282 dp->b_actf = bp->b_actf; 283 284 bp->b_error = ENXIO; 285 bp->b_flags |= B_ERROR; 286 biodone(bp); 287 } 288 splx(s); 289 290 /* locate the major number */ 291 mn = CDMINOR(self->dv_unit, 0); 292 293 for (bmaj = 0; bmaj < nblkdev; bmaj++) 294 if (bdevsw[bmaj].d_open == cdopen) 295 vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK); 296 for (cmaj = 0; cmaj < nchrdev; cmaj++) 297 if (cdevsw[cmaj].d_open == cdopen) 298 vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR); 299 return (0); 300 } 301 302 void 303 cdzeroref(self) 304 struct device *self; 305 { 306 struct cd_softc *cd = (struct cd_softc *)self; 307 308 /* Detach disk. */ 309 disk_detach(&cd->sc_dk); 310 } 311 312 313 /* 314 * open the device. Make sure the partition info is a up-to-date as can be. 315 */ 316 int 317 cdopen(dev, flag, fmt, p) 318 dev_t dev; 319 int flag, fmt; 320 struct proc *p; 321 { 322 struct cd_softc *cd; 323 struct scsi_link *sc_link; 324 int unit, part; 325 int error; 326 327 unit = CDUNIT(dev); 328 cd = cdlookup(unit); 329 if (cd == NULL) 330 return ENXIO; 331 332 sc_link = cd->sc_link; 333 334 SC_DEBUG(sc_link, SDEV_DB1, 335 ("cdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit, 336 cd_cd.cd_ndevs, CDPART(dev))); 337 338 if ((error = cdlock(cd)) != 0) { 339 device_unref(&cd->sc_dev); 340 return error; 341 } 342 343 if (cd->sc_dk.dk_openmask != 0) { 344 /* 345 * If any partition is open, but the disk has been invalidated, 346 * disallow further opens. 347 */ 348 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) { 349 error = EIO; 350 goto bad3; 351 } 352 } else { 353 /* Check that it is still responding and ok. */ 354 error = scsi_test_unit_ready(sc_link, 355 SCSI_IGNORE_ILLEGAL_REQUEST | 356 SCSI_IGNORE_MEDIA_CHANGE | SCSI_IGNORE_NOT_READY); 357 if (error) 358 goto bad3; 359 360 /* Start the pack spinning if necessary. */ 361 error = scsi_start(sc_link, SSS_START, 362 SCSI_IGNORE_ILLEGAL_REQUEST | 363 SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT); 364 if (error) 365 goto bad3; 366 367 sc_link->flags |= SDEV_OPEN; 368 369 /* Lock the pack in. */ 370 error = scsi_prevent(sc_link, PR_PREVENT, 371 SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE); 372 if (error) 373 goto bad; 374 375 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) { 376 sc_link->flags |= SDEV_MEDIA_LOADED; 377 378 /* Load the physical device parameters. */ 379 if (cd_get_parms(cd, 0) != 0) { 380 error = ENXIO; 381 goto bad2; 382 } 383 SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded ")); 384 385 /* Fabricate a disk label. */ 386 cdgetdisklabel(dev, cd, cd->sc_dk.dk_label, 387 cd->sc_dk.dk_cpulabel, 0); 388 SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel fabricated ")); 389 } 390 } 391 392 part = CDPART(dev); 393 394 /* Check that the partition exists. */ 395 if (part != RAW_PART && 396 (part >= cd->sc_dk.dk_label->d_npartitions || 397 cd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) { 398 error = ENXIO; 399 goto bad; 400 } 401 402 /* Insure only one open at a time. */ 403 switch (fmt) { 404 case S_IFCHR: 405 cd->sc_dk.dk_copenmask |= (1 << part); 406 break; 407 case S_IFBLK: 408 cd->sc_dk.dk_bopenmask |= (1 << part); 409 break; 410 } 411 cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask; 412 413 SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n")); 414 cdunlock(cd); 415 device_unref(&cd->sc_dev); 416 return 0; 417 418 bad2: 419 sc_link->flags &= ~SDEV_MEDIA_LOADED; 420 421 bad: 422 if (cd->sc_dk.dk_openmask == 0) { 423 scsi_prevent(sc_link, PR_ALLOW, 424 SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE); 425 sc_link->flags &= ~SDEV_OPEN; 426 } 427 428 bad3: 429 cdunlock(cd); 430 device_unref(&cd->sc_dev); 431 return error; 432 } 433 434 /* 435 * close the device.. only called if we are the LAST 436 * occurence of an open device 437 */ 438 int 439 cdclose(dev, flag, fmt, p) 440 dev_t dev; 441 int flag, fmt; 442 struct proc *p; 443 { 444 struct cd_softc *cd; 445 int part = CDPART(dev); 446 int error; 447 448 cd = cdlookup(CDUNIT(dev)); 449 if (cd == NULL) 450 return ENXIO; 451 452 if ((error = cdlock(cd)) != 0) { 453 device_unref(&cd->sc_dev); 454 return error; 455 } 456 457 switch (fmt) { 458 case S_IFCHR: 459 cd->sc_dk.dk_copenmask &= ~(1 << part); 460 break; 461 case S_IFBLK: 462 cd->sc_dk.dk_bopenmask &= ~(1 << part); 463 break; 464 } 465 cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask; 466 467 if (cd->sc_dk.dk_openmask == 0) { 468 /* XXXX Must wait for I/O to complete! */ 469 470 scsi_prevent(cd->sc_link, PR_ALLOW, 471 SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY); 472 cd->sc_link->flags &= ~SDEV_OPEN; 473 474 if (cd->sc_link->flags & SDEV_EJECTING) { 475 scsi_start(cd->sc_link, SSS_STOP|SSS_LOEJ, 0); 476 477 cd->sc_link->flags &= ~SDEV_EJECTING; 478 } 479 } 480 481 cdunlock(cd); 482 483 device_unref(&cd->sc_dev); 484 return 0; 485 } 486 487 /* 488 * Actually translate the requested transfer into one the physical driver can 489 * understand. The transfer is described by a buf and will include only one 490 * physical transfer. 491 */ 492 void 493 cdstrategy(bp) 494 struct buf *bp; 495 { 496 struct cd_softc *cd; 497 int opri; 498 499 if ((cd = cdlookup(CDUNIT(bp->b_dev))) == NULL) { 500 bp->b_error = ENXIO; 501 goto bad; 502 } 503 504 SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdstrategy ")); 505 SC_DEBUG(cd->sc_link, SDEV_DB1, 506 ("%ld bytes @ blk %d\n", bp->b_bcount, bp->b_blkno)); 507 /* 508 * The transfer must be a whole number of blocks. 509 */ 510 if ((bp->b_bcount % cd->sc_dk.dk_label->d_secsize) != 0) { 511 bp->b_error = EINVAL; 512 goto bad; 513 } 514 /* 515 * If the device has been made invalid, error out 516 * maybe the media changed 517 */ 518 if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) { 519 bp->b_error = EIO; 520 goto bad; 521 } 522 /* 523 * If it's a null transfer, return immediately 524 */ 525 if (bp->b_bcount == 0) 526 goto done; 527 528 /* 529 * Do bounds checking, adjust transfer. if error, process. 530 * If end of partition, just return. 531 */ 532 if (CDPART(bp->b_dev) != RAW_PART && 533 bounds_check_with_label(bp, cd->sc_dk.dk_label, 534 cd->sc_dk.dk_cpulabel, 535 (cd->flags & (CDF_WLABEL|CDF_LABELLING)) != 0) <= 0) 536 goto done; 537 538 opri = splbio(); 539 540 /* 541 * Place it in the queue of disk activities for this disk 542 */ 543 disksort(&cd->buf_queue, bp); 544 545 /* 546 * Tell the device to get going on the transfer if it's 547 * not doing anything, otherwise just wait for completion 548 */ 549 cdstart(cd); 550 551 device_unref(&cd->sc_dev); 552 splx(opri); 553 return; 554 555 bad: 556 bp->b_flags |= B_ERROR; 557 done: 558 /* 559 * Correctly set the buf to indicate a completed xfer 560 */ 561 bp->b_resid = bp->b_bcount; 562 biodone(bp); 563 if (cd != NULL) 564 device_unref(&cd->sc_dev); 565 } 566 567 /* 568 * cdstart looks to see if there is a buf waiting for the device 569 * and that the device is not already busy. If both are true, 570 * It deques the buf and creates a scsi command to perform the 571 * transfer in the buf. The transfer request will call scsi_done 572 * on completion, which will in turn call this routine again 573 * so that the next queued transfer is performed. 574 * The bufs are queued by the strategy routine (cdstrategy) 575 * 576 * This routine is also called after other non-queued requests 577 * have been made of the scsi driver, to ensure that the queue 578 * continues to be drained. 579 * 580 * must be called at the correct (highish) spl level 581 * cdstart() is called at splbio from cdstrategy and scsi_done 582 */ 583 void 584 cdstart(v) 585 register void *v; 586 { 587 register struct cd_softc *cd = v; 588 register struct scsi_link *sc_link = cd->sc_link; 589 struct buf *bp = 0; 590 struct buf *dp; 591 struct scsi_rw_big cmd_big; 592 struct scsi_rw cmd_small; 593 struct scsi_generic *cmdp; 594 int blkno, nblks, cmdlen; 595 struct partition *p; 596 597 SC_DEBUG(sc_link, SDEV_DB2, ("cdstart ")); 598 /* 599 * Check if the device has room for another command 600 */ 601 while (sc_link->openings > 0) { 602 /* 603 * there is excess capacity, but a special waits 604 * It'll need the adapter as soon as we clear out of the 605 * way and let it run (user level wait). 606 */ 607 if (sc_link->flags & SDEV_WAITING) { 608 sc_link->flags &= ~SDEV_WAITING; 609 wakeup((caddr_t)sc_link); 610 return; 611 } 612 613 /* 614 * See if there is a buf with work for us to do.. 615 */ 616 dp = &cd->buf_queue; 617 if ((bp = dp->b_actf) == NULL) /* yes, an assign */ 618 return; 619 dp->b_actf = bp->b_actf; 620 621 /* 622 * If the deivce has become invalid, abort all the 623 * reads and writes until all files have been closed and 624 * re-opened 625 */ 626 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) { 627 bp->b_error = EIO; 628 bp->b_flags |= B_ERROR; 629 bp->b_resid = bp->b_bcount; 630 biodone(bp); 631 continue; 632 } 633 634 /* 635 * We have a buf, now we should make a command 636 * 637 * First, translate the block to absolute and put it in terms 638 * of the logical blocksize of the device. 639 */ 640 blkno = 641 bp->b_blkno / (cd->sc_dk.dk_label->d_secsize / DEV_BSIZE); 642 if (CDPART(bp->b_dev) != RAW_PART) { 643 p = &cd->sc_dk.dk_label->d_partitions[CDPART(bp->b_dev)]; 644 blkno += p->p_offset; 645 } 646 nblks = howmany(bp->b_bcount, cd->sc_dk.dk_label->d_secsize); 647 648 /* 649 * Fill out the scsi command. If the transfer will 650 * fit in a "small" cdb, use it. 651 */ 652 if (!(sc_link->flags & SDEV_ATAPI) && 653 ((blkno & 0x1fffff) == blkno) && 654 ((nblks & 0xff) == nblks)) { 655 /* 656 * We can fit in a small cdb. 657 */ 658 bzero(&cmd_small, sizeof(cmd_small)); 659 cmd_small.opcode = (bp->b_flags & B_READ) ? 660 READ_COMMAND : WRITE_COMMAND; 661 _lto3b(blkno, cmd_small.addr); 662 cmd_small.length = nblks & 0xff; 663 cmdlen = sizeof(cmd_small); 664 cmdp = (struct scsi_generic *)&cmd_small; 665 } else { 666 /* 667 * Need a large cdb. 668 */ 669 bzero(&cmd_big, sizeof(cmd_big)); 670 cmd_big.opcode = (bp->b_flags & B_READ) ? 671 READ_BIG : WRITE_BIG; 672 _lto4b(blkno, cmd_big.addr); 673 _lto2b(nblks, cmd_big.length); 674 cmdlen = sizeof(cmd_big); 675 cmdp = (struct scsi_generic *)&cmd_big; 676 } 677 678 /* Instrumentation. */ 679 disk_busy(&cd->sc_dk); 680 681 /* 682 * Call the routine that chats with the adapter. 683 * Note: we cannot sleep as we may be an interrupt 684 */ 685 if (scsi_scsi_cmd(sc_link, cmdp, cmdlen, 686 (u_char *) bp->b_data, bp->b_bcount, 687 CDRETRIES, 30000, bp, SCSI_NOSLEEP | 688 ((bp->b_flags & B_READ) ? SCSI_DATA_IN : SCSI_DATA_OUT))) { 689 disk_unbusy(&cd->sc_dk, 0); 690 printf("%s: not queued", cd->sc_dev.dv_xname); 691 } 692 } 693 } 694 695 void 696 cddone(xs) 697 struct scsi_xfer *xs; 698 { 699 struct cd_softc *cd = xs->sc_link->device_softc; 700 701 if (xs->bp != NULL) 702 disk_unbusy(&cd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid); 703 } 704 705 void 706 cdminphys(bp) 707 struct buf *bp; 708 { 709 struct cd_softc *cd; 710 long max; 711 712 cd = cdlookup(CDUNIT(bp->b_dev)); 713 if (cd == NULL) 714 return; 715 716 /* 717 * If the device is ancient, we want to make sure that 718 * the transfer fits into a 6-byte cdb. 719 * 720 * XXX Note that the SCSI-I spec says that 256-block transfers 721 * are allowed in a 6-byte read/write, and are specified 722 * by settng the "length" to 0. However, we're conservative 723 * here, allowing only 255-block transfers in case an 724 * ancient device gets confused by length == 0. A length of 0 725 * in a 10-byte read/write actually means 0 blocks. 726 */ 727 if (cd->flags & CDF_ANCIENT) { 728 max = cd->sc_dk.dk_label->d_secsize * 0xff; 729 730 if (bp->b_bcount > max) 731 bp->b_bcount = max; 732 } 733 734 (*cd->sc_link->adapter->scsi_minphys)(bp); 735 } 736 737 int 738 cdread(dev, uio, ioflag) 739 dev_t dev; 740 struct uio *uio; 741 int ioflag; 742 { 743 744 return (physio(cdstrategy, NULL, dev, B_READ, cdminphys, uio)); 745 } 746 747 int 748 cdwrite(dev, uio, ioflag) 749 dev_t dev; 750 struct uio *uio; 751 int ioflag; 752 { 753 754 return (physio(cdstrategy, NULL, dev, B_WRITE, cdminphys, uio)); 755 } 756 757 /* 758 * conversion between minute-seconde-frame and logical block adress 759 * adresses format 760 */ 761 void 762 lba2msf (lba, m, s, f) 763 u_long lba; 764 u_char *m, *s, *f; 765 { 766 u_long tmp; 767 768 tmp = lba + CD_BLOCK_OFFSET; /* offset of first logical frame */ 769 tmp &= 0xffffff; /* negative lbas use only 24 bits */ 770 *m = tmp / (CD_SECS * CD_FRAMES); 771 tmp %= (CD_SECS * CD_FRAMES); 772 *s = tmp / CD_FRAMES; 773 *f = tmp % CD_FRAMES; 774 } 775 776 u_long 777 msf2lba (m, s, f) 778 u_char m, s, f; 779 { 780 781 return ((((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET); 782 } 783 784 785 /* 786 * Perform special action on behalf of the user. 787 * Knows about the internals of this device 788 */ 789 int 790 cdioctl(dev, cmd, addr, flag, p) 791 dev_t dev; 792 u_long cmd; 793 caddr_t addr; 794 int flag; 795 struct proc *p; 796 { 797 struct cd_softc *cd; 798 int part = CDPART(dev); 799 int error = 0; 800 801 cd = cdlookup(CDUNIT(dev)); 802 if (cd == NULL) 803 return ENXIO; 804 805 SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdioctl 0x%lx ", cmd)); 806 807 /* 808 * If the device is not valid.. abandon ship 809 */ 810 if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) { 811 switch (cmd) { 812 case DIOCWLABEL: 813 case DIOCLOCK: 814 case DIOCEJECT: 815 case SCIOCIDENTIFY: 816 case OSCIOCIDENTIFY: 817 case SCIOCCOMMAND: 818 case SCIOCDEBUG: 819 case CDIOCLOADUNLOAD: 820 case SCIOCRESET: 821 case CDIOCGETVOL: 822 case CDIOCSETVOL: 823 case CDIOCSETMONO: 824 case CDIOCSETSTEREO: 825 case CDIOCSETMUTE: 826 case CDIOCSETLEFT: 827 case CDIOCSETRIGHT: 828 case CDIOCCLOSE: 829 case CDIOCEJECT: 830 case CDIOCALLOW: 831 case CDIOCPREVENT: 832 case CDIOCSETDEBUG: 833 case CDIOCCLRDEBUG: 834 case CDIOCRESET: 835 case DVD_AUTH: 836 case DVD_READ_STRUCT: 837 if (part == RAW_PART) 838 break; 839 /* FALLTHROUGH */ 840 default: 841 if ((cd->sc_link->flags & SDEV_OPEN) == 0) 842 error = ENODEV; 843 else 844 error = EIO; 845 goto exit; 846 } 847 } 848 849 switch (cmd) { 850 case DIOCRLDINFO: 851 cdgetdisklabel(dev, cd, cd->sc_dk.dk_label, 852 cd->sc_dk.dk_cpulabel, 0); 853 break; 854 case DIOCGDINFO: 855 case DIOCGPDINFO: 856 *(struct disklabel *)addr = *(cd->sc_dk.dk_label); 857 break; 858 859 case DIOCGPART: 860 ((struct partinfo *)addr)->disklab = cd->sc_dk.dk_label; 861 ((struct partinfo *)addr)->part = 862 &cd->sc_dk.dk_label->d_partitions[CDPART(dev)]; 863 break; 864 865 case DIOCWDINFO: 866 case DIOCSDINFO: 867 if ((flag & FWRITE) == 0) { 868 error = EBADF; 869 break; 870 } 871 872 if ((error = cdlock(cd)) != 0) 873 break; 874 875 cd->flags |= CDF_LABELLING; 876 877 error = setdisklabel(cd->sc_dk.dk_label, 878 (struct disklabel *)addr, /*cd->sc_dk.dk_openmask : */0, 879 cd->sc_dk.dk_cpulabel); 880 if (error == 0) { 881 } 882 883 cd->flags &= ~CDF_LABELLING; 884 cdunlock(cd); 885 break; 886 887 case DIOCWLABEL: 888 error = EBADF; 889 break; 890 891 case CDIOCPLAYTRACKS: { 892 struct ioc_play_track *args = (struct ioc_play_track *)addr; 893 894 if ((error = (*cd->sc_ops->cdo_set_pa_immed)(cd, 0)) != 0) 895 break; 896 error = cd_play_tracks(cd, args->start_track, 897 args->start_index, args->end_track, args->end_index); 898 break; 899 } 900 case CDIOCPLAYMSF: { 901 struct ioc_play_msf *args = (struct ioc_play_msf *)addr; 902 903 if ((error = (*cd->sc_ops->cdo_set_pa_immed)(cd, 0)) != 0) 904 break; 905 error = cd_play_msf(cd, args->start_m, args->start_s, 906 args->start_f, args->end_m, args->end_s, args->end_f); 907 break; 908 } 909 case CDIOCPLAYBLOCKS: { 910 struct ioc_play_blocks *args = (struct ioc_play_blocks *)addr; 911 912 if ((error = (*cd->sc_ops->cdo_set_pa_immed)(cd, 0)) != 0) 913 break; 914 error = cd_play(cd, args->blk, args->len); 915 break; 916 } 917 case CDIOCREADSUBCHANNEL: { 918 struct ioc_read_subchannel *args 919 = (struct ioc_read_subchannel *)addr; 920 struct cd_sub_channel_info data; 921 int len = args->data_len; 922 if (len > sizeof(data) || 923 len < sizeof(struct cd_sub_channel_header)) { 924 error = EINVAL; 925 break; 926 } 927 error = cd_read_subchannel(cd, args->address_format, 928 args->data_format, args->track, 929 &data, len); 930 if (error) 931 break; 932 len = min(len, _2btol(data.header.data_len) + 933 sizeof(struct cd_sub_channel_header)); 934 error = copyout(&data, args->data, len); 935 break; 936 } 937 case CDIOREADTOCHEADER: { 938 struct ioc_toc_header th; 939 940 if ((error = cd_read_toc(cd, 0, 0, &th, sizeof(th), 0)) != 0) 941 break; 942 if (cd->sc_link->quirks & ADEV_LITTLETOC) 943 th.len = letoh16(th.len); 944 else 945 th.len = ntohs(th.len); 946 bcopy(&th, addr, sizeof(th)); 947 break; 948 } 949 case CDIOREADTOCENTRYS: { 950 struct cd_toc *toc; 951 struct ioc_read_toc_entry *te = 952 (struct ioc_read_toc_entry *)addr; 953 struct ioc_toc_header *th; 954 struct cd_toc_entry *cte; 955 int len = te->data_len; 956 int ntracks; 957 958 MALLOC (toc, struct cd_toc *, sizeof (struct cd_toc), 959 M_DEVBUF, M_WAITOK); 960 961 th = &toc->header; 962 963 if (len > sizeof(toc->entries) || 964 len < sizeof(struct cd_toc_entry)) { 965 FREE(toc, M_DEVBUF); 966 error = EINVAL; 967 break; 968 } 969 error = cd_read_toc(cd, te->address_format, te->starting_track, 970 toc, len + sizeof(struct ioc_toc_header), 0); 971 if (error) { 972 FREE(toc, M_DEVBUF); 973 break; 974 } 975 if (te->address_format == CD_LBA_FORMAT) 976 for (ntracks = 977 th->ending_track - th->starting_track + 1; 978 ntracks >= 0; ntracks--) { 979 cte = &toc->entries[ntracks]; 980 cte->addr_type = CD_LBA_FORMAT; 981 if (cd->sc_link->quirks & ADEV_LITTLETOC) { 982 #if BYTE_ORDER == BIG_ENDIAN 983 swap16_multi((u_int16_t *)&cte->addr, 984 sizeof(cte->addr) / 2); 985 #endif 986 } else 987 cte->addr.lba = ntohl(cte->addr.lba); 988 } 989 if (cd->sc_link->quirks & ADEV_LITTLETOC) { 990 th->len = letoh16(th->len); 991 } else 992 th->len = ntohs(th->len); 993 len = min(len, th->len - (sizeof(th->starting_track) + 994 sizeof(th->ending_track))); 995 996 error = copyout(toc->entries, te->data, len); 997 FREE(toc, M_DEVBUF); 998 break; 999 } 1000 case CDIOREADMSADDR: { 1001 struct cd_toc *toc; 1002 int sessno = *(int*)addr; 1003 struct cd_toc_entry *cte; 1004 1005 if (sessno != 0) { 1006 error = EINVAL; 1007 break; 1008 } 1009 1010 MALLOC (toc, struct cd_toc *, sizeof (struct cd_toc), 1011 M_DEVBUF, M_WAITOK); 1012 1013 error = cd_read_toc(cd, 0, 0, toc, 1014 sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry), 1015 0x40 /* control word for "get MS info" */); 1016 1017 if (error) { 1018 FREE(toc, M_DEVBUF); 1019 break; 1020 } 1021 1022 cte = &toc->entries[0]; 1023 if (cd->sc_link->quirks & ADEV_LITTLETOC) { 1024 #if BYTE_ORDER == BIG_ENDIAN 1025 swap16_multi((u_int16_t *)&cte->addr, 1026 sizeof(cte->addr) / 2); 1027 #endif 1028 } else 1029 cte->addr.lba = ntohl(cte->addr.lba); 1030 if (cd->sc_link->quirks & ADEV_LITTLETOC) 1031 toc->header.len = letoh16(toc->header.len); 1032 else 1033 toc->header.len = ntohs(toc->header.len); 1034 1035 *(int*)addr = (toc->header.len >= 10 && cte->track > 1) ? 1036 cte->addr.lba : 0; 1037 FREE(toc, M_DEVBUF); 1038 break; 1039 } 1040 case CDIOCSETPATCH: { 1041 struct ioc_patch *arg = (struct ioc_patch *)addr; 1042 1043 error = (*cd->sc_ops->cdo_setchan)(cd, arg->patch[0], 1044 arg->patch[1], arg->patch[2], arg->patch[3], 0); 1045 break; 1046 } 1047 case CDIOCGETVOL: { 1048 struct ioc_vol *arg = (struct ioc_vol *)addr; 1049 1050 error = (*cd->sc_ops->cdo_getvol)(cd, arg, 0); 1051 break; 1052 } 1053 case CDIOCSETVOL: { 1054 struct ioc_vol *arg = (struct ioc_vol *)addr; 1055 1056 error = (*cd->sc_ops->cdo_setvol)(cd, arg, 0); 1057 break; 1058 } 1059 1060 case CDIOCSETMONO: 1061 error = (*cd->sc_ops->cdo_setchan)(cd, BOTH_CHANNEL, 1062 BOTH_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL, 0); 1063 break; 1064 1065 case CDIOCSETSTEREO: 1066 error = (*cd->sc_ops->cdo_setchan)(cd, LEFT_CHANNEL, 1067 RIGHT_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL, 0); 1068 break; 1069 1070 case CDIOCSETMUTE: 1071 error = (*cd->sc_ops->cdo_setchan)(cd, MUTE_CHANNEL, 1072 MUTE_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL, 0); 1073 break; 1074 1075 case CDIOCSETLEFT: 1076 error = (*cd->sc_ops->cdo_setchan)(cd, LEFT_CHANNEL, 1077 LEFT_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL, 0); 1078 break; 1079 1080 case CDIOCSETRIGHT: 1081 error = (*cd->sc_ops->cdo_setchan)(cd, RIGHT_CHANNEL, 1082 RIGHT_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL, 0); 1083 break; 1084 1085 case CDIOCRESUME: 1086 error = cd_pause(cd, 1); 1087 break; 1088 1089 case CDIOCPAUSE: 1090 error = cd_pause(cd, 0); 1091 break; 1092 case CDIOCSTART: 1093 error = scsi_start(cd->sc_link, SSS_START, 0); 1094 break; 1095 1096 case CDIOCSTOP: 1097 error = scsi_start(cd->sc_link, SSS_STOP, 0); 1098 break; 1099 1100 case CDIOCCLOSE: 1101 error = scsi_start(cd->sc_link, SSS_START|SSS_LOEJ, 1102 SCSI_IGNORE_NOT_READY | SCSI_IGNORE_MEDIA_CHANGE); 1103 break; 1104 1105 case MTIOCTOP: 1106 if (((struct mtop *)addr)->mt_op != MTOFFL) { 1107 error = EIO; 1108 break; 1109 } 1110 /* FALLTHROUGH */ 1111 case CDIOCEJECT: /* FALLTHROUGH */ 1112 case DIOCEJECT: 1113 cd->sc_link->flags |= SDEV_EJECTING; 1114 break; 1115 case CDIOCALLOW: 1116 error = scsi_prevent(cd->sc_link, PR_ALLOW, 0); 1117 break; 1118 case CDIOCPREVENT: 1119 error = scsi_prevent(cd->sc_link, PR_PREVENT, 0); 1120 break; 1121 case DIOCLOCK: 1122 error = scsi_prevent(cd->sc_link, 1123 (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0); 1124 break; 1125 case CDIOCSETDEBUG: 1126 cd->sc_link->flags |= (SDEV_DB1 | SDEV_DB2); 1127 break; 1128 case CDIOCCLRDEBUG: 1129 cd->sc_link->flags &= ~(SDEV_DB1 | SDEV_DB2); 1130 break; 1131 case CDIOCRESET: 1132 case SCIOCRESET: 1133 error = cd_reset(cd); 1134 break; 1135 case CDIOCLOADUNLOAD: { 1136 struct ioc_load_unload *args = (struct ioc_load_unload *)addr; 1137 1138 error = (*cd->sc_ops->cdo_load_unload)(cd, args->options, 1139 args->slot); 1140 break; 1141 } 1142 1143 case DVD_AUTH: 1144 error = dvd_auth(cd, (union dvd_authinfo *)addr); 1145 break; 1146 case DVD_READ_STRUCT: 1147 error = dvd_read_struct(cd, (union dvd_struct *)addr); 1148 break; 1149 default: 1150 if (CDPART(dev) != RAW_PART) { 1151 error = ENOTTY; 1152 break; 1153 } 1154 error = scsi_do_ioctl(cd->sc_link, dev, cmd, addr, flag, p); 1155 break; 1156 } 1157 1158 exit: 1159 1160 device_unref(&cd->sc_dev); 1161 return (error); 1162 } 1163 1164 /* 1165 * Load the label information on the named device 1166 * Actually fabricate a disklabel 1167 * 1168 * EVENTUALLY take information about different 1169 * data tracks from the TOC and put it in the disklabel 1170 */ 1171 void 1172 cdgetdisklabel(dev, cd, lp, clp, spoofonly) 1173 dev_t dev; 1174 struct cd_softc *cd; 1175 struct disklabel *lp; 1176 struct cpu_disklabel *clp; 1177 int spoofonly; 1178 { 1179 char *errstring; 1180 u_int8_t hdr[TOC_HEADER_SZ], *ent, *toc = NULL; 1181 u_int32_t lba, nlba; 1182 int tocidx, i, n, len, is_data, data_track = -1; 1183 int toc_valid = 0; 1184 1185 bzero(lp, sizeof(struct disklabel)); 1186 bzero(clp, sizeof(struct cpu_disklabel)); 1187 1188 lp->d_secsize = cd->params.blksize; 1189 lp->d_ntracks = 1; 1190 lp->d_nsectors = 100; 1191 lp->d_ncylinders = (cd->params.disksize / 100) + 1; 1192 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 1193 if (lp->d_secpercyl == 0) { 1194 lp->d_secpercyl = 100; 1195 /* as long as it's not 0 - readdisklabel divides by it */ 1196 } 1197 1198 if (cd->sc_link->flags & SDEV_ATAPI) { 1199 strncpy(lp->d_typename, "ATAPI CD-ROM", sizeof(lp->d_typename) - 1); 1200 lp->d_type = DTYPE_ATAPI; 1201 } else { 1202 strncpy(lp->d_typename, "SCSI CD-ROM", sizeof(lp->d_typename) - 1); 1203 lp->d_type = DTYPE_SCSI; 1204 } 1205 1206 strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname) - 1); 1207 lp->d_secperunit = cd->params.disksize; 1208 lp->d_rpm = 300; 1209 lp->d_interleave = 1; 1210 lp->d_flags = D_REMOVABLE; 1211 1212 /* XXX - these values for BBSIZE and SBSIZE assume ffs */ 1213 lp->d_bbsize = BBSIZE; 1214 lp->d_sbsize = SBSIZE; 1215 1216 lp->d_magic = DISKMAGIC; 1217 lp->d_magic2 = DISKMAGIC; 1218 lp->d_checksum = dkcksum(lp); 1219 1220 /* The raw partition is special. */ 1221 lp->d_partitions[RAW_PART].p_offset = 0; 1222 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 1223 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED; 1224 lp->d_npartitions = RAW_PART + 1; 1225 1226 /* 1227 * Read the TOC and loop throught the individual tracks and lay them 1228 * out in our disklabel. If there is a data track, call the generic 1229 * disklabel read routine. XXX should we move all data tracks up front 1230 * before any other tracks? 1231 */ 1232 bzero(hdr, sizeof(hdr)); 1233 if (cd_read_toc(cd, 0, 0, hdr, TOC_HEADER_SZ, 0)) 1234 goto done; 1235 1236 n = hdr[TOC_HEADER_ENDING_TRACK] - hdr[TOC_HEADER_STARTING_TRACK] + 1; 1237 1238 if (n <= 0) 1239 goto done; 1240 1241 /* n + 1 because of leadout track */ 1242 len = TOC_HEADER_SZ + (n + 1) * TOC_ENTRY_SZ; 1243 MALLOC(toc, u_int8_t *, len, M_TEMP, M_WAITOK); 1244 if (cd_read_toc (cd, CD_LBA_FORMAT, 0, toc, len, 0)) 1245 goto done; 1246 1247 /* Create the partition table. */ 1248 /* Probably should sanity-check the drive's values */ 1249 toc_valid = 1; 1250 ent = toc + TOC_HEADER_SZ; 1251 lba = ((cd->sc_link->quirks & ADEV_LITTLETOC) ? 1252 ent[TOC_ENTRY_MSF_LBA] | ent[TOC_ENTRY_MSF_LBA + 1] << 8 | 1253 ent[TOC_ENTRY_MSF_LBA + 2] << 16 | 1254 ent[TOC_ENTRY_MSF_LBA + 3] << 24 : 1255 ent[TOC_ENTRY_MSF_LBA] << 24 | ent[TOC_ENTRY_MSF_LBA + 1] << 16 | 1256 ent[TOC_ENTRY_MSF_LBA + 2] << 8 | ent[TOC_ENTRY_MSF_LBA + 3]); 1257 1258 i = 0; 1259 for (tocidx = 1; tocidx <= n; tocidx++) { 1260 is_data = ent[TOC_ENTRY_CONTROL_ADDR_TYPE] & 4; 1261 ent += TOC_ENTRY_SZ; 1262 nlba = ((cd->sc_link->quirks & ADEV_LITTLETOC) ? 1263 ent[TOC_ENTRY_MSF_LBA] | 1264 ent[TOC_ENTRY_MSF_LBA + 1] << 8 | 1265 ent[TOC_ENTRY_MSF_LBA + 2] << 16 | 1266 ent[TOC_ENTRY_MSF_LBA + 3] << 24 : 1267 ent[TOC_ENTRY_MSF_LBA] << 24 | 1268 ent[TOC_ENTRY_MSF_LBA + 1] << 16 | 1269 ent[TOC_ENTRY_MSF_LBA + 2] << 8 | 1270 ent[TOC_ENTRY_MSF_LBA + 3]); 1271 1272 lp->d_partitions[i].p_fstype = 1273 is_data ? FS_UNUSED : FS_OTHER; 1274 lp->d_partitions[i].p_offset = lba; 1275 lp->d_partitions[i].p_size = nlba - lba; 1276 lba = nlba; 1277 1278 if (is_data) { 1279 if (data_track == -1) 1280 data_track = i; 1281 1282 i++; 1283 if (i == RAW_PART) 1284 i++; 1285 1286 if (i >= MAXPARTITIONS) 1287 break; 1288 } 1289 } 1290 1291 if (i < MAXPARTITIONS) 1292 bzero(&lp->d_partitions[i], sizeof(lp->d_partitions[i])); 1293 1294 lp->d_npartitions = max(RAW_PART, i - 1) + 1; 1295 1296 done: 1297 if (toc) 1298 FREE(toc, M_TEMP); 1299 1300 /* We have a data track, look in there for a real disklabel. */ 1301 if (data_track != -1 || !toc_valid) { 1302 errstring = readdisklabel(CDLABELDEV(dev), 1303 cdstrategy, lp, clp, spoofonly); 1304 /*if (errstring) 1305 printf("%s: %s\n", cd->sc_dev.dv_xname, errstring);*/ 1306 } 1307 } 1308 1309 /* 1310 * Find out from the device what it's capacity is 1311 */ 1312 u_long 1313 cd_size(cd, flags) 1314 struct cd_softc *cd; 1315 int flags; 1316 { 1317 struct scsi_read_cd_cap_data rdcap; 1318 struct scsi_read_cd_capacity scsi_cmd; 1319 int blksize; 1320 u_long size; 1321 1322 /* Reasonable defaults for drives that don't support 1323 READ_CD_CAPCITY */ 1324 cd->params.blksize = 2048; 1325 cd->params.disksize = 400000; 1326 1327 if (cd->sc_link->quirks & ADEV_NOCAPACITY) 1328 goto exit; 1329 1330 /* 1331 * make up a scsi command and ask the scsi driver to do 1332 * it for you. 1333 */ 1334 bzero(&scsi_cmd, sizeof(scsi_cmd)); 1335 scsi_cmd.opcode = READ_CD_CAPACITY; 1336 1337 /* 1338 * If the command works, interpret the result as a 4 byte 1339 * number of blocks and a blocksize 1340 */ 1341 if (scsi_scsi_cmd(cd->sc_link, 1342 (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd), 1343 (u_char *)&rdcap, sizeof(rdcap), CDRETRIES, 20000, NULL, 1344 flags | SCSI_DATA_IN) != 0) 1345 goto exit; 1346 1347 blksize = _4btol(rdcap.length); 1348 if ((blksize < 512) || ((blksize & 511) != 0)) 1349 blksize = 2048; /* some drives lie ! */ 1350 cd->params.blksize = blksize; 1351 1352 size = _4btol(rdcap.addr) + 1; 1353 if (size < 100) 1354 size = 400000; /* ditto */ 1355 cd->params.disksize = size; 1356 1357 exit: 1358 SC_DEBUG(cd->sc_link, SDEV_DB2, ("cd_size: %d %ld\n", blksize, size)); 1359 return (cd->params.disksize); 1360 } 1361 1362 1363 /* 1364 * Get scsi driver to send a "start playing" command 1365 */ 1366 int 1367 cd_play(cd, blkno, nblks) 1368 struct cd_softc *cd; 1369 int blkno, nblks; 1370 { 1371 struct scsi_play scsi_cmd; 1372 1373 bzero(&scsi_cmd, sizeof(scsi_cmd)); 1374 scsi_cmd.opcode = PLAY; 1375 _lto4b(blkno, scsi_cmd.blk_addr); 1376 _lto2b(nblks, scsi_cmd.xfer_len); 1377 return (scsi_scsi_cmd(cd->sc_link, 1378 (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd), 1379 0, 0, CDRETRIES, 200000, NULL, 0)); 1380 } 1381 1382 /* 1383 * Get scsi driver to send a "start playing" command 1384 */ 1385 int 1386 cd_play_tracks(cd, strack, sindex, etrack, eindex) 1387 struct cd_softc *cd; 1388 int strack, sindex, etrack, eindex; 1389 { 1390 struct cd_toc toc; 1391 int error; 1392 1393 if (!etrack) 1394 return (EIO); 1395 if (strack > etrack) 1396 return (EINVAL); 1397 1398 if ((error = cd_load_toc(cd, &toc)) != 0) 1399 return (error); 1400 1401 if (++etrack > (toc.header.ending_track+1)) 1402 etrack = toc.header.ending_track+1; 1403 1404 strack -= toc.header.starting_track; 1405 etrack -= toc.header.starting_track; 1406 if (strack < 0) 1407 return (EINVAL); 1408 1409 return (cd_play_msf(cd, toc.entries[strack].addr.msf.minute, 1410 toc.entries[strack].addr.msf.second, 1411 toc.entries[strack].addr.msf.frame, 1412 toc.entries[etrack].addr.msf.minute, 1413 toc.entries[etrack].addr.msf.second, 1414 toc.entries[etrack].addr.msf.frame)); 1415 } 1416 1417 /* 1418 * Get scsi driver to send a "play msf" command 1419 */ 1420 int 1421 cd_play_msf(cd, startm, starts, startf, endm, ends, endf) 1422 struct cd_softc *cd; 1423 int startm, starts, startf, endm, ends, endf; 1424 { 1425 struct scsi_play_msf scsi_cmd; 1426 1427 bzero(&scsi_cmd, sizeof(scsi_cmd)); 1428 scsi_cmd.opcode = PLAY_MSF; 1429 scsi_cmd.start_m = startm; 1430 scsi_cmd.start_s = starts; 1431 scsi_cmd.start_f = startf; 1432 scsi_cmd.end_m = endm; 1433 scsi_cmd.end_s = ends; 1434 scsi_cmd.end_f = endf; 1435 return (scsi_scsi_cmd(cd->sc_link, 1436 (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd), 1437 0, 0, CDRETRIES, 20000, NULL, 0)); 1438 } 1439 1440 /* 1441 * Get scsi driver to send a "start up" command 1442 */ 1443 int 1444 cd_pause(cd, go) 1445 struct cd_softc *cd; 1446 int go; 1447 { 1448 struct scsi_pause scsi_cmd; 1449 1450 bzero(&scsi_cmd, sizeof(scsi_cmd)); 1451 scsi_cmd.opcode = PAUSE; 1452 scsi_cmd.resume = go; 1453 return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd, 1454 sizeof(scsi_cmd), 0, 0, CDRETRIES, 2000, NULL, 0); 1455 } 1456 1457 /* 1458 * Get scsi driver to send a "RESET" command 1459 */ 1460 int 1461 cd_reset(cd) 1462 struct cd_softc *cd; 1463 { 1464 1465 return scsi_scsi_cmd(cd->sc_link, 0, 0, 0, 0, CDRETRIES, 2000, NULL, 1466 SCSI_RESET); 1467 } 1468 1469 /* 1470 * Read subchannel 1471 */ 1472 int 1473 cd_read_subchannel(cd, mode, format, track, data, len) 1474 struct cd_softc *cd; 1475 int mode, format, track, len; 1476 struct cd_sub_channel_info *data; 1477 { 1478 struct scsi_read_subchannel scsi_cmd; 1479 1480 bzero(&scsi_cmd, sizeof(scsi_cmd)); 1481 scsi_cmd.opcode = READ_SUBCHANNEL; 1482 if (mode == CD_MSF_FORMAT) 1483 scsi_cmd.byte2 |= CD_MSF; 1484 scsi_cmd.byte3 = SRS_SUBQ; 1485 scsi_cmd.subchan_format = format; 1486 scsi_cmd.track = track; 1487 _lto2b(len, scsi_cmd.data_len); 1488 return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd, 1489 sizeof(struct scsi_read_subchannel), (u_char *)data, len, 1490 CDRETRIES, 5000, NULL, SCSI_DATA_IN|SCSI_SILENT); 1491 } 1492 1493 /* 1494 * Read table of contents 1495 */ 1496 int 1497 cd_read_toc(cd, mode, start, data, len, control) 1498 struct cd_softc *cd; 1499 int mode, start, len, control; 1500 void *data; 1501 { 1502 struct scsi_read_toc scsi_cmd; 1503 int ntoc; 1504 1505 bzero(&scsi_cmd, sizeof(scsi_cmd)); 1506 #if 0 1507 if (len!=sizeof(struct ioc_toc_header)) 1508 ntoc=((len)-sizeof(struct ioc_toc_header))/sizeof(struct cd_toc_entry); 1509 else 1510 #endif 1511 ntoc = len; 1512 scsi_cmd.opcode = READ_TOC; 1513 if (mode == CD_MSF_FORMAT) 1514 scsi_cmd.byte2 |= CD_MSF; 1515 scsi_cmd.from_track = start; 1516 _lto2b(ntoc, scsi_cmd.data_len); 1517 scsi_cmd.control = control; 1518 1519 return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd, 1520 sizeof(struct scsi_read_toc), (u_char *)data, len, CDRETRIES, 1521 5000, NULL, SCSI_DATA_IN); 1522 } 1523 1524 int 1525 cd_load_toc(cd, toc) 1526 struct cd_softc *cd; 1527 struct cd_toc *toc; 1528 { 1529 int ntracks, len, error; 1530 1531 if ((error = cd_read_toc(cd, 0, 0, toc, sizeof(toc->header), 0)) != 0) 1532 return (error); 1533 1534 ntracks = toc->header.ending_track - toc->header.starting_track + 1; 1535 len = (ntracks + 1) * sizeof(struct cd_toc_entry) + 1536 sizeof(toc->header); 1537 if ((error = cd_read_toc(cd, CD_MSF_FORMAT, 0, toc, len, 0)) != 0) 1538 return (error); 1539 return (0); 1540 } 1541 1542 1543 /* 1544 * Get the scsi driver to send a full inquiry to the device and use the 1545 * results to fill out the disk parameter structure. 1546 */ 1547 int 1548 cd_get_parms(cd, flags) 1549 struct cd_softc *cd; 1550 int flags; 1551 { 1552 /* 1553 * give a number of sectors so that sec * trks * cyls 1554 * is <= disk_size 1555 */ 1556 if (cd_size(cd, flags) == 0) 1557 return (ENXIO); 1558 return (0); 1559 } 1560 1561 int 1562 cdsize(dev) 1563 dev_t dev; 1564 { 1565 1566 /* CD-ROMs are read-only. */ 1567 return -1; 1568 } 1569 1570 int 1571 cddump(dev, blkno, va, size) 1572 dev_t dev; 1573 daddr_t blkno; 1574 caddr_t va; 1575 size_t size; 1576 { 1577 1578 /* Not implemented. */ 1579 return ENXIO; 1580 } 1581 1582 #define dvd_copy_key(dst, src) bcopy((src), (dst), DVD_KEY_SIZE) 1583 #define dvd_copy_challenge(dst, src) bcopy((src), (dst), DVD_CHALLENGE_SIZE) 1584 1585 int 1586 dvd_auth(cd, a) 1587 struct cd_softc *cd; 1588 union dvd_authinfo *a; 1589 { 1590 struct scsi_generic cmd; 1591 u_int8_t buf[20]; 1592 int error; 1593 1594 bzero(cmd.bytes, sizeof(cmd.bytes)); 1595 bzero(buf, sizeof(buf)); 1596 1597 switch (a->type) { 1598 case DVD_LU_SEND_AGID: 1599 cmd.opcode = GPCMD_REPORT_KEY; 1600 cmd.bytes[8] = 8; 1601 cmd.bytes[9] = 0 | (0 << 6); 1602 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8, 1603 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1604 if (error) 1605 return (error); 1606 a->lsa.agid = buf[7] >> 6; 1607 return (0); 1608 1609 case DVD_LU_SEND_CHALLENGE: 1610 cmd.opcode = GPCMD_REPORT_KEY; 1611 cmd.bytes[8] = 16; 1612 cmd.bytes[9] = 1 | (a->lsc.agid << 6); 1613 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16, 1614 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1615 if (error) 1616 return (error); 1617 dvd_copy_challenge(a->lsc.chal, &buf[4]); 1618 return (0); 1619 1620 case DVD_LU_SEND_KEY1: 1621 cmd.opcode = GPCMD_REPORT_KEY; 1622 cmd.bytes[8] = 12; 1623 cmd.bytes[9] = 2 | (a->lsk.agid << 6); 1624 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12, 1625 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1626 if (error) 1627 return (error); 1628 dvd_copy_key(a->lsk.key, &buf[4]); 1629 return (0); 1630 1631 case DVD_LU_SEND_TITLE_KEY: 1632 cmd.opcode = GPCMD_REPORT_KEY; 1633 _lto4b(a->lstk.lba, &cmd.bytes[1]); 1634 cmd.bytes[8] = 12; 1635 cmd.bytes[9] = 4 | (a->lstk.agid << 6); 1636 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12, 1637 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1638 if (error) 1639 return (error); 1640 a->lstk.cpm = (buf[4] >> 7) & 1; 1641 a->lstk.cp_sec = (buf[4] >> 6) & 1; 1642 a->lstk.cgms = (buf[4] >> 4) & 3; 1643 dvd_copy_key(a->lstk.title_key, &buf[5]); 1644 return (0); 1645 1646 case DVD_LU_SEND_ASF: 1647 cmd.opcode = GPCMD_REPORT_KEY; 1648 cmd.bytes[8] = 8; 1649 cmd.bytes[9] = 5 | (a->lsasf.agid << 6); 1650 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8, 1651 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1652 if (error) 1653 return (error); 1654 a->lsasf.asf = buf[7] & 1; 1655 return (0); 1656 1657 case DVD_HOST_SEND_CHALLENGE: 1658 cmd.opcode = GPCMD_SEND_KEY; 1659 cmd.bytes[8] = 16; 1660 cmd.bytes[9] = 1 | (a->hsc.agid << 6); 1661 buf[1] = 14; 1662 dvd_copy_challenge(&buf[4], a->hsc.chal); 1663 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16, 1664 CDRETRIES, 30000, NULL, SCSI_DATA_OUT); 1665 if (error) 1666 return (error); 1667 a->type = DVD_LU_SEND_KEY1; 1668 return (0); 1669 1670 case DVD_HOST_SEND_KEY2: 1671 cmd.opcode = GPCMD_SEND_KEY; 1672 cmd.bytes[8] = 12; 1673 cmd.bytes[9] = 3 | (a->hsk.agid << 6); 1674 buf[1] = 10; 1675 dvd_copy_key(&buf[4], a->hsk.key); 1676 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12, 1677 CDRETRIES, 30000, NULL, SCSI_DATA_OUT); 1678 if (error) { 1679 a->type = DVD_AUTH_FAILURE; 1680 return (error); 1681 } 1682 a->type = DVD_AUTH_ESTABLISHED; 1683 return (0); 1684 1685 case DVD_INVALIDATE_AGID: 1686 cmd.opcode = GPCMD_REPORT_KEY; 1687 cmd.bytes[9] = 0x3f | (a->lsa.agid << 6); 1688 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16, 1689 CDRETRIES, 30000, NULL, 0); 1690 if (error) 1691 return (error); 1692 return (0); 1693 1694 default: 1695 return (ENOTTY); 1696 } 1697 } 1698 1699 int 1700 dvd_read_physical(cd, s) 1701 struct cd_softc *cd; 1702 union dvd_struct *s; 1703 { 1704 struct scsi_generic cmd; 1705 u_int8_t buf[4 + 4 * 20], *bufp; 1706 int error; 1707 struct dvd_layer *layer; 1708 int i; 1709 1710 bzero(cmd.bytes, sizeof(cmd.bytes)); 1711 bzero(buf, sizeof(buf)); 1712 cmd.opcode = GPCMD_READ_DVD_STRUCTURE; 1713 cmd.bytes[6] = s->type; 1714 _lto2b(sizeof(buf), &cmd.bytes[7]); 1715 1716 cmd.bytes[5] = s->physical.layer_num; 1717 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf), 1718 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1719 if (error) 1720 return (error); 1721 for (i = 0, bufp = &buf[4], layer = &s->physical.layer[0]; i < 4; 1722 i++, bufp += 20, layer++) { 1723 bzero(layer, sizeof(*layer)); 1724 layer->book_version = bufp[0] & 0xf; 1725 layer->book_type = bufp[0] >> 4; 1726 layer->min_rate = bufp[1] & 0xf; 1727 layer->disc_size = bufp[1] >> 4; 1728 layer->layer_type = bufp[2] & 0xf; 1729 layer->track_path = (bufp[2] >> 4) & 1; 1730 layer->nlayers = (bufp[2] >> 5) & 3; 1731 layer->track_density = bufp[3] & 0xf; 1732 layer->linear_density = bufp[3] >> 4; 1733 layer->start_sector = _4btol(&bufp[4]); 1734 layer->end_sector = _4btol(&bufp[8]); 1735 layer->end_sector_l0 = _4btol(&bufp[12]); 1736 layer->bca = bufp[16] >> 7; 1737 } 1738 return (0); 1739 } 1740 1741 int 1742 dvd_read_copyright(cd, s) 1743 struct cd_softc *cd; 1744 union dvd_struct *s; 1745 { 1746 struct scsi_generic cmd; 1747 u_int8_t buf[8]; 1748 int error; 1749 1750 bzero(cmd.bytes, sizeof(cmd.bytes)); 1751 bzero(buf, sizeof(buf)); 1752 cmd.opcode = GPCMD_READ_DVD_STRUCTURE; 1753 cmd.bytes[6] = s->type; 1754 _lto2b(sizeof(buf), &cmd.bytes[7]); 1755 1756 cmd.bytes[5] = s->copyright.layer_num; 1757 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf), 1758 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1759 if (error) 1760 return (error); 1761 s->copyright.cpst = buf[4]; 1762 s->copyright.rmi = buf[5]; 1763 return (0); 1764 } 1765 1766 int 1767 dvd_read_disckey(cd, s) 1768 struct cd_softc *cd; 1769 union dvd_struct *s; 1770 { 1771 struct scsi_generic cmd; 1772 u_int8_t buf[4 + 2048]; 1773 int error; 1774 1775 bzero(cmd.bytes, sizeof(cmd.bytes)); 1776 bzero(buf, sizeof(buf)); 1777 cmd.opcode = GPCMD_READ_DVD_STRUCTURE; 1778 cmd.bytes[6] = s->type; 1779 _lto2b(sizeof(buf), &cmd.bytes[7]); 1780 1781 cmd.bytes[9] = s->disckey.agid << 6; 1782 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf), 1783 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1784 if (error) 1785 return (error); 1786 bcopy(&buf[4], s->disckey.value, 2048); 1787 return (0); 1788 } 1789 1790 int 1791 dvd_read_bca(cd, s) 1792 struct cd_softc *cd; 1793 union dvd_struct *s; 1794 { 1795 struct scsi_generic cmd; 1796 u_int8_t buf[4 + 188]; 1797 int error; 1798 1799 bzero(cmd.bytes, sizeof(cmd.bytes)); 1800 bzero(buf, sizeof(buf)); 1801 cmd.opcode = GPCMD_READ_DVD_STRUCTURE; 1802 cmd.bytes[6] = s->type; 1803 _lto2b(sizeof(buf), &cmd.bytes[7]); 1804 1805 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf), 1806 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1807 if (error) 1808 return (error); 1809 s->bca.len = _2btol(&buf[0]); 1810 if (s->bca.len < 12 || s->bca.len > 188) 1811 return (EIO); 1812 bcopy(&buf[4], s->bca.value, s->bca.len); 1813 return (0); 1814 } 1815 1816 int 1817 dvd_read_manufact(cd, s) 1818 struct cd_softc *cd; 1819 union dvd_struct *s; 1820 { 1821 struct scsi_generic cmd; 1822 u_int8_t buf[4 + 2048]; 1823 int error; 1824 1825 bzero(cmd.bytes, sizeof(cmd.bytes)); 1826 bzero(buf, sizeof(buf)); 1827 cmd.opcode = GPCMD_READ_DVD_STRUCTURE; 1828 cmd.bytes[6] = s->type; 1829 _lto2b(sizeof(buf), &cmd.bytes[7]); 1830 1831 error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf), 1832 CDRETRIES, 30000, NULL, SCSI_DATA_IN); 1833 if (error) 1834 return (error); 1835 s->manufact.len = _2btol(&buf[0]); 1836 if (s->manufact.len < 0 || s->manufact.len > 2048) 1837 return (EIO); 1838 bcopy(&buf[4], s->manufact.value, s->manufact.len); 1839 return (0); 1840 } 1841 1842 int 1843 dvd_read_struct(cd, s) 1844 struct cd_softc *cd; 1845 union dvd_struct *s; 1846 { 1847 1848 switch (s->type) { 1849 case DVD_STRUCT_PHYSICAL: 1850 return (dvd_read_physical(cd, s)); 1851 case DVD_STRUCT_COPYRIGHT: 1852 return (dvd_read_copyright(cd, s)); 1853 case DVD_STRUCT_DISCKEY: 1854 return (dvd_read_disckey(cd, s)); 1855 case DVD_STRUCT_BCA: 1856 return (dvd_read_bca(cd, s)); 1857 case DVD_STRUCT_MANUFACT: 1858 return (dvd_read_manufact(cd, s)); 1859 default: 1860 return (EINVAL); 1861 } 1862 } 1863