root/scsi/cd.c

DEFINITIONS

1. cdmatch
2. cdattach
3. cdactivate
4. cddetach
5. cdopen
6. cdclose
7. cdstrategy
8. cdstart
9. cdrestart
10. cddone
11. cdminphys
12. cdread
13. cdwrite
14. lba2msf
15. msf2lba
16. cdioctl
17. cdgetdisklabel
18. cd_size
19. cd_setchan
20. cd_getvol
21. cd_setvol
22. cd_load_unload
23. cd_set_pa_immed
24. cd_play
25. cd_play_tracks
26. cd_play_msf
27. cd_pause
28. cd_reset
29. cd_read_subchannel
30. cd_read_toc
31. cd_load_toc
32. cd_get_parms
33. cdsize
34. cddump
35. dvd_auth
36. dvd_read_physical
37. dvd_read_copyright
38. dvd_read_disckey
39. dvd_read_bca
40. dvd_read_manufact
41. dvd_read_struct
42. cd_powerhook
43. cd_interpret_sense
44. cd_kill_buffers

    1 /*      $OpenBSD: cd.c,v 1.132 2007/06/20 18:15:47 deraadt Exp $        */
    2 /*      $NetBSD: cd.c,v 1.100 1997/04/02 02:29:30 mycroft Exp $ */
    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  */
   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  */
   50 #include <sys/types.h>
   51 #include <sys/param.h>
   52 #include <sys/systm.h>
   53 #include <sys/timeout.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>
   71 #include <scsi/scsi_all.h>
   72 #include <scsi/cd.h>
   73 #include <scsi/scsi_disk.h>     /* rw_big and start_stop come from there */
   74 #include <scsi/scsiconf.h>
   77 #include <ufs/ffs/fs.h>                 /* for BBSIZE and SBSIZE */
   79 #define CDOUTSTANDING   4
   81 #define MAXTRACK        99
   82 #define CD_BLOCK_OFFSET 150
   83 #define CD_FRAMES       75
   84 #define CD_SECS         60
   86 struct cd_toc {
   87         struct ioc_toc_header header;
   88         struct cd_toc_entry entries[MAXTRACK+1]; /* One extra for the */
   89                                                  /* leadout */
   90 };
   92 int     cdmatch(struct device *, void *, void *);
   93 void    cdattach(struct device *, struct device *, void *);
   94 int     cdactivate(struct device *, enum devact);
   95 int     cddetach(struct device *, int);
   97 void    cdstart(void *);
   98 void    cdrestart(void *);
   99 void    cdminphys(struct buf *);
  100 void    cdgetdisklabel(dev_t, struct cd_softc *, struct disklabel *, int);
  101 void    cddone(struct scsi_xfer *);
u_long  cd_size(struct cd_softc *, int);
  103 void    cd_kill_buffers(struct cd_softc *);
  104 void    lba2msf(u_long, u_char *, u_char *, u_char *);
u_long  msf2lba(u_char, u_char, u_char);
  106 int     cd_setchan(struct cd_softc *, int, int, int, int, int);
  107 int     cd_getvol(struct cd_softc *cd, struct ioc_vol *, int);
  108 int     cd_setvol(struct cd_softc *, const struct ioc_vol *, int);
  109 int     cd_load_unload(struct cd_softc *, int, int);
  110 int     cd_set_pa_immed(struct cd_softc *, int);
  111 int     cd_play(struct cd_softc *, int, int);
  112 int     cd_play_tracks(struct cd_softc *, int, int, int, int);
  113 int     cd_play_msf(struct cd_softc *, int, int, int, int, int, int);
  114 int     cd_pause(struct cd_softc *, int);
  115 int     cd_reset(struct cd_softc *);
  116 int     cd_read_subchannel(struct cd_softc *, int, int, int,
  117             struct cd_sub_channel_info *, int );
  118 int     cd_read_toc(struct cd_softc *, int, int, void *, int, int);
  119 int     cd_get_parms(struct cd_softc *, int);
  120 int     cd_load_toc(struct cd_softc *, struct cd_toc *, int);
  121 int     cd_interpret_sense(struct scsi_xfer *);
  123 int    dvd_auth(struct cd_softc *, union dvd_authinfo *);
  124 int    dvd_read_physical(struct cd_softc *, union dvd_struct *);
  125 int    dvd_read_copyright(struct cd_softc *, union dvd_struct *);
  126 int    dvd_read_disckey(struct cd_softc *, union dvd_struct *);
  127 int    dvd_read_bca(struct cd_softc *, union dvd_struct *);
  128 int    dvd_read_manufact(struct cd_softc *, union dvd_struct *);
  129 int    dvd_read_struct(struct cd_softc *, union dvd_struct *);
  131 void    cd_powerhook(int why, void *arg);
  133 struct cfattach cd_ca = {
  134         sizeof(struct cd_softc), cdmatch, cdattach,
cddetach, cdactivate
  136 };
  138 struct cfdriver cd_cd = {
NULL, "cd", DV_DISK
  140 };
  142 struct dkdriver cddkdriver = { cdstrategy };
  144 struct scsi_device cd_switch = {
cd_interpret_sense,
cdstart,                /* we have a queue, which is started by this */
NULL,                   /* we do not have an async handler */
cddone,                 /* deal with stats at interrupt time */
  149 };
  151 const struct scsi_inquiry_pattern cd_patterns[] = {
  152         {T_CDROM, T_REMOV,
  153          "",         "",                 ""},
  154         {T_WORM, T_REMOV,
  155          "",         "",                 ""},
  156         {T_DIRECT, T_REMOV,
  157          "NEC                 CD-ROM DRIVE:260", "", ""},
  158 #if 0
  159         {T_CDROM, T_REMOV, /* more luns */
  160          "PIONEER ", "CD-ROM DRM-600  ", ""},
  161 #endif
  162 };
  164 #define cdlock(softc)   disk_lock(&(softc)->sc_dk)
  165 #define cdunlock(softc) disk_unlock(&(softc)->sc_dk)
  166 #define cdlookup(unit) (struct cd_softc *)device_lookup(&cd_cd, (unit))
  168 int
cdmatch(struct device *parent, void *match, void *aux)
  170 {
  171         struct scsi_attach_args *sa = aux;
  172         int priority;
scsi_inqmatch(sa->sa_inqbuf, cd_patterns,
  175             sizeof(cd_patterns)/sizeof(cd_patterns[0]), sizeof(cd_patterns[0]),
  176             &priority);
  177         return (priority);
  178 }
  180 /*
  181  * The routine called by the low level scsi routine when it discovers
  182  * A device suitable for this driver
  183  */
  184 void
cdattach(struct device *parent, struct device *self, void *aux)
  186 {
  187         struct scsi_attach_args *sa = aux;
  188         struct scsi_link *sc_link = sa->sa_sc_link;
  189         struct cd_softc *cd = (struct cd_softc *)self;
SC_DEBUG(sc_link, SDEV_DB2, ("cdattach:\n"));
  193         /*
  194          * Store information needed to contact our base driver
  195          */
cd->sc_link = sc_link;
sc_link->device = &cd_switch;
sc_link->device_softc = cd;
  199         if (sc_link->openings > CDOUTSTANDING)
sc_link->openings = CDOUTSTANDING;
  202         /*
  203          * Initialize and attach the disk structure.
  204          */
cd->sc_dk.dk_driver = &cddkdriver;
cd->sc_dk.dk_name = cd->sc_dev.dv_xname;
disk_attach(&cd->sc_dk);
  209         /*
  210          * Note if this device is ancient.  This is used in cdminphys().
  211          */
  212         if (!(sc_link->flags & SDEV_ATAPI) &&
SCSISPC(sa->sa_inqbuf->version) == 0)
cd->flags |= CDF_ANCIENT;
printf("\n");
timeout_set(&cd->sc_timeout, cdrestart, cd);
  220         if ((cd->sc_cdpwrhook = powerhook_establish(cd_powerhook, cd)) == NULL)
printf("%s: WARNING: unable to establish power hook\n",
cd->sc_dev.dv_xname);
  223 }
  226 int
cdactivate(struct device *self, enum devact act)
  228 {
  229         int rv = 0;
  231         switch (act) {
  232         case DVACT_ACTIVATE:
  233                 break;
  235         case DVACT_DEACTIVATE:
  236                 /*
  237                  * Nothing to do; we key off the device's DVF_ACTIVATE.
  238                  */
  239                 break;
  240         }
  241         return (rv);
  242 }
  245 int
cddetach(struct device *self, int flags)
  247 {
  248         struct cd_softc *cd = (struct cd_softc *)self;
  249         int bmaj, cmaj, mn;
cd_kill_buffers(cd);
  253         /* Locate the lowest minor number to be detached. */
mn = DISKMINOR(self->dv_unit, 0);
  256         for (bmaj = 0; bmaj < nblkdev; bmaj++)
  257                 if (bdevsw[bmaj].d_open == cdopen)
vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK);
  259         for (cmaj = 0; cmaj < nchrdev; cmaj++)
  260                 if (cdevsw[cmaj].d_open == cdopen)
vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR);
  263         /* Get rid of the power hook. */
  264         if (cd->sc_cdpwrhook != NULL)
powerhook_disestablish(cd->sc_cdpwrhook);
  267         /* Detach disk. */
disk_detach(&cd->sc_dk);
  270         return (0);
  271 }
  273 /*
  274  * Open the device. Make sure the partition info is as up-to-date as can be.
  275  */
  276 int
cdopen(dev_t dev, int flag, int fmt, struct proc *p)
  278 {
  279         struct scsi_link *sc_link;
  280         struct cd_softc *cd;
  281         int error = 0, part, rawopen, unit;
unit = DISKUNIT(dev);
part = DISKPART(dev);
rawopen = (part == RAW_PART) && (fmt == S_IFCHR);
cd = cdlookup(unit);
  289         if (cd == NULL)
  290                 return (ENXIO);
sc_link = cd->sc_link;
SC_DEBUG(sc_link, SDEV_DB1,
  294             ("cdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
cd_cd.cd_ndevs, part));
  297         if ((error = cdlock(cd)) != 0) {
device_unref(&cd->sc_dev);
  299                 return (error);
  300         }
  302         if (cd->sc_dk.dk_openmask != 0) {
  303                 /*
  304                  * If any partition is open, but the disk has been invalidated,
  305                  * disallow further opens.
  306                  */
  307                 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
  308                         if (rawopen)
  309                                 goto out;
error = EIO;
  311                         goto bad;
  312                 }
  313         } else {
  314                 /*
  315                  * Check that it is still responding and ok.  Drive can be in
  316                  * progress of loading media so use increased retries number
  317                  * and don't ignore NOT_READY.
  318                  */
  320                 /* Use cd_interpret_sense() now. */
sc_link->flags |= SDEV_OPEN;
error = scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
  324                     (rawopen ? SCSI_SILENT : 0) | SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
  327                 /* Start the cd spinning if necessary. */
  328                 if (error == EIO)
error = scsi_start(sc_link, SSS_START,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
  333                 if (error) {
  334                         if (rawopen) {
error = 0;
  336                                 goto out;
  337                         } else
  338                                 goto bad;
  339                 }
  341                 /* Lock the cd in. */
error = scsi_prevent(sc_link, PR_PREVENT,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
  344                 if (error)
  345                         goto bad;
  347                 /* Load the physical device parameters. */
sc_link->flags |= SDEV_MEDIA_LOADED;
  349                 if (cd_get_parms(cd, 0) != 0) {
sc_link->flags &= ~SDEV_MEDIA_LOADED;
error = ENXIO;
  352                         goto bad;
  353                 }
SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded\n"));
  356                 /* Fabricate a disk label. */
cdgetdisklabel(dev, cd, cd->sc_dk.dk_label, 0);
SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel fabricated\n"));
  359         }
  361         /* Check that the partition exists. */
  362         if (part != RAW_PART && (part >= cd->sc_dk.dk_label->d_npartitions ||
cd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
error = ENXIO;
  365                 goto bad;
  366         }
out:    /* Insure only one open at a time. */
  369         switch (fmt) {
  370         case S_IFCHR:
cd->sc_dk.dk_copenmask |= (1 << part);
  372                 break;
  373         case S_IFBLK:
cd->sc_dk.dk_bopenmask |= (1 << part);
  375                 break;
  376         }
cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask;
sc_link->flags |= SDEV_OPEN;
SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
  381         /* It's OK to fall through because dk_openmask is now non-zero. */
bad:
  383         if (cd->sc_dk.dk_openmask == 0) {
scsi_prevent(sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
  387         }
cdunlock(cd);
device_unref(&cd->sc_dev);
  391         return (error);
  392 }
  394 /*
  395  * Close the device. Only called if we are the last occurrence of an open
  396  * device.
  397  */
  398 int
  399 cdclose(dev_t dev, int flag, int fmt, struct proc *p)
  400 {
  401         struct cd_softc *cd;
  402         int part = DISKPART(dev);
  403         int error;
cd = cdlookup(DISKUNIT(dev));
  406         if (cd == NULL)
  407                 return ENXIO;
  409         if ((error = cdlock(cd)) != 0) {
device_unref(&cd->sc_dev);
  411                 return error;
  412         }
  414         switch (fmt) {
  415         case S_IFCHR:
cd->sc_dk.dk_copenmask &= ~(1 << part);
  417                 break;
  418         case S_IFBLK:
cd->sc_dk.dk_bopenmask &= ~(1 << part);
  420                 break;
  421         }
cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask;
  424         if (cd->sc_dk.dk_openmask == 0) {
  425                 /* XXXX Must wait for I/O to complete! */
scsi_prevent(cd->sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
cd->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
  431                 if (cd->sc_link->flags & SDEV_EJECTING) {
scsi_start(cd->sc_link, SSS_STOP|SSS_LOEJ, 0);
cd->sc_link->flags &= ~SDEV_EJECTING;
  435                 }
timeout_del(&cd->sc_timeout);
  438         }
cdunlock(cd);
device_unref(&cd->sc_dev);
  443         return 0;
  444 }
  446 /*
  447  * Actually translate the requested transfer into one the physical driver can
  448  * understand.  The transfer is described by a buf and will include only one
  449  * physical transfer.
  450  */
  451 void
cdstrategy(struct buf *bp)
  453 {
  454         struct cd_softc *cd;
  455         int s;
  457         if ((cd = cdlookup(DISKUNIT(bp->b_dev))) == NULL) {
bp->b_error = ENXIO;
  459                 goto bad;
  460         }
SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdstrategy: %ld bytes @ blk %d\n",
bp->b_bcount, bp->b_blkno));
  464         /*
  465          * If the device has been made invalid, error out
  466          * maybe the media changed, or no media loaded
  467          */
  468         if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
bp->b_error = EIO;
  470                 goto bad;
  471         }
  472         /*
  473          * The transfer must be a whole number of blocks.
  474          */
  475         if ((bp->b_bcount % cd->sc_dk.dk_label->d_secsize) != 0) {
bp->b_error = EINVAL;
  477                 goto bad;
  478         }
  479         /*
  480          * If it's a null transfer, return immediately
  481          */
  482         if (bp->b_bcount == 0)
  483                 goto done;
  485         /*
  486          * Do bounds checking, adjust transfer. if error, process.
  487          * If end of partition, just return.
  488          */
  489         if (DISKPART(bp->b_dev) != RAW_PART &&
bounds_check_with_label(bp, cd->sc_dk.dk_label,
  491             (cd->flags & (CDF_WLABEL|CDF_LABELLING)) != 0) <= 0)
  492                 goto done;
s = splbio();
  496         /*
  497          * Place it in the queue of disk activities for this disk
  498          */
disksort(&cd->buf_queue, bp);
  501         /*
  502          * Tell the device to get going on the transfer if it's
  503          * not doing anything, otherwise just wait for completion
  504          */
cdstart(cd);
device_unref(&cd->sc_dev);
splx(s);
  509         return;
bad:
bp->b_flags |= B_ERROR;
done:
  514         /*
  515          * Correctly set the buf to indicate a completed xfer
  516          */
bp->b_resid = bp->b_bcount;
s = splbio();
biodone(bp);
splx(s);
  521         if (cd != NULL)
device_unref(&cd->sc_dev);
  523 }
  525 /*
  526  * cdstart looks to see if there is a buf waiting for the device
  527  * and that the device is not already busy. If both are true,
  528  * It deques the buf and creates a scsi command to perform the
  529  * transfer in the buf. The transfer request will call scsi_done
  530  * on completion, which will in turn call this routine again
  531  * so that the next queued transfer is performed.
  532  * The bufs are queued by the strategy routine (cdstrategy)
  533  *
  534  * This routine is also called after other non-queued requests
  535  * have been made of the scsi driver, to ensure that the queue
  536  * continues to be drained.
  537  *
  538  * must be called at the correct (highish) spl level
  539  * cdstart() is called at splbio from cdstrategy, cdrestart and scsi_done
  540  */
  541 void
cdstart(void *v)
  543 {
  544         struct cd_softc *cd = v;
  545         struct scsi_link *sc_link = cd->sc_link;
  546         struct buf *bp = 0;
  547         struct buf *dp;
  548         struct scsi_rw_big cmd_big;
  549         struct scsi_rw cmd_small;
  550         struct scsi_generic *cmdp;
  551         int blkno, nblks, cmdlen, error;
  552         struct partition *p;
splassert(IPL_BIO);
SC_DEBUG(sc_link, SDEV_DB2, ("cdstart\n"));
  557         /*
  558          * Check if the device has room for another command
  559          */
  560         while (sc_link->openings > 0) {
  561                 /*
  562                  * there is excess capacity, but a special waits
  563                  * It'll need the adapter as soon as we clear out of the
  564                  * way and let it run (user level wait).
  565                  */
  566                 if (sc_link->flags & SDEV_WAITING) {
sc_link->flags &= ~SDEV_WAITING;
wakeup((caddr_t)sc_link);
  569                         return;
  570                 }
  572                 /*
  573                  * See if there is a buf with work for us to do..
  574                  */
dp = &cd->buf_queue;
  576                 if ((bp = dp->b_actf) == NULL)  /* yes, an assign */
  577                         return;
dp->b_actf = bp->b_actf;
  580                 /*
  581                  * If the deivce has become invalid, abort all the
  582                  * reads and writes until all files have been closed and
  583                  * re-opened
  584                  */
  585                 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
bp->b_error = EIO;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
biodone(bp);
  590                         continue;
  591                 }
  593                 /*
  594                  * We have a buf, now we should make a command
  595                  *
  596                  * First, translate the block to absolute and put it in terms
  597                  * of the logical blocksize of the device.
  598                  */
blkno =
bp->b_blkno / (cd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
p = &cd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
blkno += DL_GETPOFFSET(p);
nblks = howmany(bp->b_bcount, cd->sc_dk.dk_label->d_secsize);
  605                 /*
  606                  *  Fill out the scsi command.  If the transfer will
  607                  *  fit in a "small" cdb, use it.
  608                  */
  609                 if (!(sc_link->flags & SDEV_ATAPI) &&
  610                     !(sc_link->quirks & SDEV_ONLYBIG) && 
  611                     ((blkno & 0x1fffff) == blkno) &&
  612                     ((nblks & 0xff) == nblks)) {
  613                         /*
  614                          * We can fit in a small cdb.
  615                          */
bzero(&cmd_small, sizeof(cmd_small));
cmd_small.opcode = (bp->b_flags & B_READ) ?
READ_COMMAND : WRITE_COMMAND;
_lto3b(blkno, cmd_small.addr);
cmd_small.length = nblks & 0xff;
cmdlen = sizeof(cmd_small);
cmdp = (struct scsi_generic *)&cmd_small;
  623                 } else {
  624                         /*
  625                          * Need a large cdb.
  626                          */
bzero(&cmd_big, sizeof(cmd_big));
cmd_big.opcode = (bp->b_flags & B_READ) ?
READ_BIG : WRITE_BIG;
_lto4b(blkno, cmd_big.addr);
_lto2b(nblks, cmd_big.length);
cmdlen = sizeof(cmd_big);
cmdp = (struct scsi_generic *)&cmd_big;
  634                 }
  636                 /* Instrumentation. */
disk_busy(&cd->sc_dk);
  639                 /*
  640                  * Call the routine that chats with the adapter.
  641                  * Note: we cannot sleep as we may be an interrupt
  642                  */
error = scsi_scsi_cmd(sc_link, cmdp, cmdlen,
  644                     (u_char *) bp->b_data, bp->b_bcount, CDRETRIES, 30000, bp,
SCSI_NOSLEEP | ((bp->b_flags & B_READ) ? SCSI_DATA_IN :
SCSI_DATA_OUT));
  647                 switch (error) {
  648                 case 0:
timeout_del(&cd->sc_timeout);
  650                         break;
  651                 case EAGAIN:
  652                         /*
  653                          * The device can't start another i/o. Try again later.
  654                          */
dp->b_actf = bp;
disk_unbusy(&cd->sc_dk, 0, 0);
timeout_add(&cd->sc_timeout, 1);
  658                         return;
  659                 default:
disk_unbusy(&cd->sc_dk, 0, 0);
printf("%s: not queued, error %d\n",
cd->sc_dev.dv_xname, error);
  663                         break;
  664                 }
  665         }
  666 }
  668 void
cdrestart(void *v)
  670 {
  671         int s;
s = splbio();
cdstart(v);
splx(s);
  676 }
  678 void
cddone(struct scsi_xfer *xs)
  680 {
  681         struct cd_softc *cd = xs->sc_link->device_softc;
  683         if (xs->bp != NULL)
disk_unbusy(&cd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid,
  685                     (xs->bp->b_flags & B_READ));
  686 }
  688 void
cdminphys(struct buf *bp)
  690 {
  691         struct cd_softc *cd;
  692         long max;
cd = cdlookup(DISKUNIT(bp->b_dev));
  695         if (cd == NULL)
  696                 return;
  698         /*
  699          * If the device is ancient, we want to make sure that
  700          * the transfer fits into a 6-byte cdb.
  701          *
  702          * XXX Note that the SCSI-I spec says that 256-block transfers
  703          * are allowed in a 6-byte read/write, and are specified
  704          * by setting the "length" to 0.  However, we're conservative
  705          * here, allowing only 255-block transfers in case an
  706          * ancient device gets confused by length == 0.  A length of 0
  707          * in a 10-byte read/write actually means 0 blocks.
  708          */
  709         if (cd->flags & CDF_ANCIENT) {
max = cd->sc_dk.dk_label->d_secsize * 0xff;
  712                 if (bp->b_bcount > max)
bp->b_bcount = max;
  714         }
  716         (*cd->sc_link->adapter->scsi_minphys)(bp);
device_unref(&cd->sc_dev);
  719 }
  721 int
  722 cdread(dev_t dev, struct uio *uio, int ioflag)
  723 {
  725         return (physio(cdstrategy, NULL, dev, B_READ, cdminphys, uio));
  726 }
  728 int
  729 cdwrite(dev_t dev, struct uio *uio, int ioflag)
  730 {
  732         return (physio(cdstrategy, NULL, dev, B_WRITE, cdminphys, uio));
  733 }
  735 /*
  736  * conversion between minute-seconde-frame and logical block address
  737  * addresses format
  738  */
  739 void
lba2msf (lba, m, s, f)
u_long lba;
u_char *m, *s, *f;
  743 {
u_long tmp;
tmp = lba + CD_BLOCK_OFFSET;    /* offset of first logical frame */
tmp &= 0xffffff;                /* negative lbas use only 24 bits */
  748         *m = tmp / (CD_SECS * CD_FRAMES);
tmp %= (CD_SECS * CD_FRAMES);
  750         *s = tmp / CD_FRAMES;
  751         *f = tmp % CD_FRAMES;
  752 }
u_long
msf2lba (m, s, f)
u_char m, s, f;
  757 {
  759         return ((((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET);
  760 }
  763 /*
  764  * Perform special action on behalf of the user.
  765  * Knows about the internals of this device
  766  */
  767 int
  768 cdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
  769 {
  770         struct cd_softc *cd;
  771         struct disklabel *lp;
  772         int part = DISKPART(dev);
  773         int error = 0;
cd = cdlookup(DISKUNIT(dev));
  776         if (cd == NULL)
  777                 return ENXIO;
SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdioctl 0x%lx\n", cmd));
  781         /*
  782          * If the device is not valid.. abandon ship
  783          */
  784         if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
  785                 switch (cmd) {
  786                 case DIOCWLABEL:
  787                 case DIOCLOCK:
  788                 case DIOCEJECT:
  789                 case SCIOCIDENTIFY:
  790                 case SCIOCCOMMAND:
  791                 case SCIOCDEBUG:
  792                 case CDIOCLOADUNLOAD:
  793                 case SCIOCRESET:
  794                 case CDIOCGETVOL:
  795                 case CDIOCSETVOL:
  796                 case CDIOCSETMONO:
  797                 case CDIOCSETSTEREO:
  798                 case CDIOCSETMUTE:
  799                 case CDIOCSETLEFT:
  800                 case CDIOCSETRIGHT:
  801                 case CDIOCCLOSE:
  802                 case CDIOCEJECT:
  803                 case CDIOCALLOW:
  804                 case CDIOCPREVENT:
  805                 case CDIOCSETDEBUG:
  806                 case CDIOCCLRDEBUG:
  807                 case CDIOCRESET:
  808                 case DVD_AUTH:
  809                 case DVD_READ_STRUCT:
  810                 case MTIOCTOP:
  811                         if (part == RAW_PART)
  812                                 break;
  813                 /* FALLTHROUGH */
  814                 default:
  815                         if ((cd->sc_link->flags & SDEV_OPEN) == 0)
error = ENODEV;
  817                         else
error = EIO;
  819                         goto exit;
  820                 }
  821         }
  823         switch (cmd) {
  824         case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
cdgetdisklabel(dev, cd, lp, 0);
bcopy(lp, cd->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP);
  829                 break;
  830         case DIOCGDINFO:
  831         case DIOCGPDINFO:
  832                 *(struct disklabel *)addr = *(cd->sc_dk.dk_label);
  833                 break;
  835         case DIOCGPART:
  836                 ((struct partinfo *)addr)->disklab = cd->sc_dk.dk_label;
  837                 ((struct partinfo *)addr)->part =
  838                     &cd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
  839                 break;
  841         case DIOCWDINFO:
  842         case DIOCSDINFO:
  843                 if ((flag & FWRITE) == 0) {
error = EBADF;
  845                         break;
  846                 }
  848                 if ((error = cdlock(cd)) != 0)
  849                         break;
cd->flags |= CDF_LABELLING;
error = setdisklabel(cd->sc_dk.dk_label,
  854                     (struct disklabel *)addr, /*cd->sc_dk.dk_openmask : */0);
  855                 if (error == 0) {
  856                 }
cd->flags &= ~CDF_LABELLING;
cdunlock(cd);
  860                 break;
  862         case DIOCWLABEL:
error = EBADF;
  864                 break;
  866         case CDIOCPLAYTRACKS: {
  867                 struct ioc_play_track *args = (struct ioc_play_track *)addr;
  869                 if ((error = cd_set_pa_immed(cd, 0)) != 0)
  870                         break;
error = cd_play_tracks(cd, args->start_track,
args->start_index, args->end_track, args->end_index);
  873                 break;
  874         }
  875         case CDIOCPLAYMSF: {
  876                 struct ioc_play_msf *args = (struct ioc_play_msf *)addr;
  878                 if ((error = cd_set_pa_immed(cd, 0)) != 0)
  879                         break;
error = cd_play_msf(cd, args->start_m, args->start_s,
args->start_f, args->end_m, args->end_s, args->end_f);
  882                 break;
  883         }
  884         case CDIOCPLAYBLOCKS: {
  885                 struct ioc_play_blocks *args = (struct ioc_play_blocks *)addr;
  887                 if ((error = cd_set_pa_immed(cd, 0)) != 0)
  888                         break;
error = cd_play(cd, args->blk, args->len);
  890                 break;
  891         }
  892         case CDIOCREADSUBCHANNEL: {
  893                 struct ioc_read_subchannel *args
  894                 = (struct ioc_read_subchannel *)addr;
  895                 struct cd_sub_channel_info data;
  896                 int len = args->data_len;
  897                 if (len > sizeof(data) ||
len < sizeof(struct cd_sub_channel_header)) {
error = EINVAL;
  900                         break;
  901                 }
error = cd_read_subchannel(cd, args->address_format,
args->data_format, args->track,
  904                                            &data, len);
  905                 if (error)
  906                         break;
len = min(len, _2btol(data.header.data_len) +
  908                     sizeof(struct cd_sub_channel_header));
error = copyout(&data, args->data, len);
  910                 break;
  911         }
  912         case CDIOREADTOCHEADER: {
  913                 struct ioc_toc_header th;
  915                 if ((error = cd_read_toc(cd, 0, 0, &th, sizeof(th), 0)) != 0)
  916                         break;
  917                 if (cd->sc_link->quirks & ADEV_LITTLETOC)
th.len = letoh16(th.len);
  919                 else
th.len = betoh16(th.len);
bcopy(&th, addr, sizeof(th));
  922                 break;
  923         }
  924         case CDIOREADTOCENTRYS:  {
  925                 struct cd_toc *toc;
  926                 struct ioc_read_toc_entry *te =
  927                     (struct ioc_read_toc_entry *)addr;
  928                 struct ioc_toc_header *th;
  929                 struct cd_toc_entry *cte;
  930                 int len = te->data_len;
  931                 int ntracks;
MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP,
M_WAITOK);
bzero(toc, sizeof(*toc));
th = &toc->header;
  939                 if (len > sizeof(toc->entries) ||
len < sizeof(struct cd_toc_entry)) {
FREE(toc, M_TEMP);
error = EINVAL;
  943                         break;
  944                 }
error = cd_read_toc(cd, te->address_format, te->starting_track,
toc, len + sizeof(struct ioc_toc_header), 0);
  947                 if (error) {
FREE(toc, M_TEMP);
  949                         break;
  950                 }
  951                 if (te->address_format == CD_LBA_FORMAT)
  952                         for (ntracks =
th->ending_track - th->starting_track + 1;
ntracks >= 0; ntracks--) {
cte = &toc->entries[ntracks];
cte->addr_type = CD_LBA_FORMAT;
  957                                 if (cd->sc_link->quirks & ADEV_LITTLETOC) {
  958 #if BYTE_ORDER == BIG_ENDIAN
swap16_multi((u_int16_t *)&cte->addr,
  960                                             sizeof(cte->addr) / 2);
  961 #endif
  962                                 } else
cte->addr.lba = betoh32(cte->addr.lba);
  964                         }
  965                 if (cd->sc_link->quirks & ADEV_LITTLETOC) {
th->len = letoh16(th->len);
  967                 } else
th->len = betoh16(th->len);
len = min(len, th->len - (sizeof(th->starting_track) +
  970                     sizeof(th->ending_track)));
error = copyout(toc->entries, te->data, len);
FREE(toc, M_TEMP);
  974                 break;
  975         }
  976         case CDIOREADMSADDR: {
  977                 struct cd_toc *toc;
  978                 int sessno = *(int *)addr;
  979                 struct cd_toc_entry *cte;
  981                 if (sessno != 0) {
error = EINVAL;
  983                         break;
  984                 }
MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP,
M_WAITOK);
bzero(toc, sizeof(*toc));
error = cd_read_toc(cd, 0, 0, toc,
  991                   sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry),
  992                   0x40 /* control word for "get MS info" */);
  994                 if (error) {
FREE(toc, M_TEMP);
  996                         break;
  997                 }
cte = &toc->entries[0];
 1000                 if (cd->sc_link->quirks & ADEV_LITTLETOC) {
 1001 #if BYTE_ORDER == BIG_ENDIAN
swap16_multi((u_int16_t *)&cte->addr,
 1003                             sizeof(cte->addr) / 2);
 1004 #endif
 1005                 } else
cte->addr.lba = betoh32(cte->addr.lba);
 1007                 if (cd->sc_link->quirks & ADEV_LITTLETOC)
toc->header.len = letoh16(toc->header.len);
 1009                 else
toc->header.len = betoh16(toc->header.len);
 1012                 *(int *)addr = (toc->header.len >= 10 && cte->track > 1) ?
cte->addr.lba : 0;
FREE(toc, M_TEMP);
 1015                 break;
 1016         }
 1017         case CDIOCSETPATCH: {
 1018                 struct ioc_patch *arg = (struct ioc_patch *)addr;
error = cd_setchan(cd, arg->patch[0], arg->patch[1],
arg->patch[2], arg->patch[3], 0);
 1022                 break;
 1023         }
 1024         case CDIOCGETVOL: {
 1025                 struct ioc_vol *arg = (struct ioc_vol *)addr;
error = cd_getvol(cd, arg, 0);
 1028                 break;
 1029         }
 1030         case CDIOCSETVOL: {
 1031                 struct ioc_vol *arg = (struct ioc_vol *)addr;
error = cd_setvol(cd, arg, 0);
 1034                 break;
 1035         }
 1037         case CDIOCSETMONO:
error = cd_setchan(cd, BOTH_CHANNEL, BOTH_CHANNEL, MUTE_CHANNEL,
MUTE_CHANNEL, 0);
 1040                 break;
 1042         case CDIOCSETSTEREO:
error = cd_setchan(cd, LEFT_CHANNEL, RIGHT_CHANNEL,
MUTE_CHANNEL, MUTE_CHANNEL, 0);
 1045                 break;
 1047         case CDIOCSETMUTE:
error = cd_setchan(cd, MUTE_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL,
MUTE_CHANNEL, 0);
 1050                 break;
 1052         case CDIOCSETLEFT:
error = cd_setchan(cd, LEFT_CHANNEL, LEFT_CHANNEL, MUTE_CHANNEL,
MUTE_CHANNEL, 0);
 1055                 break;
 1057         case CDIOCSETRIGHT:
error = cd_setchan(cd, RIGHT_CHANNEL, RIGHT_CHANNEL,
MUTE_CHANNEL, MUTE_CHANNEL, 0);
 1060                 break;
 1062         case CDIOCRESUME:
error = cd_pause(cd, 1);
 1064                 break;
 1066         case CDIOCPAUSE:
error = cd_pause(cd, 0);
 1068                 break;
 1069         case CDIOCSTART:
error = scsi_start(cd->sc_link, SSS_START, 0);
 1071                 break;
 1073         case CDIOCSTOP:
error = scsi_start(cd->sc_link, SSS_STOP, 0);
 1075                 break;
close_tray:
 1078         case CDIOCCLOSE:
error = scsi_start(cd->sc_link, SSS_START|SSS_LOEJ,
SCSI_IGNORE_NOT_READY | SCSI_IGNORE_MEDIA_CHANGE);
 1081                 break;
 1083         case MTIOCTOP:
 1084                 if (((struct mtop *)addr)->mt_op == MTRETEN)
 1085                         goto close_tray;
 1086                 if (((struct mtop *)addr)->mt_op != MTOFFL) {
error = EIO;
 1088                         break;
 1089                 }
 1090                 /* FALLTHROUGH */
 1091         case CDIOCEJECT: /* FALLTHROUGH */
 1092         case DIOCEJECT:
cd->sc_link->flags |= SDEV_EJECTING;
 1094                 break;
 1095         case CDIOCALLOW:
error = scsi_prevent(cd->sc_link, PR_ALLOW, 0);
 1097                 break;
 1098         case CDIOCPREVENT:
error = scsi_prevent(cd->sc_link, PR_PREVENT, 0);
 1100                 break;
 1101         case DIOCLOCK:
error = scsi_prevent(cd->sc_link,
 1103                     (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0);
 1104                 break;
 1105         case CDIOCSETDEBUG:
cd->sc_link->flags |= (SDEV_DB1 | SDEV_DB2);
 1107                 break;
 1108         case CDIOCCLRDEBUG:
cd->sc_link->flags &= ~(SDEV_DB1 | SDEV_DB2);
 1110                 break;
 1111         case CDIOCRESET:
 1112         case SCIOCRESET:
error = cd_reset(cd);
 1114                 break;
 1115         case CDIOCLOADUNLOAD: {
 1116                 struct ioc_load_unload *args = (struct ioc_load_unload *)addr;
error = cd_load_unload(cd, args->options, args->slot);
 1119                 break;
 1120         }
 1122         case DVD_AUTH:
error = dvd_auth(cd, (union dvd_authinfo *)addr);
 1124                 break;
 1125         case DVD_READ_STRUCT:
error = dvd_read_struct(cd, (union dvd_struct *)addr);
 1127                 break;
 1128         default:
 1129                 if (DISKPART(dev) != RAW_PART) {
error = ENOTTY;
 1131                         break;
 1132                 }
error = scsi_do_ioctl(cd->sc_link, dev, cmd, addr, flag, p);
 1134                 break;
 1135         }
exit:
device_unref(&cd->sc_dev);
 1140         return (error);
 1141 }
 1143 /*
 1144  * Load the label information on the named device
 1145  * Actually fabricate a disklabel
 1146  *
 1147  * EVENTUALLY take information about different
 1148  * data tracks from the TOC and put it in the disklabel
 1149  */
 1150 void
cdgetdisklabel(dev_t dev, struct cd_softc *cd, struct disklabel *lp,
 1152     int spoofonly)
 1153 {
 1154         struct cd_toc *toc;
 1155         char *errstring;
 1156         int tocidx, n, audioonly = 1;
bzero(lp, sizeof(struct disklabel));
MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP, M_WAITOK);
bzero(toc, sizeof(*toc));
lp->d_secsize = cd->params.blksize;
lp->d_ntracks = 1;
lp->d_nsectors = 100;
lp->d_secpercyl = 100;
lp->d_ncylinders = (cd->params.disksize / 100) + 1;
 1169         if (cd->sc_link->flags & SDEV_ATAPI) {
strncpy(lp->d_typename, "ATAPI CD-ROM", sizeof(lp->d_typename));
lp->d_type = DTYPE_ATAPI;
 1172         } else {
strncpy(lp->d_typename, "SCSI CD-ROM", sizeof(lp->d_typename));
lp->d_type = DTYPE_SCSI;
 1175         }
strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
DL_SETDSIZE(lp, cd->params.disksize);
lp->d_rpm = 300;
lp->d_interleave = 1;
lp->d_version = 1;
 1183         /* XXX - these values for BBSIZE and SBSIZE assume ffs */
lp->d_bbsize = BBSIZE;
lp->d_sbsize = SBSIZE;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
 1191         if (cd_load_toc(cd, toc, CD_LBA_FORMAT)) {
audioonly = 0; /* No valid TOC found == not an audio CD. */
 1193                 goto done;
 1194         }
n = toc->header.ending_track - toc->header.starting_track + 1;
 1197         for (tocidx = 0; tocidx < n; tocidx++)
 1198                 if (toc->entries[tocidx].control & 4) {
audioonly = 0; /* Found a non-audio track. */
 1200                         goto done;
 1201                 }
done:
free(toc, M_TEMP);
 1206         if (!audioonly) {
errstring = readdisklabel(DISKLABELDEV(dev), cdstrategy, lp,
spoofonly);
 1209                 /*if (errstring)
 1210                         printf("%s: %s\n", cd->sc_dev.dv_xname, errstring);*/
 1211         }
 1212 }
 1214 /*
 1215  * Find out from the device what its capacity is
 1216  */
u_long
cd_size(struct cd_softc *cd, int flags)
 1219 {
 1220         struct scsi_read_cd_cap_data rdcap;
 1221         struct scsi_read_cd_capacity scsi_cmd;
u_long size;
 1223         int blksize;
 1225         /* Reasonable defaults for drives that don't support
 1226            READ_CD_CAPACITY */
cd->params.blksize = 2048;
cd->params.disksize = 400000;
 1230         if (cd->sc_link->quirks & ADEV_NOCAPACITY)
 1231                 goto exit;
 1233         /*
 1234          * make up a scsi command and ask the scsi driver to do
 1235          * it for you.
 1236          */
bzero(&scsi_cmd, sizeof(scsi_cmd));
scsi_cmd.opcode = READ_CD_CAPACITY;
 1240         /*
 1241          * If the command works, interpret the result as a 4 byte
 1242          * number of blocks and a blocksize
 1243          */
 1244         if (scsi_scsi_cmd(cd->sc_link,
 1245             (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd),
 1246             (u_char *)&rdcap, sizeof(rdcap), CDRETRIES, 20000, NULL,
flags | SCSI_DATA_IN) != 0)
 1248                 goto exit;
blksize = _4btol(rdcap.length);
 1251         if ((blksize < 512) || ((blksize & 511) != 0))
blksize = 2048; /* some drives lie ! */
cd->params.blksize = blksize;
size = _4btol(rdcap.addr) + 1;
 1256         if (size < 100)
size = 400000;  /* ditto */
cd->params.disksize = size;
exit:
SC_DEBUG(cd->sc_link, SDEV_DB2, ("cd_size: %d %ld\n", blksize, size));
 1262         return (cd->params.disksize);
 1263 }
 1265 int
cd_setchan(struct cd_softc *cd, int p0, int p1, int p2, int p3, int flags)
 1267 {
 1268         union scsi_mode_sense_buf *data;
 1269         struct cd_audio_page *audio = NULL;
 1270         int error, big;
data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
 1273         if (data == NULL)
 1274                 return (ENOMEM);
error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
 1277             (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, &big);
 1278         if (error == 0 && audio == NULL)
error = EIO;
 1281         if (error == 0) {
audio->port[LEFT_PORT].channels = p0;
audio->port[RIGHT_PORT].channels = p1;
audio->port[2].channels = p2;
audio->port[3].channels = p3;
 1286                 if (big)
error = scsi_mode_select_big(cd->sc_link, SMS_PF,
 1288                             &data->hdr_big, flags, 20000);
 1289                 else
error = scsi_mode_select(cd->sc_link, SMS_PF,
 1291                             &data->hdr, flags, 20000);
 1292         }
free(data, M_TEMP);
 1295         return (error);
 1296 }
 1298 int
cd_getvol(struct cd_softc *cd, struct ioc_vol *arg, int flags)
 1300 {
 1301         union scsi_mode_sense_buf *data;
 1302         struct cd_audio_page *audio = NULL;
 1303         int error;
data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
 1306         if (data == NULL)
 1307                 return (ENOMEM);
error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
 1310             (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, NULL);
 1311         if (error == 0 && audio == NULL)
error = EIO;
 1314         if (error == 0) {
arg->vol[0] = audio->port[0].volume;
arg->vol[1] = audio->port[1].volume;
arg->vol[2] = audio->port[2].volume;
arg->vol[3] = audio->port[3].volume;
 1319         }
free(data, M_TEMP);
 1322         return (0);
 1323 }
 1325 int
cd_setvol(struct cd_softc *cd, const struct ioc_vol *arg, int flags)
 1327 {
 1328         union scsi_mode_sense_buf *data;
 1329         struct cd_audio_page *audio = NULL;
u_int8_t mask_volume[4];
 1331         int error, big;
data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
 1334         if (data == NULL)
 1335                 return (ENOMEM);
error = scsi_do_mode_sense(cd->sc_link,
AUDIO_PAGE | SMS_PAGE_CTRL_CHANGEABLE, data, (void **)&audio, NULL,
NULL, NULL, sizeof(*audio), flags, NULL);
 1340         if (error == 0 && audio == NULL)
error = EIO;
 1342         if (error != 0) {
free(data, M_TEMP);
 1344                 return (error);
 1345         }
mask_volume[0] = audio->port[0].volume;
mask_volume[1] = audio->port[1].volume;
mask_volume[2] = audio->port[2].volume;
mask_volume[3] = audio->port[3].volume;
error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
 1353             (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, &big);
 1354         if (error == 0 && audio == NULL)
error = EIO;
 1356         if (error != 0) {
free(data, M_TEMP);
 1358                 return (error);
 1359         }
audio->port[0].volume = arg->vol[0] & mask_volume[0];
audio->port[1].volume = arg->vol[1] & mask_volume[1];
audio->port[2].volume = arg->vol[2] & mask_volume[2];
audio->port[3].volume = arg->vol[3] & mask_volume[3];
 1366         if (big)
error = scsi_mode_select_big(cd->sc_link, SMS_PF,
 1368                     &data->hdr_big, flags, 20000);
 1369         else
error = scsi_mode_select(cd->sc_link, SMS_PF,
 1371                     &data->hdr, flags, 20000);
free(data, M_TEMP);
 1374         return (error);
 1375 }
 1377 int
cd_load_unload(struct cd_softc *cd, int options, int slot)
 1379 {
 1380         struct scsi_load_unload cmd;
bzero(&cmd, sizeof(cmd));
cmd.opcode = LOAD_UNLOAD;
cmd.options = options;    /* ioctl uses ATAPI values */
cmd.slot = slot;
 1387         return (scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&cmd,
 1388             sizeof(cmd), 0, 0, CDRETRIES, 200000, NULL, 0));
 1389 }
 1391 int
cd_set_pa_immed(struct cd_softc *cd, int flags)
 1393 {
 1394         union scsi_mode_sense_buf *data;
 1395         struct cd_audio_page *audio = NULL;
 1396         int error, oflags, big;
 1398         if (cd->sc_link->flags & SDEV_ATAPI)
 1399                 /* XXX Noop? */
 1400                 return (0);
data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
 1403         if (data == NULL)
 1404                 return (ENOMEM);
error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
 1407             (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, &big);
 1408         if (error == 0 && audio == NULL)
error = EIO;
 1411         if (error == 0) {
oflags = audio->flags;
audio->flags &= ~CD_PA_SOTC;
audio->flags |= CD_PA_IMMED;
 1415                 if (audio->flags != oflags) {
 1416                         if (big)
error = scsi_mode_select_big(cd->sc_link,
SMS_PF, &data->hdr_big, flags,
 1419                                     20000);
 1420                         else
error = scsi_mode_select(cd->sc_link, SMS_PF,
 1422                                     &data->hdr, flags, 20000);
 1423                 }
 1424         }
free(data, M_TEMP);
 1427         return (error);
 1428 }
 1430 /*
 1431  * Get scsi driver to send a "start playing" command
 1432  */
 1433 int
cd_play(struct cd_softc *cd, int blkno, int nblks)
 1435 {
 1436         struct scsi_play scsi_cmd;
bzero(&scsi_cmd, sizeof(scsi_cmd));
scsi_cmd.opcode = PLAY;
_lto4b(blkno, scsi_cmd.blk_addr);
_lto2b(nblks, scsi_cmd.xfer_len);
 1442         return (scsi_scsi_cmd(cd->sc_link,
 1443             (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd),
 1444             0, 0, CDRETRIES, 200000, NULL, 0));
 1445 }
 1447 /*
 1448  * Get scsi driver to send a "start playing" command
 1449  */
 1450 int
cd_play_tracks(struct cd_softc *cd, int strack, int sindex, int etrack,
 1452     int eindex)
 1453 {
 1454         struct cd_toc *toc;
u_char endf, ends, endm;
 1456         int error;
 1458         if (!etrack)
 1459                 return (EIO);
 1460         if (strack > etrack)
 1461                 return (EINVAL);
MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP, M_WAITOK);
bzero(toc, sizeof(*toc));
 1466         if ((error = cd_load_toc(cd, toc, CD_MSF_FORMAT)) != 0)
 1467                 goto done;
 1469         if (++etrack > (toc->header.ending_track+1))
etrack = toc->header.ending_track+1;
strack -= toc->header.starting_track;
etrack -= toc->header.starting_track;
 1474         if (strack < 0) {
error = EINVAL;
 1476                 goto done;
 1477         }
 1479         /*
 1480          * The track ends one frame before the next begins.  The last track
 1481          * is taken care of by the leadoff track.
 1482          */
endm = toc->entries[etrack].addr.msf.minute;
ends = toc->entries[etrack].addr.msf.second;
endf = toc->entries[etrack].addr.msf.frame;
 1486         if (endf-- == 0) {
endf = CD_FRAMES - 1;
 1488                 if (ends-- == 0) {
ends = CD_SECS - 1;
 1490                         if (endm-- == 0) {
error = EINVAL;
 1492                                 goto done;
 1493                         }
 1494                 }
 1495         }
error = cd_play_msf(cd, toc->entries[strack].addr.msf.minute,
toc->entries[strack].addr.msf.second,
toc->entries[strack].addr.msf.frame,
endm, ends, endf);
done:
FREE(toc, M_TEMP);
 1504         return (error);
 1505 }
 1507 /*
 1508  * Get scsi driver to send a "play msf" command
 1509  */
 1510 int
cd_play_msf(struct cd_softc *cd, int startm, int starts, int startf, int endm,
 1512     int ends, int endf)
 1513 {
 1514         struct scsi_play_msf scsi_cmd;
bzero(&scsi_cmd, sizeof(scsi_cmd));
scsi_cmd.opcode = PLAY_MSF;
scsi_cmd.start_m = startm;
scsi_cmd.start_s = starts;
scsi_cmd.start_f = startf;
scsi_cmd.end_m = endm;
scsi_cmd.end_s = ends;
scsi_cmd.end_f = endf;
 1524         return (scsi_scsi_cmd(cd->sc_link,
 1525             (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd),
 1526             0, 0, CDRETRIES, 20000, NULL, 0));
 1527 }
 1529 /*
 1530  * Get scsi driver to send a "start up" command
 1531  */
 1532 int
cd_pause(struct cd_softc *cd, int go)
 1534 {
 1535         struct scsi_pause scsi_cmd;
bzero(&scsi_cmd, sizeof(scsi_cmd));
scsi_cmd.opcode = PAUSE;
scsi_cmd.resume = go;
 1540         return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd,
 1541             sizeof(scsi_cmd), 0, 0, CDRETRIES, 2000, NULL, 0);
 1542 }
 1544 /*
 1545  * Get scsi driver to send a "RESET" command
 1546  */
 1547 int
cd_reset(struct cd_softc *cd)
 1549 {
 1550         return scsi_scsi_cmd(cd->sc_link, 0, 0, 0, 0, CDRETRIES, 2000, NULL,
SCSI_RESET);
 1552 }
 1554 /*
 1555  * Read subchannel
 1556  */
 1557 int
cd_read_subchannel(struct cd_softc *cd, int mode, int format, int track,
 1559     struct cd_sub_channel_info *data, int len)
 1560 {
 1561         struct scsi_read_subchannel scsi_cmd;
bzero(&scsi_cmd, sizeof(scsi_cmd));
scsi_cmd.opcode = READ_SUBCHANNEL;
 1565         if (mode == CD_MSF_FORMAT)
scsi_cmd.byte2 |= CD_MSF;
scsi_cmd.byte3 = SRS_SUBQ;
scsi_cmd.subchan_format = format;
scsi_cmd.track = track;
_lto2b(len, scsi_cmd.data_len);
 1571         return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd,
 1572             sizeof(struct scsi_read_subchannel), (u_char *)data, len,
CDRETRIES, 5000, NULL, SCSI_DATA_IN|SCSI_SILENT);
 1574 }
 1576 /*
 1577  * Read table of contents
 1578  */
 1579 int
cd_read_toc(struct cd_softc *cd, int mode, int start, void *data, int len,
 1581     int control)
 1582 {
 1583         struct scsi_read_toc scsi_cmd;
bzero(&scsi_cmd, sizeof(scsi_cmd));
bzero(data, len);
scsi_cmd.opcode = READ_TOC;
 1589         if (mode == CD_MSF_FORMAT)
scsi_cmd.byte2 |= CD_MSF;
scsi_cmd.from_track = start;
_lto2b(len, scsi_cmd.data_len);
scsi_cmd.control = control;
 1595         return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd,
 1596             sizeof(struct scsi_read_toc), (u_char *)data, len, CDRETRIES,
 1597             5000, NULL, SCSI_DATA_IN | SCSI_IGNORE_ILLEGAL_REQUEST);
 1598 }
 1600 int
cd_load_toc(struct cd_softc *cd, struct cd_toc *toc, int fmt)
 1602 {
 1603         int n, len, error;
error = cd_read_toc(cd, 0, 0, toc, sizeof(toc->header), 0);
 1607         if (error == 0) {
 1608                 if (toc->header.ending_track < toc->header.starting_track)
 1609                         return (EIO);
 1610                 /* +2 to account for leading out track. */
n = toc->header.ending_track - toc->header.starting_track + 2;
len = n * sizeof(struct cd_toc_entry) + sizeof(toc->header);
error = cd_read_toc(cd, fmt, 0, toc, len, 0);
 1614         }
 1616         return (error);
 1617 }
 1620 /*
 1621  * Get the scsi driver to send a full inquiry to the device and use the
 1622  * results to fill out the disk parameter structure.
 1623  */
 1624 int
cd_get_parms(struct cd_softc *cd, int flags)
 1626 {
 1627         /*
 1628          * give a number of sectors so that sec * trks * cyls
 1629          * is <= disk_size
 1630          */
 1631         if (cd_size(cd, flags) == 0)
 1632                 return (ENXIO);
 1633         return (0);
 1634 }
daddr64_t
 1637 cdsize(dev_t dev)
 1638 {
 1640         /* CD-ROMs are read-only. */
 1641         return -1;
 1642 }
 1644 int
 1645 cddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
 1646 {
 1647         /* Not implemented. */
 1648         return ENXIO;
 1649 }
 1651 #define dvd_copy_key(dst, src)          bcopy((src), (dst), DVD_KEY_SIZE)
 1652 #define dvd_copy_challenge(dst, src)    bcopy((src), (dst), DVD_CHALLENGE_SIZE)
 1654 int
dvd_auth(struct cd_softc *cd, union dvd_authinfo *a)
 1656 {
 1657         struct scsi_generic cmd;
u_int8_t buf[20];
 1659         int error;
bzero(cmd.bytes, sizeof(cmd.bytes));
bzero(buf, sizeof(buf));
 1664         switch (a->type) {
 1665         case DVD_LU_SEND_AGID:
cmd.opcode = GPCMD_REPORT_KEY;
cmd.bytes[8] = 8;
cmd.bytes[9] = 0 | (0 << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1671                 if (error)
 1672                         return (error);
a->lsa.agid = buf[7] >> 6;
 1674                 return (0);
 1676         case DVD_LU_SEND_CHALLENGE:
cmd.opcode = GPCMD_REPORT_KEY;
cmd.bytes[8] = 16;
cmd.bytes[9] = 1 | (a->lsc.agid << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16,
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1682                 if (error)
 1683                         return (error);
dvd_copy_challenge(a->lsc.chal, &buf[4]);
 1685                 return (0);
 1687         case DVD_LU_SEND_KEY1:
cmd.opcode = GPCMD_REPORT_KEY;
cmd.bytes[8] = 12;
cmd.bytes[9] = 2 | (a->lsk.agid << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12,
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1693                 if (error)
 1694                         return (error);
dvd_copy_key(a->lsk.key, &buf[4]);
 1696                 return (0);
 1698         case DVD_LU_SEND_TITLE_KEY:
cmd.opcode = GPCMD_REPORT_KEY;
_lto4b(a->lstk.lba, &cmd.bytes[1]);
cmd.bytes[8] = 12;
cmd.bytes[9] = 4 | (a->lstk.agid << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12,
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1705                 if (error)
 1706                         return (error);
a->lstk.cpm = (buf[4] >> 7) & 1;
a->lstk.cp_sec = (buf[4] >> 6) & 1;
a->lstk.cgms = (buf[4] >> 4) & 3;
dvd_copy_key(a->lstk.title_key, &buf[5]);
 1711                 return (0);
 1713         case DVD_LU_SEND_ASF:
cmd.opcode = GPCMD_REPORT_KEY;
cmd.bytes[8] = 8;
cmd.bytes[9] = 5 | (a->lsasf.agid << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1719                 if (error)
 1720                         return (error);
a->lsasf.asf = buf[7] & 1;
 1722                 return (0);
 1724         case DVD_HOST_SEND_CHALLENGE:
cmd.opcode = GPCMD_SEND_KEY;
cmd.bytes[8] = 16;
cmd.bytes[9] = 1 | (a->hsc.agid << 6);
buf[1] = 14;
dvd_copy_challenge(&buf[4], a->hsc.chal);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16,
CDRETRIES, 30000, NULL, SCSI_DATA_OUT);
 1732                 if (error)
 1733                         return (error);
a->type = DVD_LU_SEND_KEY1;
 1735                 return (0);
 1737         case DVD_HOST_SEND_KEY2:
cmd.opcode = GPCMD_SEND_KEY;
cmd.bytes[8] = 12;
cmd.bytes[9] = 3 | (a->hsk.agid << 6);
buf[1] = 10;
dvd_copy_key(&buf[4], a->hsk.key);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12,
CDRETRIES, 30000, NULL, SCSI_DATA_OUT);
 1745                 if (error) {
a->type = DVD_AUTH_FAILURE;
 1747                         return (error);
 1748                 }
a->type = DVD_AUTH_ESTABLISHED;
 1750                 return (0);
 1752         case DVD_INVALIDATE_AGID:
cmd.opcode = GPCMD_REPORT_KEY;
cmd.bytes[9] = 0x3f | (a->lsa.agid << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16,
CDRETRIES, 30000, NULL, 0);
 1757                 if (error)
 1758                         return (error);
 1759                 return (0);
 1761         case DVD_LU_SEND_RPC_STATE:
cmd.opcode = GPCMD_REPORT_KEY;
cmd.bytes[8] = 8;
cmd.bytes[9] = 8 | (0 << 6);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1767                 if (error)
 1768                         return (error);
a->lrpcs.type = (buf[4] >> 6) & 3;
a->lrpcs.vra = (buf[4] >> 3) & 7;
a->lrpcs.ucca = (buf[4]) & 7;
a->lrpcs.region_mask = buf[5];
a->lrpcs.rpc_scheme = buf[6];
 1774                 return (0);
 1776         case DVD_HOST_SEND_RPC_STATE:
cmd.opcode = GPCMD_SEND_KEY;
cmd.bytes[8] = 8;
cmd.bytes[9] = 6 | (0 << 6);
buf[1] = 6;
buf[4] = a->hrpcs.pdrc;
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
CDRETRIES, 30000, NULL, SCSI_DATA_OUT);
 1784                 if (error)
 1785                         return (error);
 1786                 return (0);
 1788         default:
 1789                 return (ENOTTY);
 1790         }
 1791 }
 1793 int
dvd_read_physical(cd, s)
 1795         struct cd_softc *cd;
 1796         union dvd_struct *s;
 1797 {
 1798         struct scsi_generic cmd;
u_int8_t buf[4 + 4 * 20], *bufp;
 1800         int error;
 1801         struct dvd_layer *layer;
 1802         int i;
bzero(cmd.bytes, sizeof(cmd.bytes));
bzero(buf, sizeof(buf));
cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
cmd.bytes[6] = s->type;
_lto2b(sizeof(buf), &cmd.bytes[7]);
cmd.bytes[5] = s->physical.layer_num;
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf),
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1813         if (error)
 1814                 return (error);
 1815         for (i = 0, bufp = &buf[4], layer = &s->physical.layer[0]; i < 4;
i++, bufp += 20, layer++) {
bzero(layer, sizeof(*layer));
layer->book_version = bufp[0] & 0xf;
layer->book_type = bufp[0] >> 4;
layer->min_rate = bufp[1] & 0xf;
layer->disc_size = bufp[1] >> 4;
layer->layer_type = bufp[2] & 0xf;
layer->track_path = (bufp[2] >> 4) & 1;
layer->nlayers = (bufp[2] >> 5) & 3;
layer->track_density = bufp[3] & 0xf;
layer->linear_density = bufp[3] >> 4;
layer->start_sector = _4btol(&bufp[4]);
layer->end_sector = _4btol(&bufp[8]);
layer->end_sector_l0 = _4btol(&bufp[12]);
layer->bca = bufp[16] >> 7;
 1831         }
 1832         return (0);
 1833 }
 1835 int
dvd_read_copyright(cd, s)
 1837         struct cd_softc *cd;
 1838         union dvd_struct *s;
 1839 {
 1840         struct scsi_generic cmd;
u_int8_t buf[8];
 1842         int error;
bzero(cmd.bytes, sizeof(cmd.bytes));
bzero(buf, sizeof(buf));
cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
cmd.bytes[6] = s->type;
_lto2b(sizeof(buf), &cmd.bytes[7]);
cmd.bytes[5] = s->copyright.layer_num;
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf),
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1853         if (error)
 1854                 return (error);
s->copyright.cpst = buf[4];
s->copyright.rmi = buf[5];
 1857         return (0);
 1858 }
 1860 int
dvd_read_disckey(cd, s)
 1862         struct cd_softc *cd;
 1863         union dvd_struct *s;
 1864 {
 1865         struct scsi_read_dvd_structure cmd;
 1866         struct scsi_read_dvd_structure_data *buf;
 1867         int error;
buf = malloc(sizeof(*buf), M_TEMP, M_WAITOK);
 1870         if (buf == NULL)
 1871                 return (ENOMEM);
bzero(buf, sizeof(*buf));
bzero(&cmd, sizeof(cmd));
cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
cmd.format = s->type;
cmd.agid = s->disckey.agid << 6;
_lto2b(sizeof(*buf), cmd.length);
error = scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&cmd,
 1881             sizeof(cmd), (u_char *)buf, sizeof(*buf), CDRETRIES, 30000, NULL,
SCSI_DATA_IN);
 1883         if (error == 0)
bcopy(buf->data, s->disckey.value, sizeof(s->disckey.value));
free(buf, M_TEMP);
 1887         return (error);
 1888 }
 1890 int
dvd_read_bca(cd, s)
 1892         struct cd_softc *cd;
 1893         union dvd_struct *s;
 1894 {
 1895         struct scsi_generic cmd;
u_int8_t buf[4 + 188];
 1897         int error;
bzero(cmd.bytes, sizeof(cmd.bytes));
bzero(buf, sizeof(buf));
cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
cmd.bytes[6] = s->type;
_lto2b(sizeof(buf), &cmd.bytes[7]);
error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf),
CDRETRIES, 30000, NULL, SCSI_DATA_IN);
 1907         if (error)
 1908                 return (error);
s->bca.len = _2btol(&buf[0]);
 1910         if (s->bca.len < 12 || s->bca.len > 188)
 1911                 return (EIO);
bcopy(&buf[4], s->bca.value, s->bca.len);
 1913         return (0);
 1914 }
 1916 int
dvd_read_manufact(cd, s)
 1918         struct cd_softc *cd;
 1919         union dvd_struct *s;
 1920 {
 1921         struct scsi_read_dvd_structure cmd;
 1922         struct scsi_read_dvd_structure_data *buf;
 1923         int error;
buf = malloc(sizeof(*buf), M_TEMP, M_WAITOK);
 1926         if (buf == NULL)
 1927                 return (ENOMEM);
bzero(buf, sizeof(*buf));
bzero(&cmd, sizeof(cmd));
cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
cmd.format = s->type;
_lto2b(sizeof(*buf), cmd.length);
error = scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&cmd,
 1936             sizeof(cmd), (u_char *)buf, sizeof(*buf), CDRETRIES, 30000, NULL,
SCSI_DATA_IN);
 1938         if (error == 0) {
s->manufact.len = _2btol(buf->len);
 1940                 if (s->manufact.len >= 0 && s->manufact.len <= 2048)
bcopy(buf->data, s->manufact.value, s->manufact.len);
 1942                 else
error = EIO;
 1944         }
free(buf, M_TEMP);
 1947         return (error);
 1948 }
 1950 int
dvd_read_struct(cd, s)
 1952         struct cd_softc *cd;
 1953         union dvd_struct *s;
 1954 {
 1956         switch (s->type) {
 1957         case DVD_STRUCT_PHYSICAL:
 1958                 return (dvd_read_physical(cd, s));
 1959         case DVD_STRUCT_COPYRIGHT:
 1960                 return (dvd_read_copyright(cd, s));
 1961         case DVD_STRUCT_DISCKEY:
 1962                 return (dvd_read_disckey(cd, s));
 1963         case DVD_STRUCT_BCA:
 1964                 return (dvd_read_bca(cd, s));
 1965         case DVD_STRUCT_MANUFACT:
 1966                 return (dvd_read_manufact(cd, s));
 1967         default:
 1968                 return (EINVAL);
 1969         }
 1970 }
 1972 void
cd_powerhook(int why, void *arg)
 1974 {
 1975         struct cd_softc *cd = arg;
 1977         /*
 1978          * When resuming, hardware may have forgotten we locked it. So if
 1979          * there are any open partitions, lock the CD.
 1980          */
 1981         if (why == PWR_RESUME && cd->sc_dk.dk_openmask != 0)
scsi_prevent(cd->sc_link, PR_PREVENT,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
 1984 }
 1986 int
cd_interpret_sense(struct scsi_xfer *xs)
 1988 {
 1989         struct scsi_sense_data *sense = &xs->sense;
 1990         struct scsi_link *sc_link = xs->sc_link;
u_int8_t skey = sense->flags & SSD_KEY;
u_int8_t serr = sense->error_code & SSD_ERRCODE;
 1994         if (((sc_link->flags & SDEV_OPEN) == 0) ||
 1995             (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED))
 1996                 return (EJUSTRETURN); /* let the generic code handle it */
 1998         /*
 1999          * We do custom processing in cd for the unit becoming ready
 2000          * case.  We do not allow xs->retries to be decremented on the
 2001          * "Unit Becoming Ready" case. This is because CD drives
 2002          * report "Unit Becoming Ready" when loading media and can
 2003          * take a long time.  Rather than having a massive timeout for
 2004          * all operations (which would cause other problems), we allow
 2005          * operations to wait (but be interruptable with Ctrl-C)
 2006          * forever as long as the drive is reporting that it is
 2007          * becoming ready.  All other cases of not being ready are
 2008          * handled by the default handler.
 2009          */
 2010         switch(skey) {
 2011         case SKEY_NOT_READY:
 2012                 if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
 2013                         return (0);
 2014                 if (ASC_ASCQ(sense) == SENSE_NOT_READY_BECOMING_READY) {
SC_DEBUG(sc_link, SDEV_DB1, ("not ready: busy (%#x)\n",
sense->add_sense_code_qual));
 2017                         /* don't count this as a retry */
xs->retries++;
 2019                         return (scsi_delay(xs, 1));
 2020                 }
 2021                 break;
 2022         /* XXX more to come here for a few other cases */
 2023         default:
 2024                 break;
 2025         }
 2026         return (EJUSTRETURN); /* use generic handler in scsi_base */
 2027 }
 2029 /*
 2030  * Remove unprocessed buffers from queue.
 2031  */
 2032 void
cd_kill_buffers(struct cd_softc *cd)
 2034 {
 2035         struct buf *dp, *bp;
 2036         int s;
s = splbio();
 2039         for (dp = &cd->buf_queue; (bp = dp->b_actf) != NULL; ) {
dp->b_actf = bp->b_actf;
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
biodone(bp);
 2045         }
splx(s);
 2047 }