int			toc_read_len;

	struct cd_toc_single	leadout;

	case CD_STATE_MEDIA_SIZE:

		struct scsi_read_capacity_data *rcap;

		/*

		 * Set the default capacity and sector size to something that

		 * GEOM can handle.  This will get reset when a read capacity

		 * completes successfully.

		 */

		softc->disk->d_sectorsize = 2048;

		softc->disk->d_mediasize = 0;

	case CD_STATE_MEDIA_ALLOW:

	case CD_STATE_MEDIA_PREVENT:

	{

		/*

		 * If the CD is already locked, we don't need to do this.

		 * Move on to the capacity check.

		 */

		if ((softc->flags & CD_FLAG_DISC_LOCKED) != 0) {

			softc->state = CD_STATE_MEDIA_SIZE;

			xpt_release_ccb(start_ccb);

			xpt_schedule(periph, CAM_PRIORITY_NORMAL);

			break;

		}

		scsi_prevent(&start_ccb->csio, 

			     /*retries*/ cd_retry_count,

			     /*cbfcnp*/ cddone,

			     /*tag_action*/ MSG_SIMPLE_Q_TAG,

			     /*action*/ (softc->state == CD_STATE_MEDIA_ALLOW) ?

					PR_ALLOW : PR_PREVENT,

			     /*sense_len*/ SSD_FULL_SIZE,

			     /*timeout*/ 60000);

		start_ccb->ccb_h.ccb_bp = NULL;

		if (softc->state == CD_STATE_MEDIA_ALLOW)

			start_ccb->ccb_h.ccb_state = CD_CCB_MEDIA_ALLOW;

		else

			start_ccb->ccb_h.ccb_state = CD_CCB_MEDIA_PREVENT;

		xpt_action(start_ccb);

		break;

	case CD_STATE_MEDIA_TOC_HDR: {

		struct ioc_toc_header *toch;

		bzero(&softc->toc, sizeof(softc->toc));

		toch = &softc->toc.header;

		scsi_read_toc(&start_ccb->csio,

			      /*retries*/ cd_retry_count,

			      /*cbfcnp*/ cddone,

			      /*tag_action*/ MSG_SIMPLE_Q_TAG,

			      /*byte1_flags*/ 0,

			      /*format*/ SRTOC_FORMAT_TOC,

			      /*track*/ 0,

			      /*data_ptr*/ (uint8_t *)toch, 

			      /*dxfer_len*/ sizeof(*toch),

			      /*sense_len*/ SSD_FULL_SIZE,

			      /*timeout*/ 50000);

		start_ccb->ccb_h.ccb_bp = NULL;

		start_ccb->ccb_h.ccb_state = CD_CCB_MEDIA_TOC_HDR;

		xpt_action(start_ccb);

		break;

	}

	case CD_STATE_MEDIA_TOC_FULL: {

		bzero(&softc->toc, sizeof(softc->toc));

		scsi_read_toc(&start_ccb->csio,

			      /*retries*/ cd_retry_count,

			      /*cbfcnp*/ cddone,

			      /*tag_action*/ MSG_SIMPLE_Q_TAG,

			      /*byte1_flags*/ 0,

			      /*format*/ SRTOC_FORMAT_TOC,

			      /*track*/ 0,

			      /*data_ptr*/ (uint8_t *)&softc->toc,

			      /*dxfer_len*/ softc->toc_read_len ?

					    softc->toc_read_len :

					    sizeof(softc->toc),

			      /*sense_len*/ SSD_FULL_SIZE,

			      /*timeout*/ 50000);

		start_ccb->ccb_h.ccb_bp = NULL;

		start_ccb->ccb_h.ccb_state = CD_CCB_MEDIA_TOC_FULL;

		xpt_action(start_ccb);

		break;

	}

	case CD_STATE_MEDIA_TOC_LEAD: {

		struct cd_toc_single *leadout;

		leadout = &softc->leadout;

		bzero(leadout, sizeof(*leadout));

		scsi_read_toc(&start_ccb->csio,

			      /*retries*/ cd_retry_count,

			      /*cbfcnp*/ cddone,

			      /*tag_action*/ MSG_SIMPLE_Q_TAG,

			      /*byte1_flags*/ CD_MSF,

			      /*format*/ SRTOC_FORMAT_TOC,

			      /*track*/ LEADOUT,

			      /*data_ptr*/ (uint8_t *)leadout, 

			      /*dxfer_len*/ sizeof(*leadout),

			      /*sense_len*/ SSD_FULL_SIZE,

			      /*timeout*/ 50000);

		start_ccb->ccb_h.ccb_bp = NULL;

		start_ccb->ccb_h.ccb_state = CD_CCB_MEDIA_TOC_LEAD;

		xpt_action(start_ccb);

		break;

	}

	}

	case CD_CCB_MEDIA_ALLOW: 

	case CD_CCB_MEDIA_PREVENT:

	{

		int error;

		int is_prevent;

		error = 0;

		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {

			error = cderror(done_ccb, CAM_RETRY_SELTO,

			    SF_RETRY_UA | SF_NO_PRINT);

		}

		if (error == ERESTART)

			return;

		if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)

			cam_release_devq(done_ccb->ccb_h.path,

					 /*relsim_flags*/0,

					 /*reduction*/0,

					 /*timeout*/0,

					 /*getcount_only*/0);

		/*

		 * Note that just like the original cdcheckmedia(), we do

		 * a prevent without failing the whole operation if the

		 * prevent fails.  We try, but keep going if it doesn't

		 * work.

		 */

		if ((done_ccb->ccb_h.ccb_state & CD_CCB_TYPE_MASK) ==

		     CD_CCB_MEDIA_PREVENT)

			is_prevent = 1;

		else

			is_prevent = 0;

		xpt_release_ccb(done_ccb);

		if (is_prevent != 0) {

			if (error == 0)

				softc->flags |= CD_FLAG_DISC_LOCKED;

			else

				softc->flags &= ~CD_FLAG_DISC_LOCKED;

			softc->state = CD_STATE_MEDIA_SIZE;

			xpt_schedule(periph, CAM_PRIORITY_NORMAL);

		} else {

			if (error == 0)

				softc->flags &= ~CD_FLAG_DISC_LOCKED;

			softc->state = CD_STATE_NORMAL;

			if (bioq_first(&softc->bio_queue) != NULL)

				xpt_schedule(periph, CAM_PRIORITY_NORMAL);

		}

		return;

	}

	case CD_CCB_MEDIA_SIZE:

	{

		struct scsi_read_capacity_data *rdcap;

		int error;

		error = 0;

		if ((csio->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {

			error = cderror(done_ccb, CAM_RETRY_SELTO,

			    SF_RETRY_UA | SF_NO_PRINT);

		}

		if (error == ERESTART)

			return;

		if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)

			cam_release_devq(done_ccb->ccb_h.path,

					 /*relsim_flags*/0,

					 /*reduction*/0,

					 /*timeout*/0,

					 /*getcount_only*/0);

		rdcap = (struct scsi_read_capacity_data *)csio->data_ptr;

		if (error == 0) {

			softc->params.disksize =scsi_4btoul(rdcap->addr) + 1;

			softc->params.blksize  = scsi_4btoul(rdcap->length);

			/* Make sure we got at least some block size. */

			if (softc->params.blksize == 0)

				error = EIO;

			/*

			 * SCSI-3 mandates that the reported blocksize shall be

			 * 2048.  Older drives sometimes report funny values,

			 * trim it down to 2048, or other parts of the kernel

			 * will get confused.

			 *

			 * XXX we leave drives alone that might report 512

			 * bytes, as well as drives reporting more weird

			 * sizes like perhaps 4K.

			 */

			if (softc->params.blksize > 2048

			 && softc->params.blksize <= 2352)

				softc->params.blksize = 2048;

		}

		free(rdcap, M_SCSICD);

		if (error == 0) {

			softc->disk->d_sectorsize = softc->params.blksize;

			softc->disk->d_mediasize =

			    (off_t)softc->params.blksize *

			    softc->params.disksize;

			softc->flags |= CD_FLAG_SAW_MEDIA | CD_FLAG_VALID_MEDIA;

			softc->state = CD_STATE_MEDIA_TOC_HDR;

		} else {

			softc->flags &= ~(CD_FLAG_VALID_MEDIA |

					  CD_FLAG_VALID_TOC);

			bioq_flush(&softc->bio_queue, NULL, EINVAL);

			softc->state = CD_STATE_MEDIA_ALLOW;

			cdmediaprobedone(periph);

		}

		xpt_release_ccb(done_ccb);

		xpt_schedule(periph, CAM_PRIORITY_NORMAL);

		return;

	}

	case CD_CCB_MEDIA_TOC_HDR:

	case CD_CCB_MEDIA_TOC_FULL:

	case CD_CCB_MEDIA_TOC_LEAD:

	{

		int error;

		struct ioc_toc_header *toch;

		int num_entries;

		int cdindex;

		error = 0;

		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {

			error = cderror(done_ccb, CAM_RETRY_SELTO,

			    SF_RETRY_UA | SF_NO_PRINT);

		}

		if (error == ERESTART)

			return;

		if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)

			cam_release_devq(done_ccb->ccb_h.path,

					 /*relsim_flags*/0,

					 /*reduction*/0,

					 /*timeout*/0,

					 /*getcount_only*/0);

		/*

		 * We will get errors here for media that doesn't have a table

		 * of contents.  According to the MMC-3 spec: "When a Read 

		 * TOC/PMA/ATIP command is presented for a DDCD/CD-R/RW media,

		 * where the first TOC has not been recorded (no complete

		 * session) and the Format codes 0000b, 0001b, or 0010b are

		 * specified, this command shall be rejected with an INVALID 

		 * FIELD IN CDB.  Devices that are not capable of reading an 

		 * incomplete session on DDC/CD-R/RW media shall report

		 * CANNOT READ MEDIUM - INCOMPATIBLE FORMAT."

		 *

		 * So this isn't fatal if we can't read the table of contents,

		 * it just means that the user won't be able to issue the

		 * play tracks ioctl, and likely lots of other stuff won't

		 * work either.  They need to burn the CD before we can do

		 * a whole lot with it.  So we don't print anything here if

		 * we get an error back.

		 *

		 * We also bail out if the drive doesn't at least give us

		 * the full TOC header.

		 */

		if ((error != 0)

		 || ((csio->dxfer_len - csio->resid) <

		      sizeof(struct ioc_toc_header))) {

			softc->flags &= ~CD_FLAG_VALID_TOC;

			bzero(&softc->toc, sizeof(softc->toc));

			/*

			 * Failing the TOC read is not an error.

			 */

			softc->state = CD_STATE_NORMAL;

			xpt_release_ccb(done_ccb);

			cdmediaprobedone(periph);

			/*

			 * Go ahead and schedule I/O execution if there is

			 * anything in the queue.  It'll probably get

			 * kicked out with an error.

			 */

			if (bioq_first(&softc->bio_queue) != NULL)

				xpt_schedule(periph, CAM_PRIORITY_NORMAL);

			return;

		}

		/*

		 * Note that this is NOT the storage location used for the

		 * leadout!

		 */

		toch = &softc->toc.header;

		if (softc->quirks & CD_Q_BCD_TRACKS) {

			toch->starting_track = bcd2bin(toch->starting_track);

			toch->ending_track = bcd2bin(toch->ending_track);

		}

		/* Number of TOC entries, plus leadout */

		num_entries = (toch->ending_track - toch->starting_track) + 2;

		cdindex = toch->starting_track + num_entries -1;

		if ((done_ccb->ccb_h.ccb_state & CD_CCB_TYPE_MASK) ==

		     CD_CCB_MEDIA_TOC_HDR) {

			if (num_entries <= 0) {

				softc->flags &= ~CD_FLAG_VALID_TOC;

				bzero(&softc->toc, sizeof(softc->toc));

				/*

				 * Failing the TOC read is not an error.

				 */

				softc->state = CD_STATE_NORMAL;

				xpt_release_ccb(done_ccb);

				cdmediaprobedone(periph);

				/*

				 * Go ahead and schedule I/O execution if

				 * there is anything in the queue.  It'll

				 * probably get kicked out with an error.

				 */

				if (bioq_first(&softc->bio_queue) != NULL)

					xpt_schedule(periph,

					    CAM_PRIORITY_NORMAL);

			} else {

				softc->toc_read_len = num_entries *

				    sizeof(struct cd_toc_entry);

				softc->toc_read_len += sizeof(*toch);

				softc->state = CD_STATE_MEDIA_TOC_FULL;

				xpt_release_ccb(done_ccb);

				xpt_schedule(periph, CAM_PRIORITY_NORMAL);

			}

			return;

		} else if ((done_ccb->ccb_h.ccb_state & CD_CCB_TYPE_MASK) ==

			    CD_CCB_MEDIA_TOC_LEAD) {

			struct cd_toc_single *leadout;

			leadout = (struct cd_toc_single *)csio->data_ptr;

			softc->toc.entries[cdindex - toch->starting_track] =

			    leadout->entry;

		} else if (((done_ccb->ccb_h.ccb_state & CD_CCB_TYPE_MASK) ==

			    CD_CCB_MEDIA_TOC_FULL)

			&& (cdindex == toch->ending_track + 1)) {

			/*

			 * XXX KDM is this necessary?  Probably only if the

			 * drive doesn't return leadout information with the

			 * table of contents.

			 */

			softc->state = CD_STATE_MEDIA_TOC_LEAD;

			xpt_release_ccb(done_ccb);

			xpt_schedule(periph, CAM_PRIORITY_NORMAL);

			return;

		}

		if (softc->quirks & CD_Q_BCD_TRACKS) {

			for (cdindex = 0; cdindex < num_entries - 1; cdindex++){

				softc->toc.entries[cdindex].track =

				    bcd2bin(softc->toc.entries[cdindex].track);

			}

		}

		softc->flags |= CD_FLAG_VALID_TOC;

		/* If the first track is audio, correct sector size. */

		if ((softc->toc.entries[0].control & 4) == 0) {

			softc->disk->d_sectorsize =softc->params.blksize = 2352;

			softc->disk->d_mediasize =

			    (off_t)softc->params.blksize *

			    softc->params.disksize;

		}

		softc->state = CD_STATE_NORMAL;

		/*

		 * We unconditionally (re)set the blocksize each time the

		 * CD device is opened.  This is because the CD can change,

		 * and therefore the blocksize might change.

		 * XXX problems here if some slice or partition is still

		 * open with the old size?

		 */

		if ((softc->disk->d_devstat->flags & DEVSTAT_BS_UNAVAILABLE)!=0)

			softc->disk->d_devstat->flags &=

			    ~DEVSTAT_BS_UNAVAILABLE;

		softc->disk->d_devstat->block_size = softc->params.blksize;

		xpt_release_ccb(done_ccb);

		cdmediaprobedone(periph);

		if (bioq_first(&softc->bio_queue) != NULL)

			xpt_schedule(periph, CAM_PRIORITY_NORMAL);

		return;

	}

static void

cdmediaprobedone(struct cam_periph *periph)

{

	struct cd_softc *softc;

	softc = (struct cd_softc *)periph->softc;

	softc->flags &= ~CD_FLAG_MEDIA_SCAN_ACT;

	if ((softc->flags & CD_FLAG_MEDIA_WAIT) != 0) {

		softc->flags &= ~CD_FLAG_MEDIA_WAIT;

		wakeup(&softc->toc);

	}

}

cdcheckmedia(struct cam_periph *periph, int do_wait)

{

	struct cd_softc *softc;

	int error;

	softc = (struct cd_softc *)periph->softc;

	error = 0;

	if ((do_wait != 0)

	 && ((softc->flags & CD_FLAG_MEDIA_WAIT) == 0)) {

		softc->flags |= CD_FLAG_MEDIA_WAIT;

	}

	if ((softc->flags & CD_FLAG_MEDIA_SCAN_ACT) == 0) {

		softc->state = CD_STATE_MEDIA_PREVENT;

		softc->flags |= CD_FLAG_MEDIA_SCAN_ACT;

		xpt_schedule(periph, CAM_PRIORITY_NORMAL);

	}

	if (do_wait == 0)

		goto bailout;

	error = msleep(&softc->toc, cam_periph_mtx(periph), PRIBIO,"cdmedia",0);

	if (error != 0)

		goto bailout;

	/*

	 * Check to see whether we have a valid size from the media.  We

	 * may or may not have a valid TOC.

	 */

	if ((softc->flags & CD_FLAG_VALID_MEDIA) == 0)

		error = EINVAL;

bailout:

	return (error);

}

#if 0

static int

#endif

		      /* byte1_flags */ (mode == CD_MSF_FORMAT) ? CD_MSF : 0,

		      /* format */ SRTOC_FORMAT_TOC,

		      /* track*/ start,

void

scsi_read_toc(struct ccb_scsiio *csio, uint32_t retries,

	      void (*cbfcnp)(struct cam_periph *, union ccb *),

	      uint8_t tag_action, uint8_t byte1_flags, uint8_t format,

	      uint8_t track, uint8_t *data_ptr, uint32_t dxfer_len,

	      int sense_len, int timeout)

{

	struct scsi_read_toc *scsi_cmd;

	scsi_cmd = (struct scsi_read_toc *)&csio->cdb_io.cdb_bytes;

	bzero(scsi_cmd, sizeof(*scsi_cmd));

	scsi_cmd->op_code = READ_TOC;

	/*

	 * The structure is counting from 1, the function counting from 0.

	 * The spec counts from 0.  In MMC-6, there is only one flag, the

	 * MSF flag.  But we put the whole byte in for a bit a future-proofing.

	 */

	scsi_cmd->byte2 = byte1_flags;

	scsi_cmd->format = format;

	scsi_cmd->from_track = track;

	scsi_ulto2b(dxfer_len, scsi_cmd->data_len);

	cam_fill_csio(csio, 

		      /* retries */ retries, 

		      /* cbfcnp */ cbfcnp,

		      /* flags */ CAM_DIR_IN,

		      /* tag_action */ tag_action,

		      /* data_ptr */ data_ptr,

		      /* dxfer_len */ dxfer_len,

		      /* sense_len */ sense_len,

		      sizeof(*scsi_cmd),

 		      /* timeout */ timeout);

}

#define	SRTOC_FORMAT_TOC	0x00

#define	SRTOC_FORMAT_LAST_ADDR	0x01

#define	SRTOC_FORMAT_QSUB_TOC	0x02

#define	SRTOC_FORMAT_QSUB_PMA	0x03

#define	SRTOC_FORMAT_ATIP	0x04

#define	SRTOC_FORMAT_CD_TEXT	0x05

void scsi_read_toc(struct ccb_scsiio *csio, uint32_t retries,

		   void (*cbfcnp)(struct cam_periph *, union ccb *),

		   uint8_t tag_action, uint8_t byte1_flags, uint8_t format,

		   uint8_t track, uint8_t *data_ptr, uint32_t dxfer_len,

		   int sense_len, int timeout);