sys/cam/scsi/scsi_cd.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1997 Justin T. Gibbs.
   5  * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003 Kenneth D. Merry.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions, and the following disclaimer,
  13  *    without modification, immediately at the beginning of the file.
  14  * 2. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /*-
  31  * Portions of this driver taken from the original FreeBSD cd driver.
  32  * Written by Julian Elischer (julian@tfs.com)
  33  * for TRW Financial Systems for use under the MACH(2.5) operating system.
  34  *
  35  * TRW Financial Systems, in accordance with their agreement with Carnegie
  36  * Mellon University, makes this software available to CMU to distribute
  37  * or use in any manner that they see fit as long as this message is kept with
  38  * the software. For this reason TFS also grants any other persons or
  39  * organisations permission to use or modify this software.
  40  *
  41  * TFS supplies this software to be publicly redistributed
  42  * on the understanding that TFS is not responsible for the correct
  43  * functioning of this software in any circumstances.
  44  *
  45  * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
  46  *
  47  *      from: cd.c,v 1.83 1997/05/04 15:24:22 joerg Exp $
  48  */
  49
  50 #include <sys/cdefs.h>
  51 __FBSDID("$FreeBSD$");
  52
  53 #include "opt_cd.h"
  54
  55 #include <sys/param.h>
  56 #include <sys/systm.h>
  57 #include <sys/kernel.h>
  58 #include <sys/bio.h>
  59 #include <sys/conf.h>
  60 #include <sys/disk.h>
  61 #include <sys/malloc.h>
  62 #include <sys/cdio.h>
  63 #include <sys/cdrio.h>
  64 #include <sys/dvdio.h>
  65 #include <sys/devicestat.h>
  66 #include <sys/sbuf.h>
  67 #include <sys/sysctl.h>
  68 #include <sys/taskqueue.h>
  69 #include <geom/geom_disk.h>
  70
  71 #include <cam/cam.h>
  72 #include <cam/cam_ccb.h>
  73 #include <cam/cam_periph.h>
  74 #include <cam/cam_xpt_periph.h>
  75 #include <cam/cam_queue.h>
  76 #include <cam/cam_sim.h>
  77
  78 #include <cam/scsi/scsi_message.h>
  79 #include <cam/scsi/scsi_da.h>
  80 #include <cam/scsi/scsi_cd.h>
  81
  82 #define LEADOUT         0xaa            /* leadout toc entry */
  83
  84 struct cd_params {
  85         u_int32_t blksize;
  86         u_long    disksize;
  87 };
  88
  89 typedef enum {
  90         CD_Q_NONE               = 0x00,
  91         CD_Q_NO_TOUCH           = 0x01,
  92         CD_Q_BCD_TRACKS         = 0x02,
  93         CD_Q_10_BYTE_ONLY       = 0x10,
  94         CD_Q_RETRY_BUSY         = 0x40
  95 } cd_quirks;
  96
  97 #define CD_Q_BIT_STRING         \
  98         "\020"                  \
  99         "\001NO_TOUCH"          \
 100         "\002BCD_TRACKS"        \
 101         "\00510_BYTE_ONLY"      \
 102         "\007RETRY_BUSY"
 103
 104 typedef enum {
 105         CD_FLAG_INVALID         = 0x0001,
 106         CD_FLAG_NEW_DISC        = 0x0002,
 107         CD_FLAG_DISC_LOCKED     = 0x0004,
 108         CD_FLAG_DISC_REMOVABLE  = 0x0008,
 109         CD_FLAG_SAW_MEDIA       = 0x0010,
 110         CD_FLAG_ACTIVE          = 0x0080,
 111         CD_FLAG_SCHED_ON_COMP   = 0x0100,
 112         CD_FLAG_RETRY_UA        = 0x0200,
 113         CD_FLAG_VALID_MEDIA     = 0x0400,
 114         CD_FLAG_VALID_TOC       = 0x0800,
 115         CD_FLAG_SCTX_INIT       = 0x1000
 116 } cd_flags;
 117
 118 typedef enum {
 119         CD_CCB_PROBE            = 0x01,
 120         CD_CCB_BUFFER_IO        = 0x02,
 121         CD_CCB_TUR              = 0x04,
 122         CD_CCB_TYPE_MASK        = 0x0F,
 123         CD_CCB_RETRY_UA         = 0x10
 124 } cd_ccb_state;
 125
 126 #define ccb_state ppriv_field0
 127 #define ccb_bp ppriv_ptr1
 128
 129 struct cd_tocdata {
 130         struct ioc_toc_header header;
 131         struct cd_toc_entry entries[100];
 132 };
 133
 134 struct cd_toc_single {
 135         struct ioc_toc_header header;
 136         struct cd_toc_entry entry;
 137 };
 138
 139 typedef enum {
 140         CD_STATE_PROBE,
 141         CD_STATE_NORMAL
 142 } cd_state;
 143
 144 struct cd_softc {
 145         cam_pinfo               pinfo;
 146         cd_state                state;
 147         volatile cd_flags       flags;
 148         struct bio_queue_head   bio_queue;
 149         LIST_HEAD(, ccb_hdr)    pending_ccbs;
 150         struct cd_params        params;
 151         union ccb               saved_ccb;
 152         cd_quirks               quirks;
 153         struct cam_periph       *periph;
 154         int                     minimum_command_size;
 155         int                     outstanding_cmds;
 156         int                     tur;
 157         struct task             sysctl_task;
 158         struct sysctl_ctx_list  sysctl_ctx;
 159         struct sysctl_oid       *sysctl_tree;
 160         STAILQ_HEAD(, cd_mode_params)   mode_queue;
 161         struct cd_tocdata       toc;
 162         struct disk             *disk;
 163         struct callout          mediapoll_c;
 164
 165 #define CD_ANNOUNCETMP_SZ 120
 166         char                    announce_temp[CD_ANNOUNCETMP_SZ];
 167 #define CD_ANNOUNCE_SZ 400
 168         char                    announce_buf[CD_ANNOUNCE_SZ];
 169 };
 170
 171 struct cd_page_sizes {
 172         int page;
 173         int page_size;
 174 };
 175
 176 static struct cd_page_sizes cd_page_size_table[] =
 177 {
 178         { AUDIO_PAGE, sizeof(struct cd_audio_page)}
 179 };
 180
 181 struct cd_quirk_entry {
 182         struct scsi_inquiry_pattern inq_pat;
 183         cd_quirks quirks;
 184 };
 185
 186 /*
 187  * NOTE ON 10_BYTE_ONLY quirks:  Any 10_BYTE_ONLY quirks MUST be because
 188  * your device hangs when it gets a 10 byte command.  Adding a quirk just
 189  * to get rid of the informative diagnostic message is not acceptable.  All
 190  * 10_BYTE_ONLY quirks must be documented in full in a PR (which should be
 191  * referenced in a comment along with the quirk) , and must be approved by
 192  * ken@FreeBSD.org.  Any quirks added that don't adhere to this policy may
 193  * be removed until the submitter can explain why they are needed.
 194  * 10_BYTE_ONLY quirks will be removed (as they will no longer be necessary)
 195  * when the CAM_NEW_TRAN_CODE work is done.
 196  */
 197 static struct cd_quirk_entry cd_quirk_table[] =
 198 {
 199         {
 200                 { T_CDROM, SIP_MEDIA_REMOVABLE, "CHINON", "CD-ROM CDS-535","*"},
 201                 /* quirks */ CD_Q_BCD_TRACKS
 202         },
 203         {
 204                 /*
 205                  * VMware returns BUSY status when storage has transient
 206                  * connectivity problems, so better wait.
 207                  */
 208                 {T_CDROM, SIP_MEDIA_REMOVABLE, "NECVMWar", "VMware IDE CDR10", "*"},
 209                 /*quirks*/ CD_Q_RETRY_BUSY
 210         }
 211 };
 212
 213 static  disk_open_t     cdopen;
 214 static  disk_close_t    cdclose;
 215 static  disk_ioctl_t    cdioctl;
 216 static  disk_strategy_t cdstrategy;
 217
 218 static  periph_init_t   cdinit;
 219 static  periph_ctor_t   cdregister;
 220 static  periph_dtor_t   cdcleanup;
 221 static  periph_start_t  cdstart;
 222 static  periph_oninv_t  cdoninvalidate;
 223 static  void            cdasync(void *callback_arg, u_int32_t code,
 224                                 struct cam_path *path, void *arg);
 225 static  int             cdcmdsizesysctl(SYSCTL_HANDLER_ARGS);
 226 static  int             cdrunccb(union ccb *ccb,
 227                                  int (*error_routine)(union ccb *ccb,
 228                                                       u_int32_t cam_flags,
 229                                                       u_int32_t sense_flags),
 230                                  u_int32_t cam_flags, u_int32_t sense_flags);
 231 static  void            cddone(struct cam_periph *periph,
 232                                union ccb *start_ccb);
 233 static  union cd_pages  *cdgetpage(struct cd_mode_params *mode_params);
 234 static  int             cdgetpagesize(int page_num);
 235 static  void            cdprevent(struct cam_periph *periph, int action);
 236 static  int             cdcheckmedia(struct cam_periph *periph);
 237 static  int             cdsize(struct cam_periph *periph, u_int32_t *size);
 238 static  int             cd6byteworkaround(union ccb *ccb);
 239 static  int             cderror(union ccb *ccb, u_int32_t cam_flags,
 240                                 u_int32_t sense_flags);
 241 static  int             cdreadtoc(struct cam_periph *periph, u_int32_t mode,
 242                                   u_int32_t start, u_int8_t *data,
 243                                   u_int32_t len, u_int32_t sense_flags);
 244 static  int             cdgetmode(struct cam_periph *periph,
 245                                   struct cd_mode_params *data, u_int32_t page);
 246 static  int             cdsetmode(struct cam_periph *periph,
 247                                   struct cd_mode_params *data);
 248 static  int             cdplay(struct cam_periph *periph, u_int32_t blk,
 249                                u_int32_t len);
 250 static  int             cdreadsubchannel(struct cam_periph *periph,
 251                                          u_int32_t mode, u_int32_t format,
 252                                          int track,
 253                                          struct cd_sub_channel_info *data,
 254                                          u_int32_t len);
 255 static  int             cdplaymsf(struct cam_periph *periph, u_int32_t startm,
 256                                   u_int32_t starts, u_int32_t startf,
 257                                   u_int32_t endm, u_int32_t ends,
 258                                   u_int32_t endf);
 259 static  int             cdplaytracks(struct cam_periph *periph,
 260                                      u_int32_t strack, u_int32_t sindex,
 261                                      u_int32_t etrack, u_int32_t eindex);
 262 static  int             cdpause(struct cam_periph *periph, u_int32_t go);
 263 static  int             cdstopunit(struct cam_periph *periph, u_int32_t eject);
 264 static  int             cdstartunit(struct cam_periph *periph, int load);
 265 static  int             cdsetspeed(struct cam_periph *periph,
 266                                    u_int32_t rdspeed, u_int32_t wrspeed);
 267 static  int             cdreportkey(struct cam_periph *periph,
 268                                     struct dvd_authinfo *authinfo);
 269 static  int             cdsendkey(struct cam_periph *periph,
 270                                   struct dvd_authinfo *authinfo);
 271 static  int             cdreaddvdstructure(struct cam_periph *periph,
 272                                            struct dvd_struct *dvdstruct);
 273 static timeout_t        cdmediapoll;
 274
 275 static struct periph_driver cddriver =
 276 {
 277         cdinit, "cd",
 278         TAILQ_HEAD_INITIALIZER(cddriver.units), /* generation */ 0
 279 };
 280
 281 PERIPHDRIVER_DECLARE(cd, cddriver);
 282
 283 #ifndef CD_DEFAULT_POLL_PERIOD
 284 #define CD_DEFAULT_POLL_PERIOD  3
 285 #endif
 286 #ifndef CD_DEFAULT_RETRY
 287 #define CD_DEFAULT_RETRY        4
 288 #endif
 289 #ifndef CD_DEFAULT_TIMEOUT
 290 #define CD_DEFAULT_TIMEOUT      30000
 291 #endif
 292
 293 static int cd_poll_period = CD_DEFAULT_POLL_PERIOD;
 294 static int cd_retry_count = CD_DEFAULT_RETRY;
 295 static int cd_timeout = CD_DEFAULT_TIMEOUT;
 296
 297 static SYSCTL_NODE(_kern_cam, OID_AUTO, cd, CTLFLAG_RD, 0, "CAM CDROM driver");
 298 SYSCTL_INT(_kern_cam_cd, OID_AUTO, poll_period, CTLFLAG_RWTUN,
 299            &cd_poll_period, 0, "Media polling period in seconds");
 300 SYSCTL_INT(_kern_cam_cd, OID_AUTO, retry_count, CTLFLAG_RWTUN,
 301            &cd_retry_count, 0, "Normal I/O retry count");
 302 SYSCTL_INT(_kern_cam_cd, OID_AUTO, timeout, CTLFLAG_RWTUN,
 303            &cd_timeout, 0, "Timeout, in us, for read operations");
 304
 305 static MALLOC_DEFINE(M_SCSICD, "scsi_cd", "scsi_cd buffers");
 306
 307 static void
 308 cdinit(void)
 309 {
 310         cam_status status;
 311
 312         /*
 313          * Install a global async callback.  This callback will
 314          * receive async callbacks like "new device found".
 315          */
 316         status = xpt_register_async(AC_FOUND_DEVICE, cdasync, NULL, NULL);
 317
 318         if (status != CAM_REQ_CMP) {
 319                 printf("cd: Failed to attach master async callback "
 320                        "due to status 0x%x!\n", status);
 321         }
 322 }
 323
 324 /*
 325  * Callback from GEOM, called when it has finished cleaning up its
 326  * resources.
 327  */
 328 static void
 329 cddiskgonecb(struct disk *dp)
 330 {
 331         struct cam_periph *periph;
 332
 333         periph = (struct cam_periph *)dp->d_drv1;
 334         cam_periph_release(periph);
 335 }
 336
 337 static void
 338 cdoninvalidate(struct cam_periph *periph)
 339 {
 340         struct cd_softc *softc;
 341
 342         softc = (struct cd_softc *)periph->softc;
 343
 344         /*
 345          * De-register any async callbacks.
 346          */
 347         xpt_register_async(0, cdasync, periph, periph->path);
 348
 349         softc->flags |= CD_FLAG_INVALID;
 350
 351         /*
 352          * Return all queued I/O with ENXIO.
 353          * XXX Handle any transactions queued to the card
 354          *     with XPT_ABORT_CCB.
 355          */
 356         bioq_flush(&softc->bio_queue, NULL, ENXIO);
 357
 358         disk_gone(softc->disk);
 359 }
 360
 361 static void
 362 cdcleanup(struct cam_periph *periph)
 363 {
 364         struct cd_softc *softc;
 365
 366         softc = (struct cd_softc *)periph->softc;
 367
 368         cam_periph_unlock(periph);
 369         if ((softc->flags & CD_FLAG_SCTX_INIT) != 0
 370             && sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
 371                 xpt_print(periph->path, "can't remove sysctl context\n");
 372         }
 373
 374         callout_drain(&softc->mediapoll_c);
 375         disk_destroy(softc->disk);
 376         free(softc, M_DEVBUF);
 377         cam_periph_lock(periph);
 378 }
 379
 380 static void
 381 cdasync(void *callback_arg, u_int32_t code,
 382         struct cam_path *path, void *arg)
 383 {
 384         struct cam_periph *periph;
 385         struct cd_softc *softc;
 386
 387         periph = (struct cam_periph *)callback_arg;
 388         switch (code) {
 389         case AC_FOUND_DEVICE:
 390         {
 391                 struct ccb_getdev *cgd;
 392                 cam_status status;
 393
 394                 cgd = (struct ccb_getdev *)arg;
 395                 if (cgd == NULL)
 396                         break;
 397
 398                 if (cgd->protocol != PROTO_SCSI)
 399                         break;
 400                 if (SID_QUAL(&cgd->inq_data) != SID_QUAL_LU_CONNECTED)
 401                         break;
 402                 if (SID_TYPE(&cgd->inq_data) != T_CDROM
 403                     && SID_TYPE(&cgd->inq_data) != T_WORM)
 404                         break;
 405
 406                 /*
 407                  * Allocate a peripheral instance for
 408                  * this device and start the probe
 409                  * process.
 410                  */
 411                 status = cam_periph_alloc(cdregister, cdoninvalidate,
 412                                           cdcleanup, cdstart,
 413                                           "cd", CAM_PERIPH_BIO,
 414                                           path, cdasync,
 415                                           AC_FOUND_DEVICE, cgd);
 416
 417                 if (status != CAM_REQ_CMP
 418                  && status != CAM_REQ_INPROG)
 419                         printf("cdasync: Unable to attach new device "
 420                                "due to status 0x%x\n", status);
 421
 422                 break;
 423         }
 424         case AC_UNIT_ATTENTION:
 425         {
 426                 union ccb *ccb;
 427                 int error_code, sense_key, asc, ascq;
 428
 429                 softc = (struct cd_softc *)periph->softc;
 430                 ccb = (union ccb *)arg;
 431
 432                 /*
 433                  * Handle all media change UNIT ATTENTIONs except
 434                  * our own, as they will be handled by cderror().
 435                  */
 436                 if (xpt_path_periph(ccb->ccb_h.path) != periph &&
 437                     scsi_extract_sense_ccb(ccb,
 438                      &error_code, &sense_key, &asc, &ascq)) {
 439                         if (asc == 0x28 && ascq == 0x00)
 440                                 disk_media_changed(softc->disk, M_NOWAIT);
 441                 }
 442                 cam_periph_async(periph, code, path, arg);
 443                 break;
 444         }
 445         case AC_SCSI_AEN:
 446                 softc = (struct cd_softc *)periph->softc;
 447                 if (softc->state == CD_STATE_NORMAL && !softc->tur) {
 448                         if (cam_periph_acquire(periph) == 0) {
 449                                 softc->tur = 1;
 450                                 xpt_schedule(periph, CAM_PRIORITY_NORMAL);
 451                         }
 452                 }
 453                 /* FALLTHROUGH */
 454         case AC_SENT_BDR:
 455         case AC_BUS_RESET:
 456         {
 457                 struct ccb_hdr *ccbh;
 458
 459                 softc = (struct cd_softc *)periph->softc;
 460                 /*
 461                  * Don't fail on the expected unit attention
 462                  * that will occur.
 463                  */
 464                 softc->flags |= CD_FLAG_RETRY_UA;
 465                 LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
 466                         ccbh->ccb_state |= CD_CCB_RETRY_UA;
 467                 /* FALLTHROUGH */
 468         }
 469         default:
 470                 cam_periph_async(periph, code, path, arg);
 471                 break;
 472         }
 473 }
 474
 475 static void
 476 cdsysctlinit(void *context, int pending)
 477 {
 478         struct cam_periph *periph;
 479         struct cd_softc *softc;
 480         char tmpstr[32], tmpstr2[16];
 481
 482         periph = (struct cam_periph *)context;
 483         if (cam_periph_acquire(periph) != 0)
 484                 return;
 485
 486         softc = (struct cd_softc *)periph->softc;
 487         snprintf(tmpstr, sizeof(tmpstr), "CAM CD unit %d", periph->unit_number);
 488         snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
 489
 490         sysctl_ctx_init(&softc->sysctl_ctx);
 491         softc->flags |= CD_FLAG_SCTX_INIT;
 492         softc->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&softc->sysctl_ctx,
 493                 SYSCTL_STATIC_CHILDREN(_kern_cam_cd), OID_AUTO,
 494                 tmpstr2, CTLFLAG_RD, 0, tmpstr, "device_index");
 495
 496         if (softc->sysctl_tree == NULL) {
 497                 printf("cdsysctlinit: unable to allocate sysctl tree\n");
 498                 cam_periph_release(periph);
 499                 return;
 500         }
 501
 502         /*
 503          * Now register the sysctl handler, so the user can the value on
 504          * the fly.
 505          */
 506         SYSCTL_ADD_PROC(&softc->sysctl_ctx,SYSCTL_CHILDREN(softc->sysctl_tree),
 507                 OID_AUTO, "minimum_cmd_size", CTLTYPE_INT | CTLFLAG_RW,
 508                 &softc->minimum_command_size, 0, cdcmdsizesysctl, "I",
 509                 "Minimum CDB size");
 510
 511         cam_periph_release(periph);
 512 }
 513
 514 /*
 515  * We have a handler function for this so we can check the values when the
 516  * user sets them, instead of every time we look at them.
 517  */
 518 static int
 519 cdcmdsizesysctl(SYSCTL_HANDLER_ARGS)
 520 {
 521         int error, value;
 522
 523         value = *(int *)arg1;
 524
 525         error = sysctl_handle_int(oidp, &value, 0, req);
 526
 527         if ((error != 0)
 528          || (req->newptr == NULL))
 529                 return (error);
 530
 531         /*
 532          * The only real values we can have here are 6 or 10.  I don't
 533          * really forsee having 12 be an option at any time in the future.
 534          * So if the user sets something less than or equal to 6, we'll set
 535          * it to 6.  If he sets something greater than 6, we'll set it to 10.
 536          *
 537          * I suppose we could just return an error here for the wrong values,
 538          * but I don't think it's necessary to do so, as long as we can
 539          * determine the user's intent without too much trouble.
 540          */
 541         if (value < 6)
 542                 value = 6;
 543         else if (value > 6)
 544                 value = 10;
 545
 546         *(int *)arg1 = value;
 547
 548         return (0);
 549 }
 550
 551 static cam_status
 552 cdregister(struct cam_periph *periph, void *arg)
 553 {
 554         struct cd_softc *softc;
 555         struct ccb_pathinq cpi;
 556         struct ccb_getdev *cgd;
 557         char tmpstr[80];
 558         caddr_t match;
 559
 560         cgd = (struct ccb_getdev *)arg;
 561         if (cgd == NULL) {
 562                 printf("cdregister: no getdev CCB, can't register device\n");
 563                 return(CAM_REQ_CMP_ERR);
 564         }
 565
 566         softc = (struct cd_softc *)malloc(sizeof(*softc),M_DEVBUF,
 567             M_NOWAIT | M_ZERO);
 568         if (softc == NULL) {
 569                 printf("cdregister: Unable to probe new device. "
 570                        "Unable to allocate softc\n");
 571                 return(CAM_REQ_CMP_ERR);
 572         }
 573
 574         LIST_INIT(&softc->pending_ccbs);
 575         STAILQ_INIT(&softc->mode_queue);
 576         softc->state = CD_STATE_PROBE;
 577         bioq_init(&softc->bio_queue);
 578         if (SID_IS_REMOVABLE(&cgd->inq_data))
 579                 softc->flags |= CD_FLAG_DISC_REMOVABLE;
 580
 581         periph->softc = softc;
 582         softc->periph = periph;
 583
 584         /*
 585          * See if this device has any quirks.
 586          */
 587         match = cam_quirkmatch((caddr_t)&cgd->inq_data,
 588                                (caddr_t)cd_quirk_table,
 589                                nitems(cd_quirk_table),
 590                                sizeof(*cd_quirk_table), scsi_inquiry_match);
 591
 592         if (match != NULL)
 593                 softc->quirks = ((struct cd_quirk_entry *)match)->quirks;
 594         else
 595                 softc->quirks = CD_Q_NONE;
 596
 597         /* Check if the SIM does not want 6 byte commands */
 598         xpt_path_inq(&cpi, periph->path);
 599         if (cpi.ccb_h.status == CAM_REQ_CMP && (cpi.hba_misc & PIM_NO_6_BYTE))
 600                 softc->quirks |= CD_Q_10_BYTE_ONLY;
 601
 602         TASK_INIT(&softc->sysctl_task, 0, cdsysctlinit, periph);
 603
 604         /* The default is 6 byte commands, unless quirked otherwise */
 605         if (softc->quirks & CD_Q_10_BYTE_ONLY)
 606                 softc->minimum_command_size = 10;
 607         else
 608                 softc->minimum_command_size = 6;
 609
 610         /*
 611          * Refcount and block open attempts until we are setup
 612          * Can't block
 613          */
 614         (void)cam_periph_hold(periph, PRIBIO);
 615         cam_periph_unlock(periph);
 616         /*
 617          * Load the user's default, if any.
 618          */
 619         snprintf(tmpstr, sizeof(tmpstr), "kern.cam.cd.%d.minimum_cmd_size",
 620                  periph->unit_number);
 621         TUNABLE_INT_FETCH(tmpstr, &softc->minimum_command_size);
 622
 623         /* 6 and 10 are the only permissible values here. */
 624         if (softc->minimum_command_size < 6)
 625                 softc->minimum_command_size = 6;
 626         else if (softc->minimum_command_size > 6)
 627                 softc->minimum_command_size = 10;
 628
 629         /*
 630          * We need to register the statistics structure for this device,
 631          * but we don't have the blocksize yet for it.  So, we register
 632          * the structure and indicate that we don't have the blocksize
 633          * yet.  Unlike other SCSI peripheral drivers, we explicitly set
 634          * the device type here to be CDROM, rather than just ORing in
 635          * the device type.  This is because this driver can attach to either
 636          * CDROM or WORM devices, and we want this peripheral driver to
 637          * show up in the devstat list as a CD peripheral driver, not a
 638          * WORM peripheral driver.  WORM drives will also have the WORM
 639          * driver attached to them.
 640          */
 641         softc->disk = disk_alloc();
 642         softc->disk->d_devstat = devstat_new_entry("cd",
 643                           periph->unit_number, 0,
 644                           DEVSTAT_BS_UNAVAILABLE,
 645                           DEVSTAT_TYPE_CDROM |
 646                           XPORT_DEVSTAT_TYPE(cpi.transport),
 647                           DEVSTAT_PRIORITY_CD);
 648         softc->disk->d_open = cdopen;
 649         softc->disk->d_close = cdclose;
 650         softc->disk->d_strategy = cdstrategy;
 651         softc->disk->d_gone = cddiskgonecb;
 652         softc->disk->d_ioctl = cdioctl;
 653         softc->disk->d_name = "cd";
 654         cam_strvis(softc->disk->d_descr, cgd->inq_data.vendor,
 655             sizeof(cgd->inq_data.vendor), sizeof(softc->disk->d_descr));
 656         strlcat(softc->disk->d_descr, " ", sizeof(softc->disk->d_descr));
 657         cam_strvis(&softc->disk->d_descr[strlen(softc->disk->d_descr)],
 658             cgd->inq_data.product, sizeof(cgd->inq_data.product),
 659             sizeof(softc->disk->d_descr) - strlen(softc->disk->d_descr));
 660         softc->disk->d_unit = periph->unit_number;
 661         softc->disk->d_drv1 = periph;
 662         if (cpi.maxio == 0)
 663                 softc->disk->d_maxsize = DFLTPHYS;      /* traditional default */
 664         else if (cpi.maxio > MAXPHYS)
 665                 softc->disk->d_maxsize = MAXPHYS;       /* for safety */
 666         else
 667                 softc->disk->d_maxsize = cpi.maxio;
 668         softc->disk->d_flags = 0;
 669         softc->disk->d_hba_vendor = cpi.hba_vendor;
 670         softc->disk->d_hba_device = cpi.hba_device;
 671         softc->disk->d_hba_subvendor = cpi.hba_subvendor;
 672         softc->disk->d_hba_subdevice = cpi.hba_subdevice;
 673
 674         /*
 675          * Acquire a reference to the periph before we register with GEOM.
 676          * We'll release this reference once GEOM calls us back (via
 677          * dadiskgonecb()) telling us that our provider has been freed.
 678          */
 679         if (cam_periph_acquire(periph) != 0) {
 680                 xpt_print(periph->path, "%s: lost periph during "
 681                           "registration!\n", __func__);
 682                 cam_periph_lock(periph);
 683                 return (CAM_REQ_CMP_ERR);
 684         }
 685
 686         disk_create(softc->disk, DISK_VERSION);
 687         cam_periph_lock(periph);
 688
 689         /*
 690          * Add an async callback so that we get
 691          * notified if this device goes away.
 692          */
 693         xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
 694             AC_SCSI_AEN | AC_UNIT_ATTENTION, cdasync, periph, periph->path);
 695
 696         /*
 697          * Schedule a periodic media polling events.
 698          */
 699         callout_init_mtx(&softc->mediapoll_c, cam_periph_mtx(periph), 0);
 700         if ((softc->flags & CD_FLAG_DISC_REMOVABLE) &&
 701             (cgd->inq_flags & SID_AEN) == 0 &&
 702             cd_poll_period != 0)
 703                 callout_reset(&softc->mediapoll_c, cd_poll_period * hz,
 704                     cdmediapoll, periph);
 705
 706         xpt_schedule(periph, CAM_PRIORITY_DEV);
 707         return(CAM_REQ_CMP);
 708 }
 709
 710 static int
 711 cdopen(struct disk *dp)
 712 {
 713         struct cam_periph *periph;
 714         struct cd_softc *softc;
 715         int error;
 716
 717         periph = (struct cam_periph *)dp->d_drv1;
 718         softc = (struct cd_softc *)periph->softc;
 719
 720         if (cam_periph_acquire(periph) != 0)
 721                 return(ENXIO);
 722
 723         cam_periph_lock(periph);
 724
 725         if (softc->flags & CD_FLAG_INVALID) {
 726                 cam_periph_release_locked(periph);
 727                 cam_periph_unlock(periph);
 728                 return(ENXIO);
 729         }
 730
 731         if ((error = cam_periph_hold(periph, PRIBIO | PCATCH)) != 0) {
 732                 cam_periph_release_locked(periph);
 733                 cam_periph_unlock(periph);
 734                 return (error);
 735         }
 736
 737         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
 738             ("cdopen\n"));
 739
 740         /*
 741          * Check for media, and set the appropriate flags.  We don't bail
 742          * if we don't have media, but then we don't allow anything but the
 743          * CDIOCEJECT/CDIOCCLOSE ioctls if there is no media.
 744          */
 745         cdcheckmedia(periph);
 746
 747         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("leaving cdopen\n"));
 748         cam_periph_unhold(periph);
 749
 750         cam_periph_unlock(periph);
 751
 752         return (0);
 753 }
 754
 755 static int
 756 cdclose(struct disk *dp)
 757 {
 758         struct  cam_periph *periph;
 759         struct  cd_softc *softc;
 760
 761         periph = (struct cam_periph *)dp->d_drv1;
 762         softc = (struct cd_softc *)periph->softc;
 763
 764         cam_periph_lock(periph);
 765         if (cam_periph_hold(periph, PRIBIO) != 0) {
 766                 cam_periph_unlock(periph);
 767                 cam_periph_release(periph);
 768                 return (0);
 769         }
 770
 771         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
 772             ("cdclose\n"));
 773
 774         if ((softc->flags & CD_FLAG_DISC_REMOVABLE) != 0)
 775                 cdprevent(periph, PR_ALLOW);
 776
 777         /*
 778          * Since we're closing this CD, mark the blocksize as unavailable.
 779          * It will be marked as available when the CD is opened again.
 780          */
 781         softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
 782
 783         /*
 784          * We'll check the media and toc again at the next open().
 785          */
 786         softc->flags &= ~(CD_FLAG_VALID_MEDIA|CD_FLAG_VALID_TOC);
 787
 788         cam_periph_unhold(periph);
 789         cam_periph_release_locked(periph);
 790         cam_periph_unlock(periph);
 791
 792         return (0);
 793 }
 794
 795 static int
 796 cdrunccb(union ccb *ccb, int (*error_routine)(union ccb *ccb,
 797                                               u_int32_t cam_flags,
 798                                               u_int32_t sense_flags),
 799          u_int32_t cam_flags, u_int32_t sense_flags)
 800 {
 801         struct cd_softc *softc;
 802         struct cam_periph *periph;
 803         int error;
 804
 805         periph = xpt_path_periph(ccb->ccb_h.path);
 806         softc = (struct cd_softc *)periph->softc;
 807
 808         error = cam_periph_runccb(ccb, error_routine, cam_flags, sense_flags,
 809                                   softc->disk->d_devstat);
 810
 811         return(error);
 812 }
 813
 814 /*
 815  * Actually translate the requested transfer into one the physical driver
 816  * can understand.  The transfer is described by a buf and will include
 817  * only one physical transfer.
 818  */
 819 static void
 820 cdstrategy(struct bio *bp)
 821 {
 822         struct cam_periph *periph;
 823         struct cd_softc *softc;
 824
 825         periph = (struct cam_periph *)bp->bio_disk->d_drv1;
 826         cam_periph_lock(periph);
 827         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
 828             ("cdstrategy(%p)\n", bp));
 829
 830         softc = (struct cd_softc *)periph->softc;
 831
 832         /*
 833          * If the device has been made invalid, error out
 834          */
 835         if ((softc->flags & CD_FLAG_INVALID)) {
 836                 cam_periph_unlock(periph);
 837                 biofinish(bp, NULL, ENXIO);
 838                 return;
 839         }
 840
 841         /*
 842          * If we don't have valid media, look for it before trying to
 843          * schedule the I/O.
 844          */
 845         if ((softc->flags & CD_FLAG_VALID_MEDIA) == 0) {
 846                 int error;
 847
 848                 error = cdcheckmedia(periph);
 849                 if (error != 0) {
 850                         cam_periph_unlock(periph);
 851                         biofinish(bp, NULL, error);
 852                         return;
 853                 }
 854         }
 855
 856         /*
 857          * Place it in the queue of disk activities for this disk
 858          */
 859         bioq_disksort(&softc->bio_queue, bp);
 860
 861         xpt_schedule(periph, CAM_PRIORITY_NORMAL);
 862
 863         cam_periph_unlock(periph);
 864         return;
 865 }
 866
 867 static void
 868 cdstart(struct cam_periph *periph, union ccb *start_ccb)
 869 {
 870         struct cd_softc *softc;
 871         struct bio *bp;
 872         struct ccb_scsiio *csio;
 873         struct scsi_read_capacity_data *rcap;
 874
 875         softc = (struct cd_softc *)periph->softc;
 876
 877         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering cdstart\n"));
 878
 879         switch (softc->state) {
 880         case CD_STATE_NORMAL:
 881         {
 882                 bp = bioq_first(&softc->bio_queue);
 883                 if (bp == NULL) {
 884                         if (softc->tur) {
 885                                 softc->tur = 0;
 886                                 csio = &start_ccb->csio;
 887                                 scsi_test_unit_ready(csio,
 888                                      /*retries*/ cd_retry_count,
 889                                      cddone,
 890                                      MSG_SIMPLE_Q_TAG,
 891                                      SSD_FULL_SIZE,
 892                                      cd_timeout);
 893                                 start_ccb->ccb_h.ccb_bp = NULL;
 894                                 start_ccb->ccb_h.ccb_state = CD_CCB_TUR;
 895                                 xpt_action(start_ccb);
 896                         } else
 897                                 xpt_release_ccb(start_ccb);
 898                 } else {
 899                         if (softc->tur) {
 900                                 softc->tur = 0;
 901                                 cam_periph_release_locked(periph);
 902                         }
 903                         bioq_remove(&softc->bio_queue, bp);
 904
 905                         scsi_read_write(&start_ccb->csio,
 906                                         /*retries*/ cd_retry_count,
 907                                         /* cbfcnp */ cddone,
 908                                         MSG_SIMPLE_Q_TAG,
 909                                         /* read */bp->bio_cmd == BIO_READ ?
 910                                         SCSI_RW_READ : SCSI_RW_WRITE,
 911                                         /* byte2 */ 0,
 912                                         /* minimum_cmd_size */ 10,
 913                                         /* lba */ bp->bio_offset /
 914                                           softc->params.blksize,
 915                                         bp->bio_bcount / softc->params.blksize,
 916                                         /* data_ptr */ bp->bio_data,
 917                                         /* dxfer_len */ bp->bio_bcount,
 918                                         /* sense_len */ cd_retry_count ?
 919                                           SSD_FULL_SIZE : SF_NO_PRINT,
 920                                         /* timeout */ cd_timeout);
 921                         /* Use READ CD command for audio tracks. */
 922                         if (softc->params.blksize == 2352) {
 923                                 start_ccb->csio.cdb_io.cdb_bytes[0] = READ_CD;
 924                                 start_ccb->csio.cdb_io.cdb_bytes[9] = 0xf8;
 925                                 start_ccb->csio.cdb_io.cdb_bytes[10] = 0;
 926                                 start_ccb->csio.cdb_io.cdb_bytes[11] = 0;
 927                                 start_ccb->csio.cdb_len = 12;
 928                         }
 929                         start_ccb->ccb_h.ccb_state = CD_CCB_BUFFER_IO;
 930
 931
 932                         LIST_INSERT_HEAD(&softc->pending_ccbs,
 933                                          &start_ccb->ccb_h, periph_links.le);
 934                         softc->outstanding_cmds++;
 935
 936                         /* We expect a unit attention from this device */
 937                         if ((softc->flags & CD_FLAG_RETRY_UA) != 0) {
 938                                 start_ccb->ccb_h.ccb_state |= CD_CCB_RETRY_UA;
 939                                 softc->flags &= ~CD_FLAG_RETRY_UA;
 940                         }
 941
 942                         start_ccb->ccb_h.ccb_bp = bp;
 943                         bp = bioq_first(&softc->bio_queue);
 944
 945                         xpt_action(start_ccb);
 946                 }
 947                 if (bp != NULL || softc->tur) {
 948                         /* Have more work to do, so ensure we stay scheduled */
 949                         xpt_schedule(periph, CAM_PRIORITY_NORMAL);
 950                 }
 951                 break;
 952         }
 953         case CD_STATE_PROBE:
 954         {
 955
 956                 rcap = (struct scsi_read_capacity_data *)malloc(sizeof(*rcap),
 957                     M_SCSICD, M_NOWAIT | M_ZERO);
 958                 if (rcap == NULL) {
 959                         xpt_print(periph->path,
 960                             "cdstart: Couldn't malloc read_capacity data\n");
 961                         /* cd_free_periph??? */
 962                         break;
 963                 }
 964                 csio = &start_ccb->csio;
 965                 scsi_read_capacity(csio,
 966                                    /*retries*/ cd_retry_count,
 967                                    cddone,
 968                                    MSG_SIMPLE_Q_TAG,
 969                                    rcap,
 970                                    SSD_FULL_SIZE,
 971                                    /*timeout*/20000);
 972                 start_ccb->ccb_h.ccb_bp = NULL;
 973                 start_ccb->ccb_h.ccb_state = CD_CCB_PROBE;
 974                 xpt_action(start_ccb);
 975                 break;
 976         }
 977         }
 978 }
 979
 980 static void
 981 cddone(struct cam_periph *periph, union ccb *done_ccb)
 982 {
 983         struct cd_softc *softc;
 984         struct ccb_scsiio *csio;
 985
 986         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering cddone\n"));
 987
 988         softc = (struct cd_softc *)periph->softc;
 989         csio = &done_ccb->csio;
 990
 991         switch (csio->ccb_h.ccb_state & CD_CCB_TYPE_MASK) {
 992         case CD_CCB_BUFFER_IO:
 993         {
 994                 struct bio      *bp;
 995                 int             error;
 996
 997                 bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
 998                 error = 0;
 999
1000                 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1001                         int sf;
1002
1003                         if ((done_ccb->ccb_h.ccb_state & CD_CCB_RETRY_UA) != 0)
1004                                 sf = SF_RETRY_UA;
1005                         else
1006                                 sf = 0;
1007
1008                         error = cderror(done_ccb, CAM_RETRY_SELTO, sf);
1009                         if (error == ERESTART) {
1010                                 /*
1011                                  * A retry was scheuled, so
1012                                  * just return.
1013                                  */
1014                                 return;
1015                         }
1016                 }
1017
1018                 if (error != 0) {
1019                         xpt_print(periph->path,
1020                             "cddone: got error %#x back\n", error);
1021                         bioq_flush(&softc->bio_queue, NULL, EIO);
1022                         bp->bio_resid = bp->bio_bcount;
1023                         bp->bio_error = error;
1024                         bp->bio_flags |= BIO_ERROR;
1025                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
1026                                 cam_release_devq(done_ccb->ccb_h.path,
1027                                          /*relsim_flags*/0,
1028                                          /*reduction*/0,
1029                                          /*timeout*/0,
1030                                          /*getcount_only*/0);
1031
1032                 } else {
1033                         bp->bio_resid = csio->resid;
1034                         bp->bio_error = 0;
1035                         if (bp->bio_resid != 0) {
1036                                 /*
1037                                  * Short transfer ???
1038                                  * XXX: not sure this is correct for partial
1039                                  * transfers at EOM
1040                                  */
1041                                 bp->bio_flags |= BIO_ERROR;
1042                         }
1043                 }
1044
1045                 LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
1046                 softc->outstanding_cmds--;
1047
1048                 biofinish(bp, NULL, 0);
1049                 break;
1050         }
1051         case CD_CCB_PROBE:
1052         {
1053                 struct     scsi_read_capacity_data *rdcap;
1054                 char       *announce_buf;
1055                 struct     cd_params *cdp;
1056                 int error;
1057
1058                 cdp = &softc->params;
1059                 announce_buf = softc->announce_temp;
1060
1061                 rdcap = (struct scsi_read_capacity_data *)csio->data_ptr;
1062
1063                 cdp->disksize = scsi_4btoul (rdcap->addr) + 1;
1064                 cdp->blksize = scsi_4btoul (rdcap->length);
1065
1066                 /*
1067                  * Retry any UNIT ATTENTION type errors.  They
1068                  * are expected at boot.
1069                  */
1070                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP ||
1071                     (error = cderror(done_ccb, CAM_RETRY_SELTO,
1072                                 SF_RETRY_UA | SF_NO_PRINT)) == 0) {
1073                         snprintf(announce_buf, CD_ANNOUNCETMP_SZ,
1074                             "%juMB (%ju %u byte sectors)",
1075                             ((uintmax_t)cdp->disksize * cdp->blksize) /
1076                              (1024 * 1024),
1077                             (uintmax_t)cdp->disksize, cdp->blksize);
1078                 } else {
1079                         if (error == ERESTART) {
1080                                 /*
1081                                  * A retry was scheuled, so
1082                                  * just return.
1083                                  */
1084                                 return;
1085                         } else {
1086                                 int asc, ascq;
1087                                 int sense_key, error_code;
1088                                 int have_sense;
1089                                 cam_status status;
1090                                 struct ccb_getdev cgd;
1091
1092                                 /* Don't wedge this device's queue */
1093                                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
1094                                         cam_release_devq(done_ccb->ccb_h.path,
1095                                                  /*relsim_flags*/0,
1096                                                  /*reduction*/0,
1097                                                  /*timeout*/0,
1098                                                  /*getcount_only*/0);
1099
1100                                 status = done_ccb->ccb_h.status;
1101
1102                                 xpt_setup_ccb(&cgd.ccb_h,
1103                                               done_ccb->ccb_h.path,
1104                                               CAM_PRIORITY_NORMAL);
1105                                 cgd.ccb_h.func_code = XPT_GDEV_TYPE;
1106                                 xpt_action((union ccb *)&cgd);
1107
1108                                 if (scsi_extract_sense_ccb(done_ccb,
1109                                     &error_code, &sense_key, &asc, &ascq))
1110                                         have_sense = TRUE;
1111                                 else
1112                                         have_sense = FALSE;
1113
1114                                 /*
1115                                  * Attach to anything that claims to be a
1116                                  * CDROM or WORM device, as long as it
1117                                  * doesn't return a "Logical unit not
1118                                  * supported" (0x25) error.
1119                                  */
1120                                 if ((have_sense) && (asc != 0x25)
1121                                  && (error_code == SSD_CURRENT_ERROR)) {
1122                                         const char *sense_key_desc;
1123                                         const char *asc_desc;
1124
1125                                         scsi_sense_desc(sense_key, asc, ascq,
1126                                                         &cgd.inq_data,
1127                                                         &sense_key_desc,
1128                                                         &asc_desc);
1129                                         snprintf(announce_buf,
1130                                             sizeof(announce_buf),
1131                                                 "Attempt to query device "
1132                                                 "size failed: %s, %s",
1133                                                 sense_key_desc,
1134                                                 asc_desc);
1135                                 } else if ((have_sense == 0)
1136                                       && ((status & CAM_STATUS_MASK) ==
1137                                            CAM_SCSI_STATUS_ERROR)
1138                                       && (csio->scsi_status ==
1139                                           SCSI_STATUS_BUSY)) {
1140                                         snprintf(announce_buf,
1141                                             sizeof(announce_buf),
1142                                             "Attempt to query device "
1143                                             "size failed: SCSI Status: %s",
1144                                             scsi_status_string(csio));
1145                                 } else if (SID_TYPE(&cgd.inq_data) == T_CDROM) {
1146                                         /*
1147                                          * We only print out an error for
1148                                          * CDROM type devices.  For WORM
1149                                          * devices, we don't print out an
1150                                          * error since a few WORM devices
1151                                          * don't support CDROM commands.
1152                                          * If we have sense information, go
1153                                          * ahead and print it out.
1154                                          * Otherwise, just say that we
1155                                          * couldn't attach.
1156                                          */
1157
1158                                         /*
1159                                          * Just print out the error, not
1160                                          * the full probe message, when we
1161                                          * don't attach.
1162                                          */
1163                                         if (have_sense)
1164                                                 scsi_sense_print(
1165                                                         &done_ccb->csio);
1166                                         else {
1167                                                 xpt_print(periph->path,
1168                                                     "got CAM status %#x\n",
1169                                                     done_ccb->ccb_h.status);
1170                                         }
1171                                         xpt_print(periph->path, "fatal error, "
1172                                             "failed to attach to device\n");
1173                                         /*
1174                                          * Invalidate this peripheral.
1175                                          */
1176                                         cam_periph_invalidate(periph);
1177
1178                                         announce_buf = NULL;
1179                                 } else {
1180
1181                                         /*
1182                                          * Invalidate this peripheral.
1183                                          */
1184                                         cam_periph_invalidate(periph);
1185                                         announce_buf = NULL;
1186                                 }
1187                         }
1188                 }
1189                 free(rdcap, M_SCSICD);
1190                 if (announce_buf != NULL) {
1191                         struct sbuf sb;
1192
1193                         sbuf_new(&sb, softc->announce_buf, CD_ANNOUNCE_SZ,
1194                             SBUF_FIXEDLEN);
1195                         xpt_announce_periph_sbuf(periph, &sb, announce_buf);
1196                         xpt_announce_quirks_sbuf(periph, &sb, softc->quirks,
1197                             CD_Q_BIT_STRING);
1198                         sbuf_finish(&sb);
1199                         sbuf_putbuf(&sb);
1200
1201                         /*
1202                          * Create our sysctl variables, now that we know
1203                          * we have successfully attached.
1204                          */
1205                         taskqueue_enqueue(taskqueue_thread,&softc->sysctl_task);
1206                 }
1207                 softc->state = CD_STATE_NORMAL;
1208                 /*
1209                  * Since our peripheral may be invalidated by an error
1210                  * above or an external event, we must release our CCB
1211                  * before releasing the probe lock on the peripheral.
1212                  * The peripheral will only go away once the last lock
1213                  * is removed, and we need it around for the CCB release
1214                  * operation.
1215                  */
1216                 xpt_release_ccb(done_ccb);
1217                 cam_periph_unhold(periph);
1218                 return;
1219         }
1220         case CD_CCB_TUR:
1221         {
1222                 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1223
1224                         if (cderror(done_ccb, CAM_RETRY_SELTO,
1225                             SF_RETRY_UA | SF_NO_RECOVERY | SF_NO_PRINT) ==
1226                             ERESTART)
1227                                 return;
1228                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
1229                                 cam_release_devq(done_ccb->ccb_h.path,
1230                                                  /*relsim_flags*/0,
1231                                                  /*reduction*/0,
1232                                                  /*timeout*/0,
1233                                                  /*getcount_only*/0);
1234                 }
1235                 xpt_release_ccb(done_ccb);
1236                 cam_periph_release_locked(periph);
1237                 return;
1238         }
1239         default:
1240                 break;
1241         }
1242         xpt_release_ccb(done_ccb);
1243 }
1244
1245 static union cd_pages *
1246 cdgetpage(struct cd_mode_params *mode_params)
1247 {
1248         union cd_pages *page;
1249
1250         if (mode_params->cdb_size == 10)
1251                 page = (union cd_pages *)find_mode_page_10(
1252                         (struct scsi_mode_header_10 *)mode_params->mode_buf);
1253         else
1254                 page = (union cd_pages *)find_mode_page_6(
1255                         (struct scsi_mode_header_6 *)mode_params->mode_buf);
1256
1257         return (page);
1258 }
1259
1260 static int
1261 cdgetpagesize(int page_num)
1262 {
1263         u_int i;
1264
1265         for (i = 0; i < nitems(cd_page_size_table); i++) {
1266                 if (cd_page_size_table[i].page == page_num)
1267                         return (cd_page_size_table[i].page_size);
1268         }
1269
1270         return (-1);
1271 }
1272
1273 static int
1274 cdioctl(struct disk *dp, u_long cmd, void *addr, int flag, struct thread *td)
1275 {
1276
1277         struct  cam_periph *periph;
1278         struct  cd_softc *softc;
1279         int     nocopyout, error = 0;
1280
1281         periph = (struct cam_periph *)dp->d_drv1;
1282         cam_periph_lock(periph);
1283
1284         softc = (struct cd_softc *)periph->softc;
1285
1286         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
1287             ("cdioctl(%#lx)\n", cmd));
1288
1289         if ((error = cam_periph_hold(periph, PRIBIO | PCATCH)) != 0) {
1290                 cam_periph_unlock(periph);
1291                 cam_periph_release(periph);
1292                 return (error);
1293         }
1294
1295         /*
1296          * If we don't have media loaded, check for it.  If still don't
1297          * have media loaded, we can only do a load or eject.
1298          *
1299          * We only care whether media is loaded if this is a cd-specific ioctl
1300          * (thus the IOCGROUP check below).  Note that this will break if
1301          * anyone adds any ioctls into the switch statement below that don't
1302          * have their ioctl group set to 'c'.
1303          */
1304         if (((softc->flags & CD_FLAG_VALID_MEDIA) == 0)
1305          && ((cmd != CDIOCCLOSE)
1306           && (cmd != CDIOCEJECT))
1307          && (IOCGROUP(cmd) == 'c')) {
1308                 error = cdcheckmedia(periph);
1309                 if (error != 0) {
1310                         cam_periph_unhold(periph);
1311                         cam_periph_unlock(periph);
1312                         return (error);
1313                 }
1314         }
1315         /*
1316          * Drop the lock here so later mallocs can use WAITOK.  The periph
1317          * is essentially locked still with the cam_periph_hold call above.
1318          */
1319         cam_periph_unlock(periph);
1320
1321         nocopyout = 0;
1322         switch (cmd) {
1323
1324         case CDIOCPLAYTRACKS:
1325                 {
1326                         struct ioc_play_track *args
1327                             = (struct ioc_play_track *) addr;
1328                         struct cd_mode_params params;
1329                         union cd_pages *page;
1330
1331                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1332                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1333                                                  M_WAITOK | M_ZERO);
1334
1335                         cam_periph_lock(periph);
1336                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1337                                   ("trying to do CDIOCPLAYTRACKS\n"));
1338
1339                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1340                         if (error) {
1341                                 free(params.mode_buf, M_SCSICD);
1342                                 cam_periph_unlock(periph);
1343                                 break;
1344                         }
1345                         page = cdgetpage(&params);
1346
1347                         page->audio.flags &= ~CD_PA_SOTC;
1348                         page->audio.flags |= CD_PA_IMMED;
1349                         error = cdsetmode(periph, &params);
1350                         free(params.mode_buf, M_SCSICD);
1351                         if (error) {
1352                                 cam_periph_unlock(periph);
1353                                 break;
1354                         }
1355
1356                         /*
1357                          * This was originally implemented with the PLAY
1358                          * AUDIO TRACK INDEX command, but that command was
1359                          * deprecated after SCSI-2.  Most (all?) SCSI CDROM
1360                          * drives support it but ATAPI and ATAPI-derivative
1361                          * drives don't seem to support it.  So we keep a
1362                          * cache of the table of contents and translate
1363                          * track numbers to MSF format.
1364                          */
1365                         if (softc->flags & CD_FLAG_VALID_TOC) {
1366                                 union msf_lba *sentry, *eentry;
1367                                 int st, et;
1368
1369                                 if (args->end_track <
1370                                     softc->toc.header.ending_track + 1)
1371                                         args->end_track++;
1372                                 if (args->end_track >
1373                                     softc->toc.header.ending_track + 1)
1374                                         args->end_track =
1375                                             softc->toc.header.ending_track + 1;
1376                                 st = args->start_track -
1377                                         softc->toc.header.starting_track;
1378                                 et = args->end_track -
1379                                         softc->toc.header.starting_track;
1380                                 if ((st < 0)
1381                                  || (et < 0)
1382                                  || (st > (softc->toc.header.ending_track -
1383                                      softc->toc.header.starting_track))) {
1384                                         error = EINVAL;
1385                                         cam_periph_unlock(periph);
1386                                         break;
1387                                 }
1388                                 sentry = &softc->toc.entries[st].addr;
1389                                 eentry = &softc->toc.entries[et].addr;
1390                                 error = cdplaymsf(periph,
1391                                                   sentry->msf.minute,
1392                                                   sentry->msf.second,
1393                                                   sentry->msf.frame,
1394                                                   eentry->msf.minute,
1395                                                   eentry->msf.second,
1396                                                   eentry->msf.frame);
1397                         } else {
1398                                 /*
1399                                  * If we don't have a valid TOC, try the
1400                                  * play track index command.  It is part of
1401                                  * the SCSI-2 spec, but was removed in the
1402                                  * MMC specs.  ATAPI and ATAPI-derived
1403                                  * drives don't support it.
1404                                  */
1405                                 if (softc->quirks & CD_Q_BCD_TRACKS) {
1406                                         args->start_track =
1407                                                 bin2bcd(args->start_track);
1408                                         args->end_track =
1409                                                 bin2bcd(args->end_track);
1410                                 }
1411                                 error = cdplaytracks(periph,
1412                                                      args->start_track,
1413                                                      args->start_index,
1414                                                      args->end_track,
1415                                                      args->end_index);
1416                         }
1417                         cam_periph_unlock(periph);
1418                 }
1419                 break;
1420         case CDIOCPLAYMSF:
1421                 {
1422                         struct ioc_play_msf *args
1423                                 = (struct ioc_play_msf *) addr;
1424                         struct cd_mode_params params;
1425                         union cd_pages *page;
1426
1427                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1428                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1429                                                  M_WAITOK | M_ZERO);
1430
1431                         cam_periph_lock(periph);
1432                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1433                                   ("trying to do CDIOCPLAYMSF\n"));
1434
1435                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1436                         if (error) {
1437                                 free(params.mode_buf, M_SCSICD);
1438                                 cam_periph_unlock(periph);
1439                                 break;
1440                         }
1441                         page = cdgetpage(&params);
1442
1443                         page->audio.flags &= ~CD_PA_SOTC;
1444                         page->audio.flags |= CD_PA_IMMED;
1445                         error = cdsetmode(periph, &params);
1446                         free(params.mode_buf, M_SCSICD);
1447                         if (error) {
1448                                 cam_periph_unlock(periph);
1449                                 break;
1450                         }
1451                         error = cdplaymsf(periph,
1452                                           args->start_m,
1453                                           args->start_s,
1454                                           args->start_f,
1455                                           args->end_m,
1456                                           args->end_s,
1457                                           args->end_f);
1458                         cam_periph_unlock(periph);
1459                 }
1460                 break;
1461         case CDIOCPLAYBLOCKS:
1462                 {
1463                         struct ioc_play_blocks *args
1464                                 = (struct ioc_play_blocks *) addr;
1465                         struct cd_mode_params params;
1466                         union cd_pages *page;
1467
1468                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1469                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1470                                                  M_WAITOK | M_ZERO);
1471
1472                         cam_periph_lock(periph);
1473                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1474                                   ("trying to do CDIOCPLAYBLOCKS\n"));
1475
1476
1477                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1478                         if (error) {
1479                                 free(params.mode_buf, M_SCSICD);
1480                                 cam_periph_unlock(periph);
1481                                 break;
1482                         }
1483                         page = cdgetpage(&params);
1484
1485                         page->audio.flags &= ~CD_PA_SOTC;
1486                         page->audio.flags |= CD_PA_IMMED;
1487                         error = cdsetmode(periph, &params);
1488                         free(params.mode_buf, M_SCSICD);
1489                         if (error) {
1490                                 cam_periph_unlock(periph);
1491                                 break;
1492                         }
1493                         error = cdplay(periph, args->blk, args->len);
1494                         cam_periph_unlock(periph);
1495                 }
1496                 break;
1497         case CDIOCREADSUBCHANNEL_SYSSPACE:
1498                 nocopyout = 1;
1499                 /* Fallthrough */
1500         case CDIOCREADSUBCHANNEL:
1501                 {
1502                         struct ioc_read_subchannel *args
1503                                 = (struct ioc_read_subchannel *) addr;
1504                         struct cd_sub_channel_info *data;
1505                         u_int32_t len = args->data_len;
1506
1507                         data = malloc(sizeof(struct cd_sub_channel_info),
1508                                       M_SCSICD, M_WAITOK | M_ZERO);
1509
1510                         cam_periph_lock(periph);
1511                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1512                                   ("trying to do CDIOCREADSUBCHANNEL\n"));
1513
1514                         if ((len > sizeof(struct cd_sub_channel_info)) ||
1515                             (len < sizeof(struct cd_sub_channel_header))) {
1516                                 printf(
1517                                         "scsi_cd: cdioctl: "
1518                                         "cdioreadsubchannel: error, len=%d\n",
1519                                         len);
1520                                 error = EINVAL;
1521                                 free(data, M_SCSICD);
1522                                 cam_periph_unlock(periph);
1523                                 break;
1524                         }
1525
1526                         if (softc->quirks & CD_Q_BCD_TRACKS)
1527                                 args->track = bin2bcd(args->track);
1528
1529                         error = cdreadsubchannel(periph, args->address_format,
1530                                 args->data_format, args->track, data, len);
1531
1532                         if (error) {
1533                                 free(data, M_SCSICD);
1534                                 cam_periph_unlock(periph);
1535                                 break;
1536                         }
1537                         if (softc->quirks & CD_Q_BCD_TRACKS)
1538                                 data->what.track_info.track_number =
1539                                     bcd2bin(data->what.track_info.track_number);
1540                         len = min(len, ((data->header.data_len[0] << 8) +
1541                                 data->header.data_len[1] +
1542                                 sizeof(struct cd_sub_channel_header)));
1543                         cam_periph_unlock(periph);
1544                         if (nocopyout == 0) {
1545                                 if (copyout(data, args->data, len) != 0) {
1546                                         error = EFAULT;
1547                                 }
1548                         } else {
1549                                 bcopy(data, args->data, len);
1550                         }
1551                         free(data, M_SCSICD);
1552                 }
1553                 break;
1554
1555         case CDIOREADTOCHEADER:
1556                 {
1557                         struct ioc_toc_header *th;
1558
1559                         th = malloc(sizeof(struct ioc_toc_header), M_SCSICD,
1560                                     M_WAITOK | M_ZERO);
1561
1562                         cam_periph_lock(periph);
1563                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1564                                   ("trying to do CDIOREADTOCHEADER\n"));
1565
1566                         error = cdreadtoc(periph, 0, 0, (u_int8_t *)th,
1567                                           sizeof (*th), /*sense_flags*/SF_NO_PRINT);
1568                         if (error) {
1569                                 free(th, M_SCSICD);
1570                                 cam_periph_unlock(periph);
1571                                 break;
1572                         }
1573                         if (softc->quirks & CD_Q_BCD_TRACKS) {
1574                                 /* we are going to have to convert the BCD
1575                                  * encoding on the cd to what is expected
1576                                  */
1577                                 th->starting_track =
1578                                         bcd2bin(th->starting_track);
1579                                 th->ending_track = bcd2bin(th->ending_track);
1580                         }
1581                         th->len = ntohs(th->len);
1582                         bcopy(th, addr, sizeof(*th));
1583                         free(th, M_SCSICD);
1584                         cam_periph_unlock(periph);
1585                 }
1586                 break;
1587         case CDIOREADTOCENTRYS:
1588                 {
1589                         struct cd_tocdata *data;
1590                         struct cd_toc_single *lead;
1591                         struct ioc_read_toc_entry *te =
1592                                 (struct ioc_read_toc_entry *) addr;
1593                         struct ioc_toc_header *th;
1594                         u_int32_t len, readlen, idx, num;
1595                         u_int32_t starting_track = te->starting_track;
1596
1597                         data = malloc(sizeof(*data), M_SCSICD, M_WAITOK | M_ZERO);
1598                         lead = malloc(sizeof(*lead), M_SCSICD, M_WAITOK | M_ZERO);
1599
1600                         cam_periph_lock(periph);
1601                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1602                                   ("trying to do CDIOREADTOCENTRYS\n"));
1603
1604                         if (te->data_len < sizeof(struct cd_toc_entry)
1605                          || (te->data_len % sizeof(struct cd_toc_entry)) != 0
1606                          || (te->address_format != CD_MSF_FORMAT
1607                           && te->address_format != CD_LBA_FORMAT)) {
1608                                 error = EINVAL;
1609                                 printf("scsi_cd: error in readtocentries, "
1610                                        "returning EINVAL\n");
1611                                 free(data, M_SCSICD);
1612                                 free(lead, M_SCSICD);
1613                                 cam_periph_unlock(periph);
1614                                 break;
1615                         }
1616
1617                         th = &data->header;
1618                         error = cdreadtoc(periph, 0, 0, (u_int8_t *)th,
1619                                           sizeof (*th), /*sense_flags*/0);
1620                         if (error) {
1621                                 free(data, M_SCSICD);
1622                                 free(lead, M_SCSICD);
1623                                 cam_periph_unlock(periph);
1624                                 break;
1625                         }
1626
1627                         if (softc->quirks & CD_Q_BCD_TRACKS) {
1628                                 /* we are going to have to convert the BCD
1629                                  * encoding on the cd to what is expected
1630                                  */
1631                                 th->starting_track =
1632                                     bcd2bin(th->starting_track);
1633                                 th->ending_track = bcd2bin(th->ending_track);
1634                         }
1635
1636                         if (starting_track == 0)
1637                                 starting_track = th->starting_track;
1638                         else if (starting_track == LEADOUT)
1639                                 starting_track = th->ending_track + 1;
1640                         else if (starting_track < th->starting_track ||
1641                                  starting_track > th->ending_track + 1) {
1642                                 printf("scsi_cd: error in readtocentries, "
1643                                        "returning EINVAL\n");
1644                                 free(data, M_SCSICD);
1645                                 free(lead, M_SCSICD);
1646                                 cam_periph_unlock(periph);
1647                                 error = EINVAL;
1648                                 break;
1649                         }
1650
1651                         /* calculate reading length without leadout entry */
1652                         readlen = (th->ending_track - starting_track + 1) *
1653                                   sizeof(struct cd_toc_entry);
1654
1655                         /* and with leadout entry */
1656                         len = readlen + sizeof(struct cd_toc_entry);
1657                         if (te->data_len < len) {
1658                                 len = te->data_len;
1659                                 if (readlen > len)
1660                                         readlen = len;
1661                         }
1662                         if (len > sizeof(data->entries)) {
1663                                 printf("scsi_cd: error in readtocentries, "
1664                                        "returning EINVAL\n");
1665                                 error = EINVAL;
1666                                 free(data, M_SCSICD);
1667                                 free(lead, M_SCSICD);
1668                                 cam_periph_unlock(periph);
1669                                 break;
1670                         }
1671                         num = len / sizeof(struct cd_toc_entry);
1672
1673                         if (readlen > 0) {
1674                                 error = cdreadtoc(periph, te->address_format,
1675                                                   starting_track,
1676                                                   (u_int8_t *)data,
1677                                                   readlen + sizeof (*th),
1678                                                   /*sense_flags*/0);
1679                                 if (error) {
1680                                         free(data, M_SCSICD);
1681                                         free(lead, M_SCSICD);
1682                                         cam_periph_unlock(periph);
1683                                         break;
1684                                 }
1685                         }
1686
1687                         /* make leadout entry if needed */
1688                         idx = starting_track + num - 1;
1689                         if (softc->quirks & CD_Q_BCD_TRACKS)
1690                                 th->ending_track = bcd2bin(th->ending_track);
1691                         if (idx == th->ending_track + 1) {
1692                                 error = cdreadtoc(periph, te->address_format,
1693                                                   LEADOUT, (u_int8_t *)lead,
1694                                                   sizeof(*lead),
1695                                                   /*sense_flags*/0);
1696                                 if (error) {
1697                                         free(data, M_SCSICD);
1698                                         free(lead, M_SCSICD);
1699                                         cam_periph_unlock(periph);
1700                                         break;
1701                                 }
1702                                 data->entries[idx - starting_track] =
1703                                         lead->entry;
1704                         }
1705                         if (softc->quirks & CD_Q_BCD_TRACKS) {
1706                                 for (idx = 0; idx < num - 1; idx++) {
1707                                         data->entries[idx].track =
1708                                             bcd2bin(data->entries[idx].track);
1709                                 }
1710                         }
1711
1712                         cam_periph_unlock(periph);
1713                         error = copyout(data->entries, te->data, len);
1714                         free(data, M_SCSICD);
1715                         free(lead, M_SCSICD);
1716                 }
1717                 break;
1718         case CDIOREADTOCENTRY:
1719                 {
1720                         struct cd_toc_single *data;
1721                         struct ioc_read_toc_single_entry *te =
1722                                 (struct ioc_read_toc_single_entry *) addr;
1723                         struct ioc_toc_header *th;
1724                         u_int32_t track;
1725
1726                         data = malloc(sizeof(*data), M_SCSICD, M_WAITOK | M_ZERO);
1727
1728                         cam_periph_lock(periph);
1729                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1730                                   ("trying to do CDIOREADTOCENTRY\n"));
1731
1732                         if (te->address_format != CD_MSF_FORMAT
1733                             && te->address_format != CD_LBA_FORMAT) {
1734                                 printf("error in readtocentry, "
1735                                        " returning EINVAL\n");
1736                                 free(data, M_SCSICD);
1737                                 error = EINVAL;
1738                                 cam_periph_unlock(periph);
1739                                 break;
1740                         }
1741
1742                         th = &data->header;
1743                         error = cdreadtoc(periph, 0, 0, (u_int8_t *)th,
1744                                           sizeof (*th), /*sense_flags*/0);
1745                         if (error) {
1746                                 free(data, M_SCSICD);
1747                                 cam_periph_unlock(periph);
1748                                 break;
1749                         }
1750
1751                         if (softc->quirks & CD_Q_BCD_TRACKS) {
1752                                 /* we are going to have to convert the BCD
1753                                  * encoding on the cd to what is expected
1754                                  */
1755                                 th->starting_track =
1756                                     bcd2bin(th->starting_track);
1757                                 th->ending_track = bcd2bin(th->ending_track);
1758                         }
1759                         track = te->track;
1760                         if (track == 0)
1761                                 track = th->starting_track;
1762                         else if (track == LEADOUT)
1763                                 /* OK */;
1764                         else if (track < th->starting_track ||
1765                                  track > th->ending_track + 1) {
1766                                 printf("error in readtocentry, "
1767                                        " returning EINVAL\n");
1768                                 free(data, M_SCSICD);
1769                                 error = EINVAL;
1770                                 cam_periph_unlock(periph);
1771                                 break;
1772                         }
1773
1774                         error = cdreadtoc(periph, te->address_format, track,
1775                                           (u_int8_t *)data, sizeof(*data),
1776                                           /*sense_flags*/0);
1777                         if (error) {
1778                                 free(data, M_SCSICD);
1779                                 cam_periph_unlock(periph);
1780                                 break;
1781                         }
1782
1783                         if (softc->quirks & CD_Q_BCD_TRACKS)
1784                                 data->entry.track = bcd2bin(data->entry.track);
1785                         bcopy(&data->entry, &te->entry,
1786                               sizeof(struct cd_toc_entry));
1787                         free(data, M_SCSICD);
1788                         cam_periph_unlock(periph);
1789                 }
1790                 break;
1791         case CDIOCSETPATCH:
1792                 {
1793                         struct ioc_patch *arg = (struct ioc_patch *)addr;
1794                         struct cd_mode_params params;
1795                         union cd_pages *page;
1796
1797                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1798                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1799                                                  M_WAITOK | M_ZERO);
1800
1801                         cam_periph_lock(periph);
1802                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1803                                   ("trying to do CDIOCSETPATCH\n"));
1804
1805                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1806                         if (error) {
1807                                 free(params.mode_buf, M_SCSICD);
1808                                 cam_periph_unlock(periph);
1809                                 break;
1810                         }
1811                         page = cdgetpage(&params);
1812
1813                         page->audio.port[LEFT_PORT].channels =
1814                                 arg->patch[0];
1815                         page->audio.port[RIGHT_PORT].channels =
1816                                 arg->patch[1];
1817                         page->audio.port[2].channels = arg->patch[2];
1818                         page->audio.port[3].channels = arg->patch[3];
1819                         error = cdsetmode(periph, &params);
1820                         free(params.mode_buf, M_SCSICD);
1821                         cam_periph_unlock(periph);
1822                 }
1823                 break;
1824         case CDIOCGETVOL:
1825                 {
1826                         struct ioc_vol *arg = (struct ioc_vol *) addr;
1827                         struct cd_mode_params params;
1828                         union cd_pages *page;
1829
1830                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1831                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1832                                                  M_WAITOK | M_ZERO);
1833
1834                         cam_periph_lock(periph);
1835                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1836                                   ("trying to do CDIOCGETVOL\n"));
1837
1838                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1839                         if (error) {
1840                                 free(params.mode_buf, M_SCSICD);
1841                                 cam_periph_unlock(periph);
1842                                 break;
1843                         }
1844                         page = cdgetpage(&params);
1845
1846                         arg->vol[LEFT_PORT] =
1847                                 page->audio.port[LEFT_PORT].volume;
1848                         arg->vol[RIGHT_PORT] =
1849                                 page->audio.port[RIGHT_PORT].volume;
1850                         arg->vol[2] = page->audio.port[2].volume;
1851                         arg->vol[3] = page->audio.port[3].volume;
1852                         free(params.mode_buf, M_SCSICD);
1853                         cam_periph_unlock(periph);
1854                 }
1855                 break;
1856         case CDIOCSETVOL:
1857                 {
1858                         struct ioc_vol *arg = (struct ioc_vol *) addr;
1859                         struct cd_mode_params params;
1860                         union cd_pages *page;
1861
1862                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1863                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1864                                                  M_WAITOK | M_ZERO);
1865
1866                         cam_periph_lock(periph);
1867                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1868                                   ("trying to do CDIOCSETVOL\n"));
1869
1870                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1871                         if (error) {
1872                                 free(params.mode_buf, M_SCSICD);
1873                                 cam_periph_unlock(periph);
1874                                 break;
1875                         }
1876                         page = cdgetpage(&params);
1877
1878                         page->audio.port[LEFT_PORT].channels = CHANNEL_0;
1879                         page->audio.port[LEFT_PORT].volume =
1880                                 arg->vol[LEFT_PORT];
1881                         page->audio.port[RIGHT_PORT].channels = CHANNEL_1;
1882                         page->audio.port[RIGHT_PORT].volume =
1883                                 arg->vol[RIGHT_PORT];
1884                         page->audio.port[2].volume = arg->vol[2];
1885                         page->audio.port[3].volume = arg->vol[3];
1886                         error = cdsetmode(periph, &params);
1887                         cam_periph_unlock(periph);
1888                         free(params.mode_buf, M_SCSICD);
1889                 }
1890                 break;
1891         case CDIOCSETMONO:
1892                 {
1893                         struct cd_mode_params params;
1894                         union cd_pages *page;
1895
1896                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1897                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1898                                                  M_WAITOK | M_ZERO);
1899
1900                         cam_periph_lock(periph);
1901                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1902                                   ("trying to do CDIOCSETMONO\n"));
1903
1904                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1905                         if (error) {
1906                                 free(params.mode_buf, M_SCSICD);
1907                                 cam_periph_unlock(periph);
1908                                 break;
1909                         }
1910                         page = cdgetpage(&params);
1911
1912                         page->audio.port[LEFT_PORT].channels =
1913                                 LEFT_CHANNEL | RIGHT_CHANNEL;
1914                         page->audio.port[RIGHT_PORT].channels =
1915                                 LEFT_CHANNEL | RIGHT_CHANNEL;
1916                         page->audio.port[2].channels = 0;
1917                         page->audio.port[3].channels = 0;
1918                         error = cdsetmode(periph, &params);
1919                         cam_periph_unlock(periph);
1920                         free(params.mode_buf, M_SCSICD);
1921                 }
1922                 break;
1923         case CDIOCSETSTEREO:
1924                 {
1925                         struct cd_mode_params params;
1926                         union cd_pages *page;
1927
1928                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1929                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1930                                                  M_WAITOK | M_ZERO);
1931
1932                         cam_periph_lock(periph);
1933                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1934                                   ("trying to do CDIOCSETSTEREO\n"));
1935
1936                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1937                         if (error) {
1938                                 free(params.mode_buf, M_SCSICD);
1939                                 cam_periph_unlock(periph);
1940                                 break;
1941                         }
1942                         page = cdgetpage(&params);
1943
1944                         page->audio.port[LEFT_PORT].channels =
1945                                 LEFT_CHANNEL;
1946                         page->audio.port[RIGHT_PORT].channels =
1947                                 RIGHT_CHANNEL;
1948                         page->audio.port[2].channels = 0;
1949                         page->audio.port[3].channels = 0;
1950                         error = cdsetmode(periph, &params);
1951                         free(params.mode_buf, M_SCSICD);
1952                         cam_periph_unlock(periph);
1953                 }
1954                 break;
1955         case CDIOCSETMUTE:
1956                 {
1957                         struct cd_mode_params params;
1958                         union cd_pages *page;
1959
1960                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1961                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1962                                                  M_WAITOK | M_ZERO);
1963
1964                         cam_periph_lock(periph);
1965                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1966                                   ("trying to do CDIOCSETMUTE\n"));
1967
1968                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1969                         if (error) {
1970                                 free(params.mode_buf, M_SCSICD);
1971                                 cam_periph_unlock(periph);
1972                                 break;
1973                         }
1974                         page = cdgetpage(&params);
1975
1976                         page->audio.port[LEFT_PORT].channels = 0;
1977                         page->audio.port[RIGHT_PORT].channels = 0;
1978                         page->audio.port[2].channels = 0;
1979                         page->audio.port[3].channels = 0;
1980                         error = cdsetmode(periph, &params);
1981                         free(params.mode_buf, M_SCSICD);
1982                         cam_periph_unlock(periph);
1983                 }
1984                 break;
1985         case CDIOCSETLEFT:
1986                 {
1987                         struct cd_mode_params params;
1988                         union cd_pages *page;
1989
1990                         params.alloc_len = sizeof(union cd_mode_data_6_10);
1991                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
1992                                                  M_WAITOK | M_ZERO);
1993
1994                         cam_periph_lock(periph);
1995                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
1996                                   ("trying to do CDIOCSETLEFT\n"));
1997
1998                         error = cdgetmode(periph, &params, AUDIO_PAGE);
1999                         if (error) {
2000                                 free(params.mode_buf, M_SCSICD);
2001                                 cam_periph_unlock(periph);
2002                                 break;
2003                         }
2004                         page = cdgetpage(&params);
2005
2006                         page->audio.port[LEFT_PORT].channels = LEFT_CHANNEL;
2007                         page->audio.port[RIGHT_PORT].channels = LEFT_CHANNEL;
2008                         page->audio.port[2].channels = 0;
2009                         page->audio.port[3].channels = 0;
2010                         error = cdsetmode(periph, &params);
2011                         free(params.mode_buf, M_SCSICD);
2012                         cam_periph_unlock(periph);
2013                 }
2014                 break;
2015         case CDIOCSETRIGHT:
2016                 {
2017                         struct cd_mode_params params;
2018                         union cd_pages *page;
2019
2020                         params.alloc_len = sizeof(union cd_mode_data_6_10);
2021                         params.mode_buf = malloc(params.alloc_len, M_SCSICD,
2022                                                  M_WAITOK | M_ZERO);
2023
2024                         cam_periph_lock(periph);
2025                         CAM_DEBUG(periph->path, CAM_DEBUG_SUBTRACE,
2026                                   ("trying to do CDIOCSETRIGHT\n"));
2027
2028                         error = cdgetmode(periph, &params, AUDIO_PAGE);
2029                         if (error) {
2030                                 free(params.mode_buf, M_SCSICD);
2031                                 cam_periph_unlock(periph);
2032                                 break;
2033                         }
2034                         page = cdgetpage(&params);
2035
2036                         page->audio.port[LEFT_PORT].channels = RIGHT_CHANNEL;
2037                         page->audio.port[RIGHT_PORT].channels = RIGHT_CHANNEL;
2038                         page->audio.port[2].channels = 0;
2039                         page->audio.port[3].channels = 0;
2040                         error = cdsetmode(periph, &params);
2041                         free(params.mode_buf, M_SCSICD);
2042                         cam_periph_unlock(periph);
2043                 }
2044                 break;
2045         case CDIOCRESUME:
2046                 cam_periph_lock(periph);
2047                 error = cdpause(periph, 1);
2048                 cam_periph_unlock(periph);
2049                 break;
2050         case CDIOCPAUSE:
2051                 cam_periph_lock(periph);
2052                 error = cdpause(periph, 0);
2053                 cam_periph_unlock(periph);
2054                 break;
2055         case CDIOCSTART:
2056                 cam_periph_lock(periph);
2057                 error = cdstartunit(periph, 0);
2058                 cam_periph_unlock(periph);
2059                 break;
2060         case CDIOCCLOSE:
2061                 cam_periph_lock(periph);
2062                 error = cdstartunit(periph, 1);
2063                 cam_periph_unlock(periph);
2064                 break;
2065         case CDIOCSTOP:
2066                 cam_periph_lock(periph);
2067                 error = cdstopunit(periph, 0);
2068                 cam_periph_unlock(periph);
2069                 break;
2070         case CDIOCEJECT:
2071                 cam_periph_lock(periph);
2072                 error = cdstopunit(periph, 1);
2073                 cam_periph_unlock(periph);
2074                 break;
2075         case CDIOCALLOW:
2076                 cam_periph_lock(periph);
2077                 cdprevent(periph, PR_ALLOW);
2078                 cam_periph_unlock(periph);
2079                 break;
2080         case CDIOCPREVENT:
2081                 cam_periph_lock(periph);
2082                 cdprevent(periph, PR_PREVENT);
2083                 cam_periph_unlock(periph);
2084                 break;
2085         case CDIOCSETDEBUG:
2086                 /* sc_link->flags |= (SDEV_DB1 | SDEV_DB2); */
2087                 error = ENOTTY;
2088                 break;
2089         case CDIOCCLRDEBUG:
2090                 /* sc_link->flags &= ~(SDEV_DB1 | SDEV_DB2); */
2091                 error = ENOTTY;
2092                 break;
2093         case CDIOCRESET:
2094                 /* return (cd_reset(periph)); */
2095                 error = ENOTTY;
2096                 break;
2097         case CDRIOCREADSPEED:
2098                 cam_periph_lock(periph);
2099                 error = cdsetspeed(periph, *(u_int32_t *)addr, CDR_MAX_SPEED);
2100                 cam_periph_unlock(periph);
2101                 break;
2102         case CDRIOCWRITESPEED:
2103                 cam_periph_lock(periph);
2104                 error = cdsetspeed(periph, CDR_MAX_SPEED, *(u_int32_t *)addr);
2105                 cam_periph_unlock(periph);
2106                 break;
2107         case CDRIOCGETBLOCKSIZE:
2108                 *(int *)addr = softc->params.blksize;
2109                 break;
2110         case CDRIOCSETBLOCKSIZE:
2111                 if (*(int *)addr <= 0) {
2112                         error = EINVAL;
2113                         break;
2114                 }
2115                 softc->disk->d_sectorsize = softc->params.blksize = *(int *)addr;
2116                 break;
2117         case DVDIOCSENDKEY:
2118         case DVDIOCREPORTKEY: {
2119                 struct dvd_authinfo *authinfo;
2120
2121                 authinfo = (struct dvd_authinfo *)addr;
2122
2123                 if (cmd == DVDIOCREPORTKEY)
2124                         error = cdreportkey(periph, authinfo);
2125                 else
2126                         error = cdsendkey(periph, authinfo);
2127                 break;
2128                 }
2129         case DVDIOCREADSTRUCTURE: {
2130                 struct dvd_struct *dvdstruct;
2131
2132                 dvdstruct = (struct dvd_struct *)addr;
2133
2134                 error = cdreaddvdstructure(periph, dvdstruct);
2135
2136                 break;
2137         }
2138         default:
2139                 cam_periph_lock(periph);
2140                 error = cam_periph_ioctl(periph, cmd, addr, cderror);
2141                 cam_periph_unlock(periph);
2142                 break;
2143         }
2144
2145         cam_periph_lock(periph);
2146         cam_periph_unhold(periph);
2147
2148         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("leaving cdioctl\n"));
2149         if (error && bootverbose) {
2150                 printf("scsi_cd.c::ioctl cmd=%08lx error=%d\n", cmd, error);
2151         }
2152         cam_periph_unlock(periph);
2153
2154         return (error);
2155 }
2156
2157 static void
2158 cdprevent(struct cam_periph *periph, int action)
2159 {
2160         union   ccb *ccb;
2161         struct  cd_softc *softc;
2162         int     error;
2163
2164         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering cdprevent\n"));
2165
2166         softc = (struct cd_softc *)periph->softc;
2167
2168         if (((action == PR_ALLOW)
2169           && (softc->flags & CD_FLAG_DISC_LOCKED) == 0)
2170          || ((action == PR_PREVENT)
2171           && (softc->flags & CD_FLAG_DISC_LOCKED) != 0)) {
2172                 return;
2173         }
2174
2175         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2176
2177         scsi_prevent(&ccb->csio,
2178                      /*retries*/ cd_retry_count,
2179                      cddone,
2180                      MSG_SIMPLE_Q_TAG,
2181                      action,
2182                      SSD_FULL_SIZE,
2183                      /* timeout */60000);
2184
2185         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2186                         /*sense_flags*/SF_RETRY_UA|SF_NO_PRINT);
2187
2188         xpt_release_ccb(ccb);
2189
2190         if (error == 0) {
2191                 if (action == PR_ALLOW)
2192                         softc->flags &= ~CD_FLAG_DISC_LOCKED;
2193                 else
2194                         softc->flags |= CD_FLAG_DISC_LOCKED;
2195         }
2196 }
2197
2198 /*
2199  * XXX: the disk media and sector size is only really able to change
2200  * XXX: while the device is closed.
2201  */
2202 static int
2203 cdcheckmedia(struct cam_periph *periph)
2204 {
2205         struct cd_softc *softc;
2206         struct ioc_toc_header *toch;
2207         struct cd_toc_single leadout;
2208         u_int32_t size, toclen;
2209         int error, num_entries, cdindex;
2210
2211         softc = (struct cd_softc *)periph->softc;
2212
2213         cdprevent(periph, PR_PREVENT);
2214         softc->disk->d_sectorsize = 2048;
2215         softc->disk->d_mediasize = 0;
2216
2217         /*
2218          * Get the disc size and block size.  If we can't get it, we don't
2219          * have media, most likely.
2220          */
2221         if ((error = cdsize(periph, &size)) != 0) {
2222                 softc->flags &= ~(CD_FLAG_VALID_MEDIA|CD_FLAG_VALID_TOC);
2223                 cdprevent(periph, PR_ALLOW);
2224                 return (error);
2225         } else {
2226                 softc->flags |= CD_FLAG_SAW_MEDIA | CD_FLAG_VALID_MEDIA;
2227                 softc->disk->d_sectorsize = softc->params.blksize;
2228                 softc->disk->d_mediasize =
2229                     (off_t)softc->params.blksize * softc->params.disksize;
2230         }
2231
2232         /*
2233          * Now we check the table of contents.  This (currently) is only
2234          * used for the CDIOCPLAYTRACKS ioctl.  It may be used later to do
2235          * things like present a separate entry in /dev for each track,
2236          * like that acd(4) driver does.
2237          */
2238         bzero(&softc->toc, sizeof(softc->toc));
2239         toch = &softc->toc.header;
2240         /*
2241          * We will get errors here for media that doesn't have a table of
2242          * contents.  According to the MMC-3 spec: "When a Read TOC/PMA/ATIP
2243          * command is presented for a DDCD/CD-R/RW media, where the first TOC
2244          * has not been recorded (no complete session) and the Format codes
2245          * 0000b, 0001b, or 0010b are specified, this command shall be rejected
2246          * with an INVALID FIELD IN CDB.  Devices that are not capable of
2247          * reading an incomplete session on DDC/CD-R/RW media shall report
2248          * CANNOT READ MEDIUM - INCOMPATIBLE FORMAT."
2249          *
2250          * So this isn't fatal if we can't read the table of contents, it
2251          * just means that the user won't be able to issue the play tracks
2252          * ioctl, and likely lots of other stuff won't work either.  They
2253          * need to burn the CD before we can do a whole lot with it.  So
2254          * we don't print anything here if we get an error back.
2255          */
2256         error = cdreadtoc(periph, 0, 0, (u_int8_t *)toch, sizeof(*toch),
2257                           SF_NO_PRINT);
2258         /*
2259          * Errors in reading the table of contents aren't fatal, we just
2260          * won't have a valid table of contents cached.
2261          */
2262         if (error != 0) {
2263                 error = 0;
2264                 bzero(&softc->toc, sizeof(softc->toc));
2265                 goto bailout;
2266         }
2267
2268         if (softc->quirks & CD_Q_BCD_TRACKS) {
2269                 toch->starting_track = bcd2bin(toch->starting_track);
2270                 toch->ending_track = bcd2bin(toch->ending_track);
2271         }
2272
2273         /* Number of TOC entries, plus leadout */
2274         num_entries = (toch->ending_track - toch->starting_track) + 2;
2275
2276         if (num_entries <= 0)
2277                 goto bailout;
2278
2279         toclen = num_entries * sizeof(struct cd_toc_entry);
2280
2281         error = cdreadtoc(periph, CD_MSF_FORMAT, toch->starting_track,
2282                           (u_int8_t *)&softc->toc, toclen + sizeof(*toch),
2283                           SF_NO_PRINT);
2284         if (error != 0) {
2285                 error = 0;
2286                 bzero(&softc->toc, sizeof(softc->toc));
2287                 goto bailout;
2288         }
2289
2290         if (softc->quirks & CD_Q_BCD_TRACKS) {
2291                 toch->starting_track = bcd2bin(toch->starting_track);
2292                 toch->ending_track = bcd2bin(toch->ending_track);
2293         }
2294         /*
2295          * XXX KDM is this necessary?  Probably only if the drive doesn't
2296          * return leadout information with the table of contents.
2297          */
2298         cdindex = toch->starting_track + num_entries -1;
2299         if (cdindex == toch->ending_track + 1) {
2300
2301                 error = cdreadtoc(periph, CD_MSF_FORMAT, LEADOUT,
2302                                   (u_int8_t *)&leadout, sizeof(leadout),
2303                                   SF_NO_PRINT);
2304                 if (error != 0) {
2305                         error = 0;
2306                         goto bailout;
2307                 }
2308                 softc->toc.entries[cdindex - toch->starting_track] =
2309                         leadout.entry;
2310         }
2311         if (softc->quirks & CD_Q_BCD_TRACKS) {
2312                 for (cdindex = 0; cdindex < num_entries - 1; cdindex++) {
2313                         softc->toc.entries[cdindex].track =
2314                                 bcd2bin(softc->toc.entries[cdindex].track);
2315                 }
2316         }
2317
2318         softc->flags |= CD_FLAG_VALID_TOC;
2319
2320         /* If the first track is audio, correct sector size. */
2321         if ((softc->toc.entries[0].control & 4) == 0) {
2322                 softc->disk->d_sectorsize = softc->params.blksize = 2352;
2323                 softc->disk->d_mediasize =
2324                     (off_t)softc->params.blksize * softc->params.disksize;
2325         }
2326
2327 bailout:
2328
2329         /*
2330          * We unconditionally (re)set the blocksize each time the
2331          * CD device is opened.  This is because the CD can change,
2332          * and therefore the blocksize might change.
2333          * XXX problems here if some slice or partition is still
2334          * open with the old size?
2335          */
2336         if ((softc->disk->d_devstat->flags & DEVSTAT_BS_UNAVAILABLE) != 0)
2337                 softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
2338         softc->disk->d_devstat->block_size = softc->params.blksize;
2339
2340         return (error);
2341 }
2342
2343 static int
2344 cdsize(struct cam_periph *periph, u_int32_t *size)
2345 {
2346         struct cd_softc *softc;
2347         union ccb *ccb;
2348         struct scsi_read_capacity_data *rcap_buf;
2349         int error;
2350
2351         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering cdsize\n"));
2352
2353         softc = (struct cd_softc *)periph->softc;
2354
2355         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2356
2357         /* XXX Should be M_WAITOK */
2358         rcap_buf = malloc(sizeof(struct scsi_read_capacity_data),
2359                           M_SCSICD, M_NOWAIT | M_ZERO);
2360         if (rcap_buf == NULL)
2361                 return (ENOMEM);
2362
2363         scsi_read_capacity(&ccb->csio,
2364                            /*retries*/ cd_retry_count,
2365                            cddone,
2366                            MSG_SIMPLE_Q_TAG,
2367                            rcap_buf,
2368                            SSD_FULL_SIZE,
2369                            /* timeout */20000);
2370
2371         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2372                          /*sense_flags*/SF_RETRY_UA|SF_NO_PRINT);
2373
2374         xpt_release_ccb(ccb);
2375
2376         softc->params.disksize = scsi_4btoul(rcap_buf->addr) + 1;
2377         softc->params.blksize  = scsi_4btoul(rcap_buf->length);
2378         /* Make sure we got at least some block size. */
2379         if (error == 0 && softc->params.blksize == 0)
2380                 error = EIO;
2381         /*
2382          * SCSI-3 mandates that the reported blocksize shall be 2048.
2383          * Older drives sometimes report funny values, trim it down to
2384          * 2048, or other parts of the kernel will get confused.
2385          *
2386          * XXX we leave drives alone that might report 512 bytes, as
2387          * well as drives reporting more weird sizes like perhaps 4K.
2388          */
2389         if (softc->params.blksize > 2048 && softc->params.blksize <= 2352)
2390                 softc->params.blksize = 2048;
2391
2392         free(rcap_buf, M_SCSICD);
2393         *size = softc->params.disksize;
2394
2395         return (error);
2396
2397 }
2398
2399 static int
2400 cd6byteworkaround(union ccb *ccb)
2401 {
2402         u_int8_t *cdb;
2403         struct cam_periph *periph;
2404         struct cd_softc *softc;
2405         struct cd_mode_params *params;
2406         int frozen, found;
2407
2408         periph = xpt_path_periph(ccb->ccb_h.path);
2409         softc = (struct cd_softc *)periph->softc;
2410
2411         cdb = ccb->csio.cdb_io.cdb_bytes;
2412
2413         if ((ccb->ccb_h.flags & CAM_CDB_POINTER)
2414          || ((cdb[0] != MODE_SENSE_6)
2415           && (cdb[0] != MODE_SELECT_6)))
2416                 return (0);
2417
2418         /*
2419          * Because there is no convenient place to stash the overall
2420          * cd_mode_params structure pointer, we have to grab it like this.
2421          * This means that ALL MODE_SENSE and MODE_SELECT requests in the
2422          * cd(4) driver MUST go through cdgetmode() and cdsetmode()!
2423          *
2424          * XXX It would be nice if, at some point, we could increase the
2425          * number of available peripheral private pointers.  Both pointers
2426          * are currently used in most every peripheral driver.
2427          */
2428         found = 0;
2429
2430         STAILQ_FOREACH(params, &softc->mode_queue, links) {
2431                 if (params->mode_buf == ccb->csio.data_ptr) {
2432                         found = 1;
2433                         break;
2434                 }
2435         }
2436
2437         /*
2438          * This shouldn't happen.  All mode sense and mode select
2439          * operations in the cd(4) driver MUST go through cdgetmode() and
2440          * cdsetmode()!
2441          */
2442         if (found == 0) {
2443                 xpt_print(periph->path,
2444                     "mode buffer not found in mode queue!\n");
2445                 return (0);
2446         }
2447
2448         params->cdb_size = 10;
2449         softc->minimum_command_size = 10;
2450         xpt_print(ccb->ccb_h.path,
2451             "%s(6) failed, increasing minimum CDB size to 10 bytes\n",
2452             (cdb[0] == MODE_SENSE_6) ? "MODE_SENSE" : "MODE_SELECT");
2453
2454         if (cdb[0] == MODE_SENSE_6) {
2455                 struct scsi_mode_sense_10 ms10;
2456                 struct scsi_mode_sense_6 *ms6;
2457                 int len;
2458
2459                 ms6 = (struct scsi_mode_sense_6 *)cdb;
2460
2461                 bzero(&ms10, sizeof(ms10));
2462                 ms10.opcode = MODE_SENSE_10;
2463                 ms10.byte2 = ms6->byte2;
2464                 ms10.page = ms6->page;
2465
2466                 /*
2467                  * 10 byte mode header, block descriptor,
2468                  * sizeof(union cd_pages)
2469                  */
2470                 len = sizeof(struct cd_mode_data_10);
2471                 ccb->csio.dxfer_len = len;
2472
2473                 scsi_ulto2b(len, ms10.length);
2474                 ms10.control = ms6->control;
2475                 bcopy(&ms10, cdb, 10);
2476                 ccb->csio.cdb_len = 10;
2477         } else {
2478                 struct scsi_mode_select_10 ms10;
2479                 struct scsi_mode_select_6 *ms6;
2480                 struct scsi_mode_header_6 *header6;
2481                 struct scsi_mode_header_10 *header10;
2482                 struct scsi_mode_page_header *page_header;
2483                 int blk_desc_len, page_num, page_size, len;
2484
2485                 ms6 = (struct scsi_mode_select_6 *)cdb;
2486
2487                 bzero(&ms10, sizeof(ms10));
2488                 ms10.opcode = MODE_SELECT_10;
2489                 ms10.byte2 = ms6->byte2;
2490
2491                 header6 = (struct scsi_mode_header_6 *)params->mode_buf;
2492                 header10 = (struct scsi_mode_header_10 *)params->mode_buf;
2493
2494                 page_header = find_mode_page_6(header6);
2495                 page_num = page_header->page_code;
2496
2497                 blk_desc_len = header6->blk_desc_len;
2498
2499                 page_size = cdgetpagesize(page_num);
2500
2501                 if (page_size != (page_header->page_length +
2502                     sizeof(*page_header)))
2503                         page_size = page_header->page_length +
2504                                 sizeof(*page_header);
2505
2506                 len = sizeof(*header10) + blk_desc_len + page_size;
2507
2508                 len = min(params->alloc_len, len);
2509
2510                 /*
2511                  * Since the 6 byte parameter header is shorter than the 10
2512                  * byte parameter header, we need to copy the actual mode
2513                  * page data, and the block descriptor, if any, so things wind
2514                  * up in the right place.  The regions will overlap, but
2515                  * bcopy() does the right thing.
2516                  */
2517                 bcopy(params->mode_buf + sizeof(*header6),
2518                       params->mode_buf + sizeof(*header10),
2519                       len - sizeof(*header10));
2520
2521                 /* Make sure these fields are set correctly. */
2522                 scsi_ulto2b(0, header10->data_length);
2523                 header10->medium_type = 0;
2524                 scsi_ulto2b(blk_desc_len, header10->blk_desc_len);
2525
2526                 ccb->csio.dxfer_len = len;
2527
2528                 scsi_ulto2b(len, ms10.length);
2529                 ms10.control = ms6->control;
2530                 bcopy(&ms10, cdb, 10);
2531                 ccb->csio.cdb_len = 10;
2532         }
2533
2534         frozen = (ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
2535         ccb->ccb_h.status = CAM_REQUEUE_REQ;
2536         xpt_action(ccb);
2537         if (frozen) {
2538                 cam_release_devq(ccb->ccb_h.path,
2539                                  /*relsim_flags*/0,
2540                                  /*openings*/0,
2541                                  /*timeout*/0,
2542                                  /*getcount_only*/0);
2543         }
2544
2545         return (ERESTART);
2546 }
2547
2548 static int
2549 cderror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
2550 {
2551         struct cd_softc *softc;
2552         struct cam_periph *periph;
2553         int error, error_code, sense_key, asc, ascq;
2554
2555         periph = xpt_path_periph(ccb->ccb_h.path);
2556         softc = (struct cd_softc *)periph->softc;
2557
2558         error = 0;
2559
2560         /*
2561          * We use a status of CAM_REQ_INVALID as shorthand -- if a 6 byte
2562          * CDB comes back with this particular error, try transforming it
2563          * into the 10 byte version.
2564          */
2565         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INVALID) {
2566                 error = cd6byteworkaround(ccb);
2567         } else if (scsi_extract_sense_ccb(ccb,
2568             &error_code, &sense_key, &asc, &ascq)) {
2569                 if (sense_key == SSD_KEY_ILLEGAL_REQUEST)
2570                         error = cd6byteworkaround(ccb);
2571                 else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
2572                     asc == 0x28 && ascq == 0x00)
2573                         disk_media_changed(softc->disk, M_NOWAIT);
2574                 else if (sense_key == SSD_KEY_NOT_READY &&
2575                     asc == 0x3a && (softc->flags & CD_FLAG_SAW_MEDIA)) {
2576                         softc->flags &= ~CD_FLAG_SAW_MEDIA;
2577                         disk_media_gone(softc->disk, M_NOWAIT);
2578                 }
2579         }
2580
2581         if (error == ERESTART)
2582                 return (error);
2583
2584         /*
2585          * XXX
2586          * Until we have a better way of doing pack validation,
2587          * don't treat UAs as errors.
2588          */
2589         sense_flags |= SF_RETRY_UA;
2590
2591         if (softc->quirks & CD_Q_RETRY_BUSY)
2592                 sense_flags |= SF_RETRY_BUSY;
2593         return (cam_periph_error(ccb, cam_flags, sense_flags));
2594 }
2595
2596 static void
2597 cdmediapoll(void *arg)
2598 {
2599         struct cam_periph *periph = arg;
2600         struct cd_softc *softc = periph->softc;
2601
2602         if (softc->state == CD_STATE_NORMAL && !softc->tur &&
2603             softc->outstanding_cmds == 0) {
2604                 if (cam_periph_acquire(periph) == 0) {
2605                         softc->tur = 1;
2606                         xpt_schedule(periph, CAM_PRIORITY_NORMAL);
2607                 }
2608         }
2609         /* Queue us up again */
2610         if (cd_poll_period != 0)
2611                 callout_schedule(&softc->mediapoll_c, cd_poll_period * hz);
2612 }
2613
2614 /*
2615  * Read table of contents
2616  */
2617 static int
2618 cdreadtoc(struct cam_periph *periph, u_int32_t mode, u_int32_t start,
2619           u_int8_t *data, u_int32_t len, u_int32_t sense_flags)
2620 {
2621         struct scsi_read_toc *scsi_cmd;
2622         u_int32_t ntoc;
2623         struct ccb_scsiio *csio;
2624         union ccb *ccb;
2625         int error;
2626
2627         ntoc = len;
2628         error = 0;
2629
2630         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2631
2632         csio = &ccb->csio;
2633
2634         cam_fill_csio(csio,
2635                       /* retries */ cd_retry_count,
2636                       /* cbfcnp */ cddone,
2637                       /* flags */ CAM_DIR_IN,
2638                       /* tag_action */ MSG_SIMPLE_Q_TAG,
2639                       /* data_ptr */ data,
2640                       /* dxfer_len */ len,
2641                       /* sense_len */ SSD_FULL_SIZE,
2642                       sizeof(struct scsi_read_toc),
2643                       /* timeout */ 50000);
2644
2645         scsi_cmd = (struct scsi_read_toc *)&csio->cdb_io.cdb_bytes;
2646         bzero (scsi_cmd, sizeof(*scsi_cmd));
2647
2648         if (mode == CD_MSF_FORMAT)
2649                 scsi_cmd->byte2 |= CD_MSF;
2650         scsi_cmd->from_track = start;
2651         /* scsi_ulto2b(ntoc, (u_int8_t *)scsi_cmd->data_len); */
2652         scsi_cmd->data_len[0] = (ntoc) >> 8;
2653         scsi_cmd->data_len[1] = (ntoc) & 0xff;
2654
2655         scsi_cmd->op_code = READ_TOC;
2656
2657         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2658                          /*sense_flags*/SF_RETRY_UA | sense_flags);
2659
2660         xpt_release_ccb(ccb);
2661
2662         return(error);
2663 }
2664
2665 static int
2666 cdreadsubchannel(struct cam_periph *periph, u_int32_t mode,
2667                  u_int32_t format, int track,
2668                  struct cd_sub_channel_info *data, u_int32_t len)
2669 {
2670         struct scsi_read_subchannel *scsi_cmd;
2671         struct ccb_scsiio *csio;
2672         union ccb *ccb;
2673         int error;
2674
2675         error = 0;
2676
2677         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2678
2679         csio = &ccb->csio;
2680
2681         cam_fill_csio(csio,
2682                       /* retries */ cd_retry_count,
2683                       /* cbfcnp */ cddone,
2684                       /* flags */ CAM_DIR_IN,
2685                       /* tag_action */ MSG_SIMPLE_Q_TAG,
2686                       /* data_ptr */ (u_int8_t *)data,
2687                       /* dxfer_len */ len,
2688                       /* sense_len */ SSD_FULL_SIZE,
2689                       sizeof(struct scsi_read_subchannel),
2690                       /* timeout */ 50000);
2691
2692         scsi_cmd = (struct scsi_read_subchannel *)&csio->cdb_io.cdb_bytes;
2693         bzero (scsi_cmd, sizeof(*scsi_cmd));
2694
2695         scsi_cmd->op_code = READ_SUBCHANNEL;
2696         if (mode == CD_MSF_FORMAT)
2697                 scsi_cmd->byte1 |= CD_MSF;
2698         scsi_cmd->byte2 = SRS_SUBQ;
2699         scsi_cmd->subchan_format = format;
2700         scsi_cmd->track = track;
2701         scsi_ulto2b(len, (u_int8_t *)scsi_cmd->data_len);
2702         scsi_cmd->control = 0;
2703
2704         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2705                          /*sense_flags*/SF_RETRY_UA);
2706
2707         xpt_release_ccb(ccb);
2708
2709         return(error);
2710 }
2711
2712
2713 /*
2714  * All MODE_SENSE requests in the cd(4) driver MUST go through this
2715  * routine.  See comments in cd6byteworkaround() for details.
2716  */
2717 static int
2718 cdgetmode(struct cam_periph *periph, struct cd_mode_params *data,
2719           u_int32_t page)
2720 {
2721         struct ccb_scsiio *csio;
2722         struct cd_softc *softc;
2723         union ccb *ccb;
2724         int param_len;
2725         int error;
2726
2727         softc = (struct cd_softc *)periph->softc;
2728
2729         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2730
2731         csio = &ccb->csio;
2732
2733         data->cdb_size = softc->minimum_command_size;
2734         if (data->cdb_size < 10)
2735                 param_len = sizeof(struct cd_mode_data);
2736         else
2737                 param_len = sizeof(struct cd_mode_data_10);
2738
2739         /* Don't say we've got more room than we actually allocated */
2740         param_len = min(param_len, data->alloc_len);
2741
2742         scsi_mode_sense_len(csio,
2743                             /* retries */ cd_retry_count,
2744                             /* cbfcnp */ cddone,
2745                             /* tag_action */ MSG_SIMPLE_Q_TAG,
2746                             /* dbd */ 0,
2747                             /* page_code */ SMS_PAGE_CTRL_CURRENT,
2748                             /* page */ page,
2749                             /* param_buf */ data->mode_buf,
2750                             /* param_len */ param_len,
2751                             /* minimum_cmd_size */ softc->minimum_command_size,
2752                             /* sense_len */ SSD_FULL_SIZE,
2753                             /* timeout */ 50000);
2754
2755         /*
2756          * It would be nice not to have to do this, but there's no
2757          * available pointer in the CCB that would allow us to stuff the
2758          * mode params structure in there and retrieve it in
2759          * cd6byteworkaround(), so we can set the cdb size.  The cdb size
2760          * lets the caller know what CDB size we ended up using, so they
2761          * can find the actual mode page offset.
2762          */
2763         STAILQ_INSERT_TAIL(&softc->mode_queue, data, links);
2764
2765         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2766                          /*sense_flags*/SF_RETRY_UA);
2767
2768         xpt_release_ccb(ccb);
2769
2770         STAILQ_REMOVE(&softc->mode_queue, data, cd_mode_params, links);
2771
2772         /*
2773          * This is a bit of belt-and-suspenders checking, but if we run
2774          * into a situation where the target sends back multiple block
2775          * descriptors, we might not have enough space in the buffer to
2776          * see the whole mode page.  Better to return an error than
2777          * potentially access memory beyond our malloced region.
2778          */
2779         if (error == 0) {
2780                 u_int32_t data_len;
2781
2782                 if (data->cdb_size == 10) {
2783                         struct scsi_mode_header_10 *hdr10;
2784
2785                         hdr10 = (struct scsi_mode_header_10 *)data->mode_buf;
2786                         data_len = scsi_2btoul(hdr10->data_length);
2787                         data_len += sizeof(hdr10->data_length);
2788                 } else {
2789                         struct scsi_mode_header_6 *hdr6;
2790
2791                         hdr6 = (struct scsi_mode_header_6 *)data->mode_buf;
2792                         data_len = hdr6->data_length;
2793                         data_len += sizeof(hdr6->data_length);
2794                 }
2795
2796                 /*
2797                  * Complain if there is more mode data available than we
2798                  * allocated space for.  This could potentially happen if
2799                  * we miscalculated the page length for some reason, if the
2800                  * drive returns multiple block descriptors, or if it sets
2801                  * the data length incorrectly.
2802                  */
2803                 if (data_len > data->alloc_len) {
2804                         xpt_print(periph->path, "allocated modepage %d length "
2805                             "%d < returned length %d\n", page, data->alloc_len,
2806                             data_len);
2807                         error = ENOSPC;
2808                 }
2809         }
2810         return (error);
2811 }
2812
2813 /*
2814  * All MODE_SELECT requests in the cd(4) driver MUST go through this
2815  * routine.  See comments in cd6byteworkaround() for details.
2816  */
2817 static int
2818 cdsetmode(struct cam_periph *periph, struct cd_mode_params *data)
2819 {
2820         struct ccb_scsiio *csio;
2821         struct cd_softc *softc;
2822         union ccb *ccb;
2823         int cdb_size, param_len;
2824         int error;
2825
2826         softc = (struct cd_softc *)periph->softc;
2827
2828         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2829
2830         csio = &ccb->csio;
2831
2832         error = 0;
2833
2834         /*
2835          * If the data is formatted for the 10 byte version of the mode
2836          * select parameter list, we need to use the 10 byte CDB.
2837          * Otherwise, we use whatever the stored minimum command size.
2838          */
2839         if (data->cdb_size == 10)
2840                 cdb_size = data->cdb_size;
2841         else
2842                 cdb_size = softc->minimum_command_size;
2843
2844         if (cdb_size >= 10) {
2845                 struct scsi_mode_header_10 *mode_header;
2846                 u_int32_t data_len;
2847
2848                 mode_header = (struct scsi_mode_header_10 *)data->mode_buf;
2849
2850                 data_len = scsi_2btoul(mode_header->data_length);
2851
2852                 scsi_ulto2b(0, mode_header->data_length);
2853                 /*
2854                  * SONY drives do not allow a mode select with a medium_type
2855                  * value that has just been returned by a mode sense; use a
2856                  * medium_type of 0 (Default) instead.
2857                  */
2858                 mode_header->medium_type = 0;
2859
2860                 /*
2861                  * Pass back whatever the drive passed to us, plus the size
2862                  * of the data length field.
2863                  */
2864                 param_len = data_len + sizeof(mode_header->data_length);
2865
2866         } else {
2867                 struct scsi_mode_header_6 *mode_header;
2868
2869                 mode_header = (struct scsi_mode_header_6 *)data->mode_buf;
2870
2871                 param_len = mode_header->data_length + 1;
2872
2873                 mode_header->data_length = 0;
2874                 /*
2875                  * SONY drives do not allow a mode select with a medium_type
2876                  * value that has just been returned by a mode sense; use a
2877                  * medium_type of 0 (Default) instead.
2878                  */
2879                 mode_header->medium_type = 0;
2880         }
2881
2882         /* Don't say we've got more room than we actually allocated */
2883         param_len = min(param_len, data->alloc_len);
2884
2885         scsi_mode_select_len(csio,
2886                              /* retries */ cd_retry_count,
2887                              /* cbfcnp */ cddone,
2888                              /* tag_action */ MSG_SIMPLE_Q_TAG,
2889                              /* scsi_page_fmt */ 1,
2890                              /* save_pages */ 0,
2891                              /* param_buf */ data->mode_buf,
2892                              /* param_len */ param_len,
2893                              /* minimum_cmd_size */ cdb_size,
2894                              /* sense_len */ SSD_FULL_SIZE,
2895                              /* timeout */ 50000);
2896
2897         /* See comments in cdgetmode() and cd6byteworkaround(). */
2898         STAILQ_INSERT_TAIL(&softc->mode_queue, data, links);
2899
2900         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2901                          /*sense_flags*/SF_RETRY_UA);
2902
2903         xpt_release_ccb(ccb);
2904
2905         STAILQ_REMOVE(&softc->mode_queue, data, cd_mode_params, links);
2906
2907         return (error);
2908 }
2909
2910
2911 static int
2912 cdplay(struct cam_periph *periph, u_int32_t blk, u_int32_t len)
2913 {
2914         struct ccb_scsiio *csio;
2915         union ccb *ccb;
2916         int error;
2917         u_int8_t cdb_len;
2918
2919         error = 0;
2920         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2921         csio = &ccb->csio;
2922         /*
2923          * Use the smallest possible command to perform the operation.
2924          */
2925         if ((len & 0xffff0000) == 0) {
2926                 /*
2927                  * We can fit in a 10 byte cdb.
2928                  */
2929                 struct scsi_play_10 *scsi_cmd;
2930
2931                 scsi_cmd = (struct scsi_play_10 *)&csio->cdb_io.cdb_bytes;
2932                 bzero (scsi_cmd, sizeof(*scsi_cmd));
2933                 scsi_cmd->op_code = PLAY_10;
2934                 scsi_ulto4b(blk, (u_int8_t *)scsi_cmd->blk_addr);
2935                 scsi_ulto2b(len, (u_int8_t *)scsi_cmd->xfer_len);
2936                 cdb_len = sizeof(*scsi_cmd);
2937         } else  {
2938                 struct scsi_play_12 *scsi_cmd;
2939
2940                 scsi_cmd = (struct scsi_play_12 *)&csio->cdb_io.cdb_bytes;
2941                 bzero (scsi_cmd, sizeof(*scsi_cmd));
2942                 scsi_cmd->op_code = PLAY_12;
2943                 scsi_ulto4b(blk, (u_int8_t *)scsi_cmd->blk_addr);
2944                 scsi_ulto4b(len, (u_int8_t *)scsi_cmd->xfer_len);
2945                 cdb_len = sizeof(*scsi_cmd);
2946         }
2947         cam_fill_csio(csio,
2948                       /*retries*/ cd_retry_count,
2949                       cddone,
2950                       /*flags*/CAM_DIR_NONE,
2951                       MSG_SIMPLE_Q_TAG,
2952                       /*dataptr*/NULL,
2953                       /*datalen*/0,
2954                       /*sense_len*/SSD_FULL_SIZE,
2955                       cdb_len,
2956                       /*timeout*/50 * 1000);
2957
2958         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
2959                          /*sense_flags*/SF_RETRY_UA);
2960
2961         xpt_release_ccb(ccb);
2962
2963         return(error);
2964 }
2965
2966 static int
2967 cdplaymsf(struct cam_periph *periph, u_int32_t startm, u_int32_t starts,
2968           u_int32_t startf, u_int32_t endm, u_int32_t ends, u_int32_t endf)
2969 {
2970         struct scsi_play_msf *scsi_cmd;
2971         struct ccb_scsiio *csio;
2972         union ccb *ccb;
2973         int error;
2974
2975         error = 0;
2976
2977         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2978
2979         csio = &ccb->csio;
2980
2981         cam_fill_csio(csio,
2982                       /* retries */ cd_retry_count,
2983                       /* cbfcnp */ cddone,
2984                       /* flags */ CAM_DIR_NONE,
2985                       /* tag_action */ MSG_SIMPLE_Q_TAG,
2986                       /* data_ptr */ NULL,
2987                       /* dxfer_len */ 0,
2988                       /* sense_len */ SSD_FULL_SIZE,
2989                       sizeof(struct scsi_play_msf),
2990                       /* timeout */ 50000);
2991
2992         scsi_cmd = (struct scsi_play_msf *)&csio->cdb_io.cdb_bytes;
2993         bzero (scsi_cmd, sizeof(*scsi_cmd));
2994
2995         scsi_cmd->op_code = PLAY_MSF;
2996         scsi_cmd->start_m = startm;
2997         scsi_cmd->start_s = starts;
2998         scsi_cmd->start_f = startf;
2999         scsi_cmd->end_m = endm;
3000         scsi_cmd->end_s = ends;
3001         scsi_cmd->end_f = endf;
3002
3003         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3004                          /*sense_flags*/SF_RETRY_UA);
3005
3006         xpt_release_ccb(ccb);
3007
3008         return(error);
3009 }
3010
3011
3012 static int
3013 cdplaytracks(struct cam_periph *periph, u_int32_t strack, u_int32_t sindex,
3014              u_int32_t etrack, u_int32_t eindex)
3015 {
3016         struct scsi_play_track *scsi_cmd;
3017         struct ccb_scsiio *csio;
3018         union ccb *ccb;
3019         int error;
3020
3021         error = 0;
3022
3023         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3024
3025         csio = &ccb->csio;
3026
3027         cam_fill_csio(csio,
3028                       /* retries */ cd_retry_count,
3029                       /* cbfcnp */ cddone,
3030                       /* flags */ CAM_DIR_NONE,
3031                       /* tag_action */ MSG_SIMPLE_Q_TAG,
3032                       /* data_ptr */ NULL,
3033                       /* dxfer_len */ 0,
3034                       /* sense_len */ SSD_FULL_SIZE,
3035                       sizeof(struct scsi_play_track),
3036                       /* timeout */ 50000);
3037
3038         scsi_cmd = (struct scsi_play_track *)&csio->cdb_io.cdb_bytes;
3039         bzero (scsi_cmd, sizeof(*scsi_cmd));
3040
3041         scsi_cmd->op_code = PLAY_TRACK;
3042         scsi_cmd->start_track = strack;
3043         scsi_cmd->start_index = sindex;
3044         scsi_cmd->end_track = etrack;
3045         scsi_cmd->end_index = eindex;
3046
3047         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3048                          /*sense_flags*/SF_RETRY_UA);
3049
3050         xpt_release_ccb(ccb);
3051
3052         return(error);
3053 }
3054
3055 static int
3056 cdpause(struct cam_periph *periph, u_int32_t go)
3057 {
3058         struct scsi_pause *scsi_cmd;
3059         struct ccb_scsiio *csio;
3060         union ccb *ccb;
3061         int error;
3062
3063         error = 0;
3064
3065         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3066
3067         csio = &ccb->csio;
3068
3069         cam_fill_csio(csio,
3070                       /* retries */ cd_retry_count,
3071                       /* cbfcnp */ cddone,
3072                       /* flags */ CAM_DIR_NONE,
3073                       /* tag_action */ MSG_SIMPLE_Q_TAG,
3074                       /* data_ptr */ NULL,
3075                       /* dxfer_len */ 0,
3076                       /* sense_len */ SSD_FULL_SIZE,
3077                       sizeof(struct scsi_pause),
3078                       /* timeout */ 50000);
3079
3080         scsi_cmd = (struct scsi_pause *)&csio->cdb_io.cdb_bytes;
3081         bzero (scsi_cmd, sizeof(*scsi_cmd));
3082
3083         scsi_cmd->op_code = PAUSE;
3084         scsi_cmd->resume = go;
3085
3086         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3087                          /*sense_flags*/SF_RETRY_UA);
3088
3089         xpt_release_ccb(ccb);
3090
3091         return(error);
3092 }
3093
3094 static int
3095 cdstartunit(struct cam_periph *periph, int load)
3096 {
3097         union ccb *ccb;
3098         int error;
3099
3100         error = 0;
3101
3102         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3103
3104         scsi_start_stop(&ccb->csio,
3105                         /* retries */ cd_retry_count,
3106                         /* cbfcnp */ cddone,
3107                         /* tag_action */ MSG_SIMPLE_Q_TAG,
3108                         /* start */ TRUE,
3109                         /* load_eject */ load,
3110                         /* immediate */ FALSE,
3111                         /* sense_len */ SSD_FULL_SIZE,
3112                         /* timeout */ 50000);
3113
3114         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3115                          /*sense_flags*/SF_RETRY_UA);
3116
3117         xpt_release_ccb(ccb);
3118
3119         return(error);
3120 }
3121
3122 static int
3123 cdstopunit(struct cam_periph *periph, u_int32_t eject)
3124 {
3125         union ccb *ccb;
3126         int error;
3127
3128         error = 0;
3129
3130         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3131
3132         scsi_start_stop(&ccb->csio,
3133                         /* retries */ cd_retry_count,
3134                         /* cbfcnp */ cddone,
3135                         /* tag_action */ MSG_SIMPLE_Q_TAG,
3136                         /* start */ FALSE,
3137                         /* load_eject */ eject,
3138                         /* immediate */ FALSE,
3139                         /* sense_len */ SSD_FULL_SIZE,
3140                         /* timeout */ 50000);
3141
3142         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3143                          /*sense_flags*/SF_RETRY_UA);
3144
3145         xpt_release_ccb(ccb);
3146
3147         return(error);
3148 }
3149
3150 static int
3151 cdsetspeed(struct cam_periph *periph, u_int32_t rdspeed, u_int32_t wrspeed)
3152 {
3153         struct scsi_set_speed *scsi_cmd;
3154         struct ccb_scsiio *csio;
3155         union ccb *ccb;
3156         int error;
3157
3158         error = 0;
3159         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3160         csio = &ccb->csio;
3161
3162         /* Preserve old behavior: units in multiples of CDROM speed */
3163         if (rdspeed < 177)
3164                 rdspeed *= 177;
3165         if (wrspeed < 177)
3166                 wrspeed *= 177;
3167
3168         cam_fill_csio(csio,
3169                       /* retries */ cd_retry_count,
3170                       /* cbfcnp */ cddone,
3171                       /* flags */ CAM_DIR_NONE,
3172                       /* tag_action */ MSG_SIMPLE_Q_TAG,
3173                       /* data_ptr */ NULL,
3174                       /* dxfer_len */ 0,
3175                       /* sense_len */ SSD_FULL_SIZE,
3176                       sizeof(struct scsi_set_speed),
3177                       /* timeout */ 50000);
3178
3179         scsi_cmd = (struct scsi_set_speed *)&csio->cdb_io.cdb_bytes;
3180         bzero(scsi_cmd, sizeof(*scsi_cmd));
3181
3182         scsi_cmd->opcode = SET_CD_SPEED;
3183         scsi_ulto2b(rdspeed, scsi_cmd->readspeed);
3184         scsi_ulto2b(wrspeed, scsi_cmd->writespeed);
3185
3186         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3187                          /*sense_flags*/SF_RETRY_UA);
3188
3189         xpt_release_ccb(ccb);
3190
3191         return(error);
3192 }
3193
3194 static int
3195 cdreportkey(struct cam_periph *periph, struct dvd_authinfo *authinfo)
3196 {
3197         union ccb *ccb;
3198         u_int8_t *databuf;
3199         u_int32_t lba;
3200         int error;
3201         int length;
3202
3203         error = 0;
3204         databuf = NULL;
3205         lba = 0;
3206
3207         switch (authinfo->format) {
3208         case DVD_REPORT_AGID:
3209                 length = sizeof(struct scsi_report_key_data_agid);
3210                 break;
3211         case DVD_REPORT_CHALLENGE:
3212                 length = sizeof(struct scsi_report_key_data_challenge);
3213                 break;
3214         case DVD_REPORT_KEY1:
3215                 length = sizeof(struct scsi_report_key_data_key1_key2);
3216                 break;
3217         case DVD_REPORT_TITLE_KEY:
3218                 length = sizeof(struct scsi_report_key_data_title);
3219                 /* The lba field is only set for the title key */
3220                 lba = authinfo->lba;
3221                 break;
3222         case DVD_REPORT_ASF:
3223                 length = sizeof(struct scsi_report_key_data_asf);
3224                 break;
3225         case DVD_REPORT_RPC:
3226                 length = sizeof(struct scsi_report_key_data_rpc);
3227                 break;
3228         case DVD_INVALIDATE_AGID:
3229                 length = 0;
3230                 break;
3231         default:
3232                 return (EINVAL);
3233         }
3234
3235         if (length != 0) {
3236                 databuf = malloc(length, M_DEVBUF, M_WAITOK | M_ZERO);
3237         } else
3238                 databuf = NULL;
3239
3240         cam_periph_lock(periph);
3241         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3242
3243         scsi_report_key(&ccb->csio,
3244                         /* retries */ cd_retry_count,
3245                         /* cbfcnp */ cddone,
3246                         /* tag_action */ MSG_SIMPLE_Q_TAG,
3247                         /* lba */ lba,
3248                         /* agid */ authinfo->agid,
3249                         /* key_format */ authinfo->format,
3250                         /* data_ptr */ databuf,
3251                         /* dxfer_len */ length,
3252                         /* sense_len */ SSD_FULL_SIZE,
3253                         /* timeout */ 50000);
3254
3255         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3256                          /*sense_flags*/SF_RETRY_UA);
3257
3258         if (error != 0)
3259                 goto bailout;
3260
3261         if (ccb->csio.resid != 0) {
3262                 xpt_print(periph->path, "warning, residual for report key "
3263                     "command is %d\n", ccb->csio.resid);
3264         }
3265
3266         switch(authinfo->format) {
3267         case DVD_REPORT_AGID: {
3268                 struct scsi_report_key_data_agid *agid_data;
3269
3270                 agid_data = (struct scsi_report_key_data_agid *)databuf;
3271
3272                 authinfo->agid = (agid_data->agid & RKD_AGID_MASK) >>
3273                         RKD_AGID_SHIFT;
3274                 break;
3275         }
3276         case DVD_REPORT_CHALLENGE: {
3277                 struct scsi_report_key_data_challenge *chal_data;
3278
3279                 chal_data = (struct scsi_report_key_data_challenge *)databuf;
3280
3281                 bcopy(chal_data->challenge_key, authinfo->keychal,
3282                       min(sizeof(chal_data->challenge_key),
3283                           sizeof(authinfo->keychal)));
3284                 break;
3285         }
3286         case DVD_REPORT_KEY1: {
3287                 struct scsi_report_key_data_key1_key2 *key1_data;
3288
3289                 key1_data = (struct scsi_report_key_data_key1_key2 *)databuf;
3290
3291                 bcopy(key1_data->key1, authinfo->keychal,
3292                       min(sizeof(key1_data->key1), sizeof(authinfo->keychal)));
3293                 break;
3294         }
3295         case DVD_REPORT_TITLE_KEY: {
3296                 struct scsi_report_key_data_title *title_data;
3297
3298                 title_data = (struct scsi_report_key_data_title *)databuf;
3299
3300                 authinfo->cpm = (title_data->byte0 & RKD_TITLE_CPM) >>
3301                         RKD_TITLE_CPM_SHIFT;
3302                 authinfo->cp_sec = (title_data->byte0 & RKD_TITLE_CP_SEC) >>
3303                         RKD_TITLE_CP_SEC_SHIFT;
3304                 authinfo->cgms = (title_data->byte0 & RKD_TITLE_CMGS_MASK) >>
3305                         RKD_TITLE_CMGS_SHIFT;
3306                 bcopy(title_data->title_key, authinfo->keychal,
3307                       min(sizeof(title_data->title_key),
3308                           sizeof(authinfo->keychal)));
3309                 break;
3310         }
3311         case DVD_REPORT_ASF: {
3312                 struct scsi_report_key_data_asf *asf_data;
3313
3314                 asf_data = (struct scsi_report_key_data_asf *)databuf;
3315
3316                 authinfo->asf = asf_data->success & RKD_ASF_SUCCESS;
3317                 break;
3318         }
3319         case DVD_REPORT_RPC: {
3320                 struct scsi_report_key_data_rpc *rpc_data;
3321
3322                 rpc_data = (struct scsi_report_key_data_rpc *)databuf;
3323
3324                 authinfo->reg_type = (rpc_data->byte4 & RKD_RPC_TYPE_MASK) >>
3325                         RKD_RPC_TYPE_SHIFT;
3326                 authinfo->vend_rsts =
3327                         (rpc_data->byte4 & RKD_RPC_VENDOR_RESET_MASK) >>
3328                         RKD_RPC_VENDOR_RESET_SHIFT;
3329                 authinfo->user_rsts = rpc_data->byte4 & RKD_RPC_USER_RESET_MASK;
3330                 authinfo->region = rpc_data->region_mask;
3331                 authinfo->rpc_scheme = rpc_data->rpc_scheme1;
3332                 break;
3333         }
3334         case DVD_INVALIDATE_AGID:
3335                 break;
3336         default:
3337                 /* This should be impossible, since we checked above */
3338                 error = EINVAL;
3339                 goto bailout;
3340                 break; /* NOTREACHED */
3341         }
3342
3343 bailout:
3344         xpt_release_ccb(ccb);
3345         cam_periph_unlock(periph);
3346
3347         if (databuf != NULL)
3348                 free(databuf, M_DEVBUF);
3349
3350         return(error);
3351 }
3352
3353 static int
3354 cdsendkey(struct cam_periph *periph, struct dvd_authinfo *authinfo)
3355 {
3356         union ccb *ccb;
3357         u_int8_t *databuf;
3358         int length;
3359         int error;
3360
3361         error = 0;
3362         databuf = NULL;
3363
3364         switch(authinfo->format) {
3365         case DVD_SEND_CHALLENGE: {
3366                 struct scsi_report_key_data_challenge *challenge_data;
3367
3368                 length = sizeof(*challenge_data);
3369
3370                 challenge_data = malloc(length, M_DEVBUF, M_WAITOK | M_ZERO);
3371
3372                 databuf = (u_int8_t *)challenge_data;
3373
3374                 scsi_ulto2b(length - sizeof(challenge_data->data_len),
3375                             challenge_data->data_len);
3376
3377                 bcopy(authinfo->keychal, challenge_data->challenge_key,
3378                       min(sizeof(authinfo->keychal),
3379                           sizeof(challenge_data->challenge_key)));
3380                 break;
3381         }
3382         case DVD_SEND_KEY2: {
3383                 struct scsi_report_key_data_key1_key2 *key2_data;
3384
3385                 length = sizeof(*key2_data);
3386
3387                 key2_data = malloc(length, M_DEVBUF, M_WAITOK | M_ZERO);
3388
3389                 databuf = (u_int8_t *)key2_data;
3390
3391                 scsi_ulto2b(length - sizeof(key2_data->data_len),
3392                             key2_data->data_len);
3393
3394                 bcopy(authinfo->keychal, key2_data->key1,
3395                       min(sizeof(authinfo->keychal), sizeof(key2_data->key1)));
3396
3397                 break;
3398         }
3399         case DVD_SEND_RPC: {
3400                 struct scsi_send_key_data_rpc *rpc_data;
3401
3402                 length = sizeof(*rpc_data);
3403
3404                 rpc_data = malloc(length, M_DEVBUF, M_WAITOK | M_ZERO);
3405
3406                 databuf = (u_int8_t *)rpc_data;
3407
3408                 scsi_ulto2b(length - sizeof(rpc_data->data_len),
3409                             rpc_data->data_len);
3410
3411                 rpc_data->region_code = authinfo->region;
3412                 break;
3413         }
3414         default:
3415                 return (EINVAL);
3416         }
3417
3418         cam_periph_lock(periph);
3419         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3420
3421         scsi_send_key(&ccb->csio,
3422                       /* retries */ cd_retry_count,
3423                       /* cbfcnp */ cddone,
3424                       /* tag_action */ MSG_SIMPLE_Q_TAG,
3425                       /* agid */ authinfo->agid,
3426                       /* key_format */ authinfo->format,
3427                       /* data_ptr */ databuf,
3428                       /* dxfer_len */ length,
3429                       /* sense_len */ SSD_FULL_SIZE,
3430                       /* timeout */ 50000);
3431
3432         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3433                          /*sense_flags*/SF_RETRY_UA);
3434
3435         xpt_release_ccb(ccb);
3436         cam_periph_unlock(periph);
3437
3438         if (databuf != NULL)
3439                 free(databuf, M_DEVBUF);
3440
3441         return(error);
3442 }
3443
3444 static int
3445 cdreaddvdstructure(struct cam_periph *periph, struct dvd_struct *dvdstruct)
3446 {
3447         union ccb *ccb;
3448         u_int8_t *databuf;
3449         u_int32_t address;
3450         int error;
3451         int length;
3452
3453         error = 0;
3454         databuf = NULL;
3455         /* The address is reserved for many of the formats */
3456         address = 0;
3457
3458         switch(dvdstruct->format) {
3459         case DVD_STRUCT_PHYSICAL:
3460                 length = sizeof(struct scsi_read_dvd_struct_data_physical);
3461                 break;
3462         case DVD_STRUCT_COPYRIGHT:
3463                 length = sizeof(struct scsi_read_dvd_struct_data_copyright);
3464                 break;
3465         case DVD_STRUCT_DISCKEY:
3466                 length = sizeof(struct scsi_read_dvd_struct_data_disc_key);
3467                 break;
3468         case DVD_STRUCT_BCA:
3469                 length = sizeof(struct scsi_read_dvd_struct_data_bca);
3470                 break;
3471         case DVD_STRUCT_MANUFACT:
3472                 length = sizeof(struct scsi_read_dvd_struct_data_manufacturer);
3473                 break;
3474         case DVD_STRUCT_CMI:
3475                 return (ENODEV);
3476         case DVD_STRUCT_PROTDISCID:
3477                 length = sizeof(struct scsi_read_dvd_struct_data_prot_discid);
3478                 break;
3479         case DVD_STRUCT_DISCKEYBLOCK:
3480                 length = sizeof(struct scsi_read_dvd_struct_data_disc_key_blk);
3481                 break;
3482         case DVD_STRUCT_DDS:
3483                 length = sizeof(struct scsi_read_dvd_struct_data_dds);
3484                 break;
3485         case DVD_STRUCT_MEDIUM_STAT:
3486                 length = sizeof(struct scsi_read_dvd_struct_data_medium_status);
3487                 break;
3488         case DVD_STRUCT_SPARE_AREA:
3489                 length = sizeof(struct scsi_read_dvd_struct_data_spare_area);
3490                 break;
3491         case DVD_STRUCT_RMD_LAST:
3492                 return (ENODEV);
3493         case DVD_STRUCT_RMD_RMA:
3494                 return (ENODEV);
3495         case DVD_STRUCT_PRERECORDED:
3496                 length = sizeof(struct scsi_read_dvd_struct_data_leadin);
3497                 break;
3498         case DVD_STRUCT_UNIQUEID:
3499                 length = sizeof(struct scsi_read_dvd_struct_data_disc_id);
3500                 break;
3501         case DVD_STRUCT_DCB:
3502                 return (ENODEV);
3503         case DVD_STRUCT_LIST:
3504                 /*
3505                  * This is the maximum allocation length for the READ DVD
3506                  * STRUCTURE command.  There's nothing in the MMC3 spec
3507                  * that indicates a limit in the amount of data that can
3508                  * be returned from this call, other than the limits
3509                  * imposed by the 2-byte length variables.
3510                  */
3511                 length = 65535;
3512                 break;
3513         default:
3514                 return (EINVAL);
3515         }
3516
3517         if (length != 0) {
3518                 databuf = malloc(length, M_DEVBUF, M_WAITOK | M_ZERO);
3519         } else
3520                 databuf = NULL;
3521
3522         cam_periph_lock(periph);
3523         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3524
3525         scsi_read_dvd_structure(&ccb->csio,
3526                                 /* retries */ cd_retry_count,
3527                                 /* cbfcnp */ cddone,
3528                                 /* tag_action */ MSG_SIMPLE_Q_TAG,
3529                                 /* lba */ address,
3530                                 /* layer_number */ dvdstruct->layer_num,
3531                                 /* key_format */ dvdstruct->format,
3532                                 /* agid */ dvdstruct->agid,
3533                                 /* data_ptr */ databuf,
3534                                 /* dxfer_len */ length,
3535                                 /* sense_len */ SSD_FULL_SIZE,
3536                                 /* timeout */ 50000);
3537
3538         error = cdrunccb(ccb, cderror, /*cam_flags*/CAM_RETRY_SELTO,
3539                          /*sense_flags*/SF_RETRY_UA);
3540
3541         if (error != 0)
3542                 goto bailout;
3543
3544         switch(dvdstruct->format) {
3545         case DVD_STRUCT_PHYSICAL: {
3546                 struct scsi_read_dvd_struct_data_layer_desc *inlayer;
3547                 struct dvd_layer *outlayer;
3548                 struct scsi_read_dvd_struct_data_physical *phys_data;
3549
3550                 phys_data =
3551                         (struct scsi_read_dvd_struct_data_physical *)databuf;
3552                 inlayer = &phys_data->layer_desc;
3553                 outlayer = (struct dvd_layer *)&dvdstruct->data;
3554
3555                 dvdstruct->length = sizeof(*inlayer);
3556
3557                 outlayer->book_type = (inlayer->book_type_version &
3558                         RDSD_BOOK_TYPE_MASK) >> RDSD_BOOK_TYPE_SHIFT;
3559                 outlayer->book_version = (inlayer->book_type_version &
3560                         RDSD_BOOK_VERSION_MASK);
3561                 outlayer->disc_size = (inlayer->disc_size_max_rate &
3562                         RDSD_DISC_SIZE_MASK) >> RDSD_DISC_SIZE_SHIFT;
3563                 outlayer->max_rate = (inlayer->disc_size_max_rate &
3564                         RDSD_MAX_RATE_MASK);
3565                 outlayer->nlayers = (inlayer->layer_info &
3566                         RDSD_NUM_LAYERS_MASK) >> RDSD_NUM_LAYERS_SHIFT;
3567                 outlayer->track_path = (inlayer->layer_info &
3568                         RDSD_TRACK_PATH_MASK) >> RDSD_TRACK_PATH_SHIFT;
3569                 outlayer->layer_type = (inlayer->layer_info &
3570                         RDSD_LAYER_TYPE_MASK);
3571                 outlayer->linear_density = (inlayer->density &
3572                         RDSD_LIN_DENSITY_MASK) >> RDSD_LIN_DENSITY_SHIFT;
3573                 outlayer->track_density = (inlayer->density &
3574                         RDSD_TRACK_DENSITY_MASK);
3575                 outlayer->bca = (inlayer->bca & RDSD_BCA_MASK) >>
3576                         RDSD_BCA_SHIFT;
3577                 outlayer->start_sector = scsi_3btoul(inlayer->main_data_start);
3578                 outlayer->end_sector = scsi_3btoul(inlayer->main_data_end);
3579                 outlayer->end_sector_l0 =
3580                         scsi_3btoul(inlayer->end_sector_layer0);
3581                 break;
3582         }
3583         case DVD_STRUCT_COPYRIGHT: {
3584                 struct scsi_read_dvd_struct_data_copyright *copy_data;
3585
3586                 copy_data = (struct scsi_read_dvd_struct_data_copyright *)
3587                         databuf;
3588
3589                 dvdstruct->cpst = copy_data->cps_type;
3590                 dvdstruct->rmi = copy_data->region_info;
3591                 dvdstruct->length = 0;
3592
3593                 break;
3594         }
3595         default:
3596                 /*
3597                  * Tell the user what the overall length is, no matter
3598                  * what we can actually fit in the data buffer.
3599                  */
3600                 dvdstruct->length = length - ccb->csio.resid -
3601                         sizeof(struct scsi_read_dvd_struct_data_header);
3602
3603                 /*
3604                  * But only actually copy out the smaller of what we read
3605                  * in or what the structure can take.
3606                  */
3607                 bcopy(databuf + sizeof(struct scsi_read_dvd_struct_data_header),
3608                       dvdstruct->data,
3609                       min(sizeof(dvdstruct->data), dvdstruct->length));
3610                 break;
3611         }
3612
3613 bailout:
3614         xpt_release_ccb(ccb);
3615         cam_periph_unlock(periph);
3616
3617         if (databuf != NULL)
3618                 free(databuf, M_DEVBUF);
3619
3620         return(error);
3621 }
3622
3623 void
3624 scsi_report_key(struct ccb_scsiio *csio, u_int32_t retries,
3625                 void (*cbfcnp)(struct cam_periph *, union ccb *),
3626                 u_int8_t tag_action, u_int32_t lba, u_int8_t agid,
3627                 u_int8_t key_format, u_int8_t *data_ptr, u_int32_t dxfer_len,
3628                 u_int8_t sense_len, u_int32_t timeout)
3629 {
3630         struct scsi_report_key *scsi_cmd;
3631
3632         scsi_cmd = (struct scsi_report_key *)&csio->cdb_io.cdb_bytes;
3633         bzero(scsi_cmd, sizeof(*scsi_cmd));
3634         scsi_cmd->opcode = REPORT_KEY;
3635         scsi_ulto4b(lba, scsi_cmd->lba);
3636         scsi_ulto2b(dxfer_len, scsi_cmd->alloc_len);
3637         scsi_cmd->agid_keyformat = (agid << RK_KF_AGID_SHIFT) |
3638                 (key_format & RK_KF_KEYFORMAT_MASK);
3639
3640         cam_fill_csio(csio,
3641                       retries,
3642                       cbfcnp,
3643                       /*flags*/ (dxfer_len == 0) ? CAM_DIR_NONE : CAM_DIR_IN,
3644                       tag_action,
3645                       /*data_ptr*/ data_ptr,
3646                       /*dxfer_len*/ dxfer_len,
3647                       sense_len,
3648                       sizeof(*scsi_cmd),
3649                       timeout);
3650 }
3651
3652 void
3653 scsi_send_key(struct ccb_scsiio *csio, u_int32_t retries,
3654               void (*cbfcnp)(struct cam_periph *, union ccb *),
3655               u_int8_t tag_action, u_int8_t agid, u_int8_t key_format,
3656               u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
3657               u_int32_t timeout)
3658 {
3659         struct scsi_send_key *scsi_cmd;
3660
3661         scsi_cmd = (struct scsi_send_key *)&csio->cdb_io.cdb_bytes;
3662         bzero(scsi_cmd, sizeof(*scsi_cmd));
3663         scsi_cmd->opcode = SEND_KEY;
3664
3665         scsi_ulto2b(dxfer_len, scsi_cmd->param_len);
3666         scsi_cmd->agid_keyformat = (agid << RK_KF_AGID_SHIFT) |
3667                 (key_format & RK_KF_KEYFORMAT_MASK);
3668
3669         cam_fill_csio(csio,
3670                       retries,
3671                       cbfcnp,
3672                       /*flags*/ CAM_DIR_OUT,
3673                       tag_action,
3674                       /*data_ptr*/ data_ptr,
3675                       /*dxfer_len*/ dxfer_len,
3676                       sense_len,
3677                       sizeof(*scsi_cmd),
3678                       timeout);
3679 }
3680
3681
3682 void
3683 scsi_read_dvd_structure(struct ccb_scsiio *csio, u_int32_t retries,
3684                         void (*cbfcnp)(struct cam_periph *, union ccb *),
3685                         u_int8_t tag_action, u_int32_t address,
3686                         u_int8_t layer_number, u_int8_t format, u_int8_t agid,
3687                         u_int8_t *data_ptr, u_int32_t dxfer_len,
3688                         u_int8_t sense_len, u_int32_t timeout)
3689 {
3690         struct scsi_read_dvd_structure *scsi_cmd;
3691
3692         scsi_cmd = (struct scsi_read_dvd_structure *)&csio->cdb_io.cdb_bytes;
3693         bzero(scsi_cmd, sizeof(*scsi_cmd));
3694         scsi_cmd->opcode = READ_DVD_STRUCTURE;
3695
3696         scsi_ulto4b(address, scsi_cmd->address);
3697         scsi_cmd->layer_number = layer_number;
3698         scsi_cmd->format = format;
3699         scsi_ulto2b(dxfer_len, scsi_cmd->alloc_len);
3700         /* The AGID is the top two bits of this byte */
3701         scsi_cmd->agid = agid << 6;
3702
3703         cam_fill_csio(csio,
3704                       retries,
3705                       cbfcnp,
3706                       /*flags*/ CAM_DIR_IN,
3707                       tag_action,
3708                       /*data_ptr*/ data_ptr,
3709                       /*dxfer_len*/ dxfer_len,
3710                       sense_len,
3711                       sizeof(*scsi_cmd),
3712                       timeout);
3713 }