diff --git a/include/cdio/sector.h b/include/cdio/sector.h
index 39d3721f..07eaff8b 100644
--- a/include/cdio/sector.h
+++ b/include/cdio/sector.h
@@ -1,6 +1,5 @@
-
 /*
-    $Id: sector.h,v 1.22 2004/07/23 11:29:49 rocky Exp $
+    $Id: sector.h,v 1.23 2004/07/24 05:42:09 rocky Exp $
 
     Copyright (C) 2000 Herbert Valerio Riedel <hvr@gnu.org>
     Copyright (C) 2003, 2004 Rocky Bernstein <rocky@panix.com>
diff --git a/lib/FreeBSD/freebsd.h b/lib/FreeBSD/freebsd.h
index 9a70a565..0ccb82de 100644
--- a/lib/FreeBSD/freebsd.h
+++ b/lib/FreeBSD/freebsd.h
@@ -1,5 +1,5 @@
 /*
-    $Id: freebsd.h,v 1.14 2004/07/18 20:40:01 rocky Exp $
+    $Id: freebsd.h,v 1.15 2004/07/24 05:42:09 rocky Exp $
 
     Copyright (C) 2003, 2004 Rocky Bernstein <rocky@panix.com>
 
@@ -158,6 +158,13 @@ bool get_track_green_freebsd_ioctl(const _img_private_t *env,
 int  eject_media_freebsd_ioctl (_img_private_t *env);
 int  eject_media_freebsd_cam (_img_private_t *env);
 
+void get_drive_cap_freebsd_cam (const _img_private_t *p_env,
+				cdio_drive_read_cap_t  *p_read_cap,
+				cdio_drive_write_cap_t *p_write_cap,
+				cdio_drive_misc_cap_t  *p_misc_cap);
+
+char *get_mcn_freebsd_cam (_img_private_t *p_env);
+
 void free_freebsd_cam (void *obj);
 
 /*!
diff --git a/lib/FreeBSD/freebsd_cam.c b/lib/FreeBSD/freebsd_cam.c
index 1f43986c..a032a438 100644
--- a/lib/FreeBSD/freebsd_cam.c
+++ b/lib/FreeBSD/freebsd_cam.c
@@ -1,5 +1,5 @@
 /*
-    $Id: freebsd_cam.c,v 1.21 2004/07/22 09:52:17 rocky Exp $
+    $Id: freebsd_cam.c,v 1.22 2004/07/24 05:42:09 rocky Exp $
 
     Copyright (C) 2004 Rocky Bernstein <rocky@panix.com>
 
@@ -26,86 +26,128 @@
 # include "config.h"
 #endif
 
-static const char _rcsid[] = "$Id: freebsd_cam.c,v 1.21 2004/07/22 09:52:17 rocky Exp $";
+static const char _rcsid[] = "$Id: freebsd_cam.c,v 1.22 2004/07/24 05:42:09 rocky Exp $";
 
 #ifdef HAVE_FREEBSD_CDROM
 
 #include "freebsd.h"
 #include <cdio/scsi_mmc.h>
 
-static const u_char scsi_cdblen[8] = {6, 10, 10, 12, 12, 12, 10, 10};
+/* Default value in seconds we will wait for a command to 
+   complete. */
+#define DEFAULT_TIMEOUT_SECS 10
 
+/*!
+  Run a SCSI MMC command. 
+ 
+  p_user_data   internal CD structure.
+  i_timeout     time in milliseconds we will wait for the command
+                to complete. If this value is -1, use the default 
+		time-out value.
+  i_cdb	        Size of p_cdb
+  p_cdb	        CDB bytes. 
+  e_direction	direction the transfer is to go.
+  i_buf	        Size of buffer
+  p_buf	        Buffer for data, both sending and receiving
+
+  Return 0 if no error.
+ */
 static int
-_scsi_cmd (_img_private_t * env)
+scsi_mmc_run_cmd_freebsd_cam( const void *p_user_data, int i_timeout,
+			      unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb, 
+			      scsi_mmc_direction_t e_direction, 
+			      unsigned int i_buf, /*in/out*/ void *p_buf )
 {
-  int retval;
-  env->ccb.csio.cdb_len = scsi_cdblen[(env->ccb.csio.cdb_io.cdb_bytes[0] >> 5) & 7];
-  if ((retval = cam_send_ccb(env->cam, &env->ccb)) < 0)
+  const _img_private_t *p_env = p_user_data;
+  int   i_status;
+  union ccb ccb;
+
+  ccb.ccb_h.path_id    = p_env->cam->path_id;
+  ccb.ccb_h.target_id  = p_env->cam->target_id;
+  ccb.ccb_h.target_lun = p_env->cam->target_lun;
+  ccb.ccb_h.timeout    = i_timeout;
+
+  cam_fill_csio (&(ccb.csio), 1, NULL, 
+		 CAM_DEV_QFRZDIS, MSG_SIMPLE_Q_TAG, NULL, 0, 
+		 sizeof(ccb.csio.sense_data), 0, 30*1000);
+
+  memcpy(ccb.csio.cdb_io.cdb_bytes, p_cdb, i_cdb);
+  
+  ccb.csio.ccb_h.flags = (SCSI_MMC_DATA_READ == e_direction)
+    ? CAM_DIR_OUT : CAM_DIR_IN;
+
+  ccb.csio.data_ptr  = p_buf;
+  ccb.csio.dxfer_len = i_buf;
+
+  ccb.csio.cdb_len = 
+    scsi_mmc_get_cmd_len(ccb.csio.cdb_io.cdb_bytes[0]);
+  
+  if ((i_status = cam_send_ccb(p_env->cam, &ccb)) < 0)
     {
-      cdio_warn ("transport failed: ", retval);
+      cdio_warn ("transport failed: %d", i_status);
       return -1;
     }
-  if ((env->ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
+  if ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
     {
       return 0;
     }
   errno = EIO;
-  retval = ERRCODE(((unsigned char *)&env->ccb.csio.sense_data));
-  if (retval == 0)
-    retval = -1;
+  i_status = ERRCODE(((unsigned char *)&ccb.csio.sense_data));
+  if (i_status == 0)
+    i_status = -1;
   else
-    CREAM_ON_ERRNO(((unsigned char *)&env->ccb.csio.sense_data));
-  cdio_warn ("transport failed: ", retval);
-  return retval;
+    CREAM_ON_ERRNO(((unsigned char *)&ccb.csio.sense_data));
+  cdio_warn ("transport failed: %d", i_status);
+  return i_status;
 }
 
 bool
-init_freebsd_cam (_img_private_t *env)
+init_freebsd_cam (_img_private_t *p_env)
 {
   char pass[100];
   
-  env->cam=NULL;
-  memset (&env->ccb, 0, sizeof(env->ccb));
-  env->ccb.ccb_h.func_code = XPT_GDEVLIST;
+  p_env->cam=NULL;
+  memset (&p_env->ccb, 0, sizeof(p_env->ccb));
+  p_env->ccb.ccb_h.func_code = XPT_GDEVLIST;
 
-  if (-1 == env->gen.fd) 
-    env->gen.fd = open (env->device, O_RDONLY, 0);
+  if (-1 == p_env->gen.fd) 
+    p_env->gen.fd = open (p_env->device, O_RDONLY, 0);
 
-  if (env->gen.fd < 0)
+  if (p_env->gen.fd < 0)
     {
-      cdio_warn ("open (%s): %s", env->device, strerror (errno));
+      cdio_warn ("open (%s): %s", p_env->device, strerror (errno));
       return false;
     }
 
-  if (ioctl (env->gen.fd, CAMGETPASSTHRU, &env->ccb) < 0)
+  if (ioctl (p_env->gen.fd, CAMGETPASSTHRU, &p_env->ccb) < 0)
     {
       cdio_warn ("open: %s", strerror (errno));
       return false;
     }
   sprintf (pass,"/dev/%.15s%u",
-	   env->ccb.cgdl.periph_name,
-	   env->ccb.cgdl.unit_number);
-  env->cam = cam_open_pass (pass,O_RDWR,NULL);
-  env->gen.init   = true;
-  env->b_cam_init = true;
+	   p_env->ccb.cgdl.periph_name,
+	   p_env->ccb.cgdl.unit_number);
+  p_env->cam = cam_open_pass (pass,O_RDWR,NULL);
+  p_env->gen.init   = true;
+  p_env->b_cam_init = true;
   return true;
 }
 
 void
 free_freebsd_cam (void *user_data)
 {
-  _img_private_t *env = user_data;
+  _img_private_t *p_env = user_data;
 
-  if (NULL == env) return;
+  if (NULL == p_env) return;
 
-  if (env->gen.fd > 0)
-    close (env->gen.fd);
-  env->gen.fd = -1;
+  if (p_env->gen.fd > 0)
+    close (p_env->gen.fd);
+  p_env->gen.fd = -1;
 
-  if(env->cam)
-    cam_close_device(env->cam);
+  if(p_env->cam)
+    cam_close_device(p_env->cam);
 
-  free (env);
+  free (p_env);
 }
 
 /**** 
@@ -113,7 +155,7 @@ free_freebsd_cam (void *user_data)
       they can be used as a starting point for someone who knows what
       they are doing.
 *******/
-#if 0
+#if 1
 /*!
   Return the the kind of drive capabilities of device.
 
@@ -121,42 +163,24 @@ free_freebsd_cam (void *user_data)
   string when done with it.
 
  */
-static char *
-get_drive_mcn_freebsd_cam (img_private_t *env)
+char *
+get_mcn_freebsd_cam (_img_private_t *p_env)
 {
-  char buf[192] = { 0, };
-  int rc;
+  scsi_mmc_cdb_t cdb = {{0, }};
+  char buf[28] = { 0, };
+  int i_status;
   
-  memset(&env->ccb, 0, sizeof(env->ccb));
+  CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_SUBCHANNEL);
+  cdb.field[1] = 0x0;  
+  cdb.field[2] = 0x40; 
+  cdb.field[3] = CDIO_SUBCHANNEL_MEDIA_CATALOG;
+  CDIO_MMC_SET_READ_LENGTH(cdb.field, sizeof(buf));
 
-  env->ccb.ccb_h.path_id    = env->cam->path_id;
-  env->ccb.ccb_h.target_id  = env->cam->target_id;
-  env->ccb.ccb_h.target_lun = env->cam->target_lun;
-  cam_fill_csio (&(env->ccb.csio), 1, NULL, 
-		 CAM_DEV_QFRZDIS, MSG_SIMPLE_Q_TAG, NULL, 0, 
-		 sizeof(env->ccb.csio.sense_data), 0, 30*1000);
-
-  /* Initialize my_scsi_cdb as a Mode Select(6) */
-  CDIO_MMC_SET_COMMAND(env->ccb.csio.cdb_io.cdb_bytes, 
-		       CDIO_MMC_GPCMD_READ_SUBCHANNEL);
-  env->ccb.csio.cdb_io.cdb_bytes[1] = 0x0;  
-  env->ccb.csio.cdb_io.cdb_bytes[2] = 0x40;
-  env->ccb.csio.cdb_io.cdb_bytes[3] = CDIO_SUBCHANNEL_MEDIA_CATALOG;
-  env->ccb.csio.cdb_io.cdb_bytes[4] = 0;    /* Not used */
-  env->ccb.csio.cdb_io.cdb_bytes[5] = 0;    /* Not used */
-  env->ccb.csio.cdb_io.cdb_bytes[6] = 0;    /* Not used */
-  env->ccb.csio.cdb_io.cdb_bytes[7] = 0;    /* Not used */
-  env->ccb.csio.cdb_io.cdb_bytes[8] = 28; 
-  env->ccb.csio.cdb_io.cdb_bytes[9] = 0;    /* Not used */
-  
-  /* suc.suc_timeout = 500; */
-  env->ccb.csio.ccb_h.flags = CAM_DIR_OUT;
-  env->ccb.csio.data_ptr  = buf;
-  env->ccb.csio.dxfer_len = sizeof(buf);
-
-  rc =  _scsi_cmd (env);
-
-  if(rc == 0) {
+  i_status = scsi_mmc_run_cmd_freebsd_cam(p_env, DEFAULT_TIMEOUT_SECS,
+					  scsi_mmc_get_cmd_len(cdb.field[0]), 
+					  &cdb, SCSI_MMC_DATA_READ, 
+					  sizeof(buf), buf);
+  if(i_status == 0) {
     return strdup(&buf[9]);
   }
   return NULL;
@@ -165,63 +189,71 @@ get_drive_mcn_freebsd_cam (img_private_t *env)
 /*!
   Return the the kind of drive capabilities of device.
 
-  Note: string is malloc'd so caller should free() then returned
-  string when done with it.
-
  */
-static cdio_drive_cap_t
-get_drive_cap_freebsd_cam (img_private_t *env,
-			   /*out*/ cdio_drive_read_cap_t  *p_read_cap,
-			   /*out*/ cdio_drive_write_cap_t *p_write_cap,
-			   /*out*/ cdio_drive_misc_cap_t  *p_misc_cap)
+void
+get_drive_cap_freebsd_cam (const _img_private_t *p_env,
+			   cdio_drive_read_cap_t  *p_read_cap,
+			   cdio_drive_write_cap_t *p_write_cap,
+			   cdio_drive_misc_cap_t  *p_misc_cap)
 {
-  int32_t i_drivetype = 0;
-  uint8_t buf[192] = { 0, };
-  int rc;
-  
-  memset(&env->ccb, 0, sizeof(env->ccb));
+  scsi_mmc_cdb_t cdb = {{0, }};
+  uint8_t  buf[256] = { 0, };
+  int      i_status;
 
-  env->ccb.ccb_h.path_id    = env->cam->path_id;
-  env->ccb.ccb_h.target_id  = env->cam->target_id;
-  env->ccb.ccb_h.target_lun = env->cam->target_lun;
-  cam_fill_csio (&(env->ccb.csio), 1, NULL, 
-		 CAM_DEV_QFRZDIS, MSG_SIMPLE_Q_TAG, NULL, 0, 
-		 sizeof(env->ccb.csio.sense_data), 0, 30*1000);
+  CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_MODE_SENSE_10);
+  cdb.field[1]  = 0x0;
+  cdb.field[2]  = CDIO_MMC_ALL_PAGES;
+  cdb.field[7]  = 0x01;
+  cdb.field[8]  = 0x00; 
 
-  /* Initialize my_scsi_cdb as a Mode Select(6) */
-  CDIO_MMC_SET_COMMAND(env->ccb.csio.cdb_io.cdb_bytes, 
-		       CDIO_MMC_GPCMD_MODE_SENSE6);
-  env->ccb.csio.cdb_io.cdb_bytes[1] = 0x0;  
-                                      /* use ALL_PAGES?*/
-  env->ccb.csio.cdb_io.cdb_bytes[2] = CDIO_MMC_CAPABILITIES_PAGE; 
-  env->ccb.csio.cdb_io.cdb_bytes[3] = 0;    /* Not used */
-  env->ccb.csio.cdb_io.cdb_bytes[4] = 128; 
-  env->ccb.csio.cdb_io.cdb_bytes[5] = 0;    /* Not used */
-  
-  /* suc.suc_timeout = 500; */
-  env->ccb.csio.ccb_h.flags = CAM_DIR_OUT;
-  env->ccb.csio.data_ptr  = buf;
-  env->ccb.csio.dxfer_len = sizeof(buf);
+  i_status = scsi_mmc_run_cmd_freebsd_cam(p_env, DEFAULT_TIMEOUT_SECS, 
+					  scsi_mmc_get_cmd_len(cdb.field[0]),
+					  &cdb, SCSI_MMC_DATA_READ, 
+					  sizeof(buf), buf);
+  if (0 == i_status) {
+    uint8_t *p;
+    int lenData  = ((unsigned int)buf[0] << 8) + buf[1];
+    uint8_t *pMax = buf + 256;
 
-  rc =  _scsi_cmd (env);
-
-  if(rc == 0) {
-    unsigned int n=buf[3]+4;
     *p_read_cap  = 0;
     *p_write_cap = 0;
     *p_misc_cap  = 0;
-    scsi_mmc_get_drive_cap(&(buf[n], p_read_cap, p_write_cap, p_misc_cap));
+
+    /* set to first sense mask, and then walk through the masks */
+    p = buf + 8;
+    while( (p < &(buf[2+lenData])) && (p < pMax) )       {
+      uint8_t which;
+      
+      which = p[0] & 0x3F;
+      switch( which )
+	{
+	case CDIO_MMC_AUDIO_CTL_PAGE:
+	case CDIO_MMC_R_W_ERROR_PAGE:
+	case CDIO_MMC_CDR_PARMS_PAGE:
+	  /* Don't handle these yet. */
+	  break;
+	case CDIO_MMC_CAPABILITIES_PAGE:
+	  scsi_mmc_get_drive_cap(p, p_read_cap, p_write_cap, p_misc_cap);
+	  break;
+	default: ;
+	}
+      p += (p[1] + 2);
+    }
   } else {
-    *p_read_cap  = CDIO_DRIVE_CAP_ERROR;
-    *p_write_cap = CDIO_DRIVE_CAP_ERROR;
-    *p_misc_cap  = CDIO_DRIVE_CAP_ERROR;
+    cdio_info("error in aspi USCSICMD MODE_SELECT");
+    *p_read_cap  = CDIO_DRIVE_CAP_UNKNOWN;
+    *p_write_cap = CDIO_DRIVE_CAP_UNKNOWN;
+    *p_misc_cap  = CDIO_DRIVE_CAP_UNKNOWN;
   }
 }
+
 #endif
 
-static int
-_set_bsize (_img_private_t *env, unsigned int bsize)
+static int 
+_set_bsize (_img_private_t *p_env, unsigned int bsize)
 {
+  scsi_mmc_cdb_t cdb = {{0, }};
+
   struct
   {
     uint8_t reserved1;
@@ -238,145 +270,126 @@ _set_bsize (_img_private_t *env, unsigned int bsize)
     uint8_t block_length_lo;
   } mh;
 
-  memset(&env->ccb, 0, sizeof(env->ccb));
   memset (&mh, 0, sizeof (mh));
-
-  env->ccb.ccb_h.path_id    = env->cam->path_id;
-  env->ccb.ccb_h.target_id  = env->cam->target_id;
-  env->ccb.ccb_h.target_lun = env->cam->target_lun;
-  cam_fill_csio (&(env->ccb.csio), 1, NULL, 
-		 CAM_DEV_QFRZDIS, MSG_SIMPLE_Q_TAG, NULL, 0, 
-		 sizeof(env->ccb.csio.sense_data), 0, 30*1000);
-  env->ccb.csio.cdb_len = 4+1;
-  
-  CDIO_MMC_SET_COMMAND(env->ccb.csio.cdb_io.cdb_bytes, 
-		       CDIO_MMC_GPCMD_MODE_SELECT_6);
-  env->ccb.csio.cdb_io.cdb_bytes[1] = 1 << 4;
-  env->ccb.csio.cdb_io.cdb_bytes[4] = 12;
-  
-  env->ccb.csio.data_ptr = (u_char *)&mh;
-  env->ccb.csio.dxfer_len = sizeof (mh);;
-  
-  /* suc.suc_timeout = 500; */
-  env->ccb.csio.ccb_h.flags = CAM_DIR_OUT;
-  
   mh.block_desc_length = 0x08;
   mh.block_length_hi   = (bsize >> 16) & 0xff;
-  mh.block_length_med  = (bsize >> 8) & 0xff;
-  mh.block_length_lo   = (bsize >> 0) & 0xff;
+  mh.block_length_med  = (bsize >>  8) & 0xff;
+  mh.block_length_lo   = (bsize >>  0) & 0xff;
+
+  memset (&cdb, 0, sizeof (cdb));
   
-  return _scsi_cmd (env);
+  CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_MODE_SELECT_6);
+
+  cdb.field[1] = 1 << 4;
+  cdb.field[4] = 12;
+  
+  return scsi_mmc_run_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_SECS,
+				       scsi_mmc_get_cmd_len(cdb.field[0]), 
+				       &cdb, SCSI_MMC_DATA_WRITE, 
+				       sizeof(mh), &mh);
 }
 
 int
-read_mode2_sector_freebsd_cam (_img_private_t *env, void *data, lsn_t lsn, 
+read_mode2_sector_freebsd_cam (_img_private_t *p_env, void *data, lsn_t lsn, 
 			       bool b_form2)
 {
   if ( b_form2 )
-    return read_mode2_sectors_freebsd_cam(env, data, lsn, 1);
+    return read_mode2_sectors_freebsd_cam(p_env, data, lsn, 1);
   else {
     /* Need to pick out the data portion from a mode2 form2 frame */
     char buf[M2RAW_SECTOR_SIZE] = { 0, };
-    int retval = read_mode2_sectors_freebsd_cam(env, buf, lsn, 1);
+    int retval = read_mode2_sectors_freebsd_cam(p_env, buf, lsn, 1);
     if ( retval ) return retval;
     memcpy (((char *)data), buf + CDIO_CD_SUBHEADER_SIZE, CDIO_CD_FRAMESIZE);
     return 0;
   }
 }
 
+/*!
+   Reads nblocks of mode2 sectors from cd device into data starting
+   from lsn.
+   Returns 0 if no error. 
+ */
 int
-read_mode2_sectors_freebsd_cam (_img_private_t *env, void *buf, lsn_t lsn, 
-				unsigned int nblocks)
+read_mode2_sectors_freebsd_cam (_img_private_t *p_env, void *p_buf, 
+				lsn_t lsn, unsigned int nblocks)
 {
-  int retval = 0;
+  scsi_mmc_cdb_t cdb = {{0, }};
+
   bool b_read_10 = false;
 
-  memset(&env->ccb,0,sizeof(env->ccb));
-
-  env->ccb.ccb_h.path_id    = env->cam->path_id;
-  env->ccb.ccb_h.target_id  = env->cam->target_id;
-  env->ccb.ccb_h.target_lun = env->cam->target_lun;
-  cam_fill_csio (&(env->ccb.csio), 1, NULL, 
-		 CAM_DEV_QFRZDIS, MSG_SIMPLE_Q_TAG, NULL, 0, 
-		 sizeof(env->ccb.csio.sense_data), 0, 30*1000);
-  env->ccb.csio.cdb_len = (b_read_10 ? 8 : 9) + 1;
-  
-  CDIO_MMC_SET_COMMAND(env->ccb.csio.cdb_io.cdb_bytes, b_read_10
+  CDIO_MMC_SET_COMMAND(p_env->ccb.csio.cdb_io.cdb_bytes, b_read_10
 		       ? CDIO_MMC_GPCMD_READ_10 : CDIO_MMC_GPCMD_READ_CD);
 
-  CDIO_MMC_SET_READ_LBA(env->ccb.csio.cdb_io.cdb_bytes, lsn);
-  CDIO_MMC_SET_READ_LENGTH(env->ccb.csio.cdb_io.cdb_bytes, nblocks);
+  CDIO_MMC_SET_READ_LBA(cdb.field, lsn);
+  CDIO_MMC_SET_READ_LENGTH(cdb.field, nblocks);
   
   if (!b_read_10) {
-    env->ccb.csio.cdb_io.cdb_bytes[1] = 0; /* sector size mode2 */
-    env->ccb.csio.cdb_io.cdb_bytes[9] = 0x58; /* 2336 mode2 mixed form */
+    cdb.field[1] = 0; /* sector size mode2 */
+    cdb.field[9] = 0x58; /* 2336 mode2 */
   }
 
-  env->ccb.csio.dxfer_len = M2RAW_SECTOR_SIZE * nblocks;
-  env->ccb.csio.data_ptr  = buf;
-  
-  /* suc.suc_timeout = 500; */
-  env->ccb.csio.ccb_h.flags = CAM_DIR_IN;
-  
-  if (b_read_10)
-    {
-      if ((retval = _set_bsize (env, M2RAW_SECTOR_SIZE)))
-	goto out;
-      
-      if ((retval = _scsi_cmd(env)))
-	{
-	  _set_bsize (env, CDIO_CD_FRAMESIZE);
-	  goto out;
-	}
-      retval = _set_bsize (env, CDIO_CD_FRAMESIZE);
-    }
-  else
-    retval = _scsi_cmd(env);
-  
- out:
-  return retval;
+  if (b_read_10) {
+    int retval;
+    
+    if ((retval = _set_bsize (p_env, M2RAW_SECTOR_SIZE)))
+      return retval;
+    
+    if ((retval = scsi_mmc_run_cmd_freebsd_cam (p_env, 0, 
+						scsi_mmc_get_cmd_len(cdb.field[0]), 
+						&cdb, 
+						SCSI_MMC_DATA_READ,
+						M2RAW_SECTOR_SIZE * nblocks, 
+						p_buf)))
+      {
+	_set_bsize (p_env, CDIO_CD_FRAMESIZE);
+	return retval;
+      }
+    
+    if ((retval = _set_bsize (p_env, CDIO_CD_FRAMESIZE)))
+      return retval;
+  } else
+    return scsi_mmc_run_cmd_freebsd_cam (p_env, 0, 
+					 scsi_mmc_get_cmd_len(cdb.field[0]), 
+					 &cdb, 
+					 SCSI_MMC_DATA_READ,
+					 M2RAW_SECTOR_SIZE * nblocks, p_buf);
+
+  return 0;
 }
 
 /*!
    Return the size of the CD in logical block address (LBA) units.
  */
 uint32_t
-stat_size_freebsd_cam (_img_private_t *env)
+stat_size_freebsd_cam (_img_private_t *p_env)
 {
+  scsi_mmc_cdb_t cdb = {{0, }};
   uint8_t buf[12] = { 0, };
 
   uint32_t retval;
+  int i_status;
 
-  memset(&env->ccb,0,sizeof(env->ccb));
-  env->ccb.ccb_h.path_id    = env->cam->path_id;
-  env->ccb.ccb_h.target_id  = env->cam->target_id;
-  env->ccb.ccb_h.target_lun = env->cam->target_lun;
-  cam_fill_csio (&(env->ccb.csio), 1, NULL, CAM_DEV_QFRZDIS, 
-		 MSG_SIMPLE_Q_TAG, NULL, 0, 
-		 sizeof(env->ccb.csio.sense_data), 0, 30*1000);
-  env->ccb.csio.cdb_len = 8+1;
-  
   /* Operation code */
-  CDIO_MMC_SET_COMMAND(env->ccb.csio.cdb_io.cdb_bytes, 
-		       CDIO_MMC_GPCMD_READ_TOC);
+  CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_TOC);
 
-  env->ccb.csio.cdb_io.cdb_bytes[1] = 0; /* lba; msf: 0x2 */
+  cdb.field[1] = 0; /* lba; msf: 0x2 */
 
   /* Format */
-  env->ccb.csio.cdb_io.cdb_bytes[2] = CDIO_MMC_READTOC_FMT_TOC;
+  cdb.field[2] = CDIO_MMC_READTOC_FMT_TOC;
 
-  CDIO_MMC_SET_START_TRACK(env->ccb.csio.cdb_io.cdb_bytes, 
-			   CDIO_CDROM_LEADOUT_TRACK);
+  CDIO_MMC_SET_START_TRACK(cdb.field, CDIO_CDROM_LEADOUT_TRACK);
 
-  env->ccb.csio.cdb_io.cdb_bytes[8] = 12; /* ? */
+  CDIO_MMC_SET_READ_LENGTH(cdb.field, sizeof(buf));
   
-  env->ccb.csio.data_ptr = buf;
-  env->ccb.csio.dxfer_len = sizeof (buf);
+  p_env->ccb.csio.data_ptr = buf;
+  p_env->ccb.csio.dxfer_len = sizeof (buf);
 
-  /*suc.suc_timeout = 500; */
-  env->ccb.csio.ccb_h.flags = CAM_DIR_IN;
-
-  if (_scsi_cmd(env))
+  i_status = scsi_mmc_run_cmd_freebsd_cam(p_env, DEFAULT_TIMEOUT_SECS,
+					  scsi_mmc_get_cmd_len(cdb.field[0]), 
+					  &cdb, SCSI_MMC_DATA_READ, 
+					  sizeof(buf), buf);
+  if (0 != i_status)
     return 0;
 
   {
@@ -393,33 +406,38 @@ stat_size_freebsd_cam (_img_private_t *env)
   return retval;
 }
 
+/*!
+ * Eject using SCSI MMC commands. Return 0 if successful.
+ */
 int
-eject_media_freebsd_cam (_img_private_t *env) 
+eject_media_freebsd_cam (_img_private_t *p_env) 
 {
+  int i_status;
+  scsi_mmc_cdb_t cdb = {{0, }};
+  uint8_t buf[1];
   
-  if (env->gen.fd == -1)
-    return 2;
+  CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL);
+
+  i_status = scsi_mmc_run_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_SECS,
+					   scsi_mmc_get_cmd_len(cdb.field[0]), 
+					   &cdb, SCSI_MMC_DATA_WRITE, 0, &buf);
+  if (0 != i_status)
+    return i_status;
   
-  memset(&env->ccb,0,sizeof(env->ccb));
-  env->ccb.ccb_h.path_id    = env->cam->path_id;
-  env->ccb.ccb_h.target_id  = env->cam->target_id;
-  env->ccb.ccb_h.target_lun = env->cam->target_lun;
-  cam_fill_csio (&(env->ccb.csio), 1, NULL, CAM_DEV_QFRZDIS, 
-		 MSG_SIMPLE_Q_TAG, NULL, 0, sizeof(env->ccb.csio.sense_data), 
-		 0, 30*1000);
-  env->ccb.csio.cdb_len = 5+1;
+  cdb.field[4] = 1;
+  i_status = scsi_mmc_run_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_SECS,
+				 scsi_mmc_get_cmd_len(cdb.field[0]), &cdb, 
+				 SCSI_MMC_DATA_WRITE, 0, &buf);
+  if (0 != i_status)
+    return i_status;
   
-  CDIO_MMC_SET_COMMAND(env->ccb.csio.cdb_io.cdb_bytes, 
-		       CDIO_MMC_GPCMD_START_STOP);
-  env->ccb.csio.cdb_io.cdb_bytes[1] = 0x1;	/* immediate */
-  env->ccb.csio.cdb_io.cdb_bytes[4] = 0x2;	/* eject */
-  
-  env->ccb.csio.data_ptr = 0;
-  env->ccb.csio.dxfer_len = 0;
-  
-  /* suc.suc_timeout = 500; */
-  env->ccb.csio.ccb_h.flags = CAM_DIR_IN;
-  return(_scsi_cmd(env));
+  CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_START_STOP);
+  cdb.field[4] = 2; /* eject */
+
+  return scsi_mmc_run_cmd_freebsd_cam (p_env, DEFAULT_TIMEOUT_SECS,
+				       scsi_mmc_get_cmd_len(cdb.field[0]), 
+				       &cdb, 
+				       SCSI_MMC_DATA_WRITE, 0, &buf);
 }
 
 #endif /* HAVE_FREEBSD_CDROM */
diff --git a/lib/MSWindows/aspi32.c b/lib/MSWindows/aspi32.c
index 3f00598d..fbe91905 100644
--- a/lib/MSWindows/aspi32.c
+++ b/lib/MSWindows/aspi32.c
@@ -1,5 +1,5 @@
 /*
-    $Id: aspi32.c,v 1.32 2004/07/23 10:59:15 rocky Exp $
+    $Id: aspi32.c,v 1.33 2004/07/24 05:42:09 rocky Exp $
 
     Copyright (C) 2004 Rocky Bernstein <rocky@panix.com>
 
@@ -27,7 +27,7 @@
 # include "config.h"
 #endif
 
-static const char _rcsid[] = "$Id: aspi32.c,v 1.32 2004/07/23 10:59:15 rocky Exp $";
+static const char _rcsid[] = "$Id: aspi32.c,v 1.33 2004/07/24 05:42:09 rocky Exp $";
 
 #include <cdio/cdio.h>
 #include <cdio/sector.h>
@@ -770,7 +770,7 @@ get_drive_cap_aspi (const _img_private_t *p_env,
 }
 
 /*!
-  Return the the kind of drive capabilities of device.
+  Return the media catalog number MCN.
 
   Note: string is malloc'd so caller should free() then returned
   string when done with it.
diff --git a/lib/_cdio_linux.c b/lib/_cdio_linux.c
index e817a255..a9478533 100644
--- a/lib/_cdio_linux.c
+++ b/lib/_cdio_linux.c
@@ -1,5 +1,5 @@
 /*
-    $Id: _cdio_linux.c,v 1.74 2004/07/22 11:00:59 rocky Exp $
+    $Id: _cdio_linux.c,v 1.75 2004/07/24 05:42:09 rocky Exp $
 
     Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>
     Copyright (C) 2002, 2003, 2004 Rocky Bernstein <rocky@panix.com>
@@ -27,7 +27,7 @@
 # include "config.h"
 #endif
 
-static const char _rcsid[] = "$Id: _cdio_linux.c,v 1.74 2004/07/22 11:00:59 rocky Exp $";
+static const char _rcsid[] = "$Id: _cdio_linux.c,v 1.75 2004/07/24 05:42:09 rocky Exp $";
 
 #include <string.h>
 
@@ -286,7 +286,7 @@ scsi_mmc_run_cmd_linux( const void *p_user_data, int i_timeout,
   memcpy(&cgc.cmd, p_cdb, i_cdb);
   cgc.buflen = i_buf;
   cgc.buffer = p_buf;
-  cgc.data_direction = SCSI_MMC_DATA_READ == cgc.data_direction 
+  cgc.data_direction = (SCSI_MMC_DATA_READ == cgc.data_direction)
     ? CGC_DATA_READ : CGC_DATA_WRITE;
 
 #ifdef HAVE_LINUX_CDROM_TIMEOUT
@@ -300,7 +300,7 @@ scsi_mmc_run_cmd_linux( const void *p_user_data, int i_timeout,
 static int 
 _set_bsize (_img_private_t *p_env, unsigned int bsize)
 {
-  scsi_mmc_cdb_t cdb;
+  scsi_mmc_cdb_t cdb = {{0, }};
 
   struct
   {
@@ -324,8 +324,6 @@ _set_bsize (_img_private_t *p_env, unsigned int bsize)
   mh.block_length_med  = (bsize >>  8) & 0xff;
   mh.block_length_lo   = (bsize >>  0) & 0xff;
 
-  memset (&cdb, 0, sizeof (cdb));
-  
   CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_MODE_SELECT_6);
 
   cdb.field[1] = 1 << 4;
@@ -343,9 +341,7 @@ static int
 _read_sectors_mmc (_img_private_t *p_env, void *p_buf, lba_t lba, 
 		   int sector_type, unsigned int nblocks)
 {
-  scsi_mmc_cdb_t cdb;
-
-  memset (&cdb, 0, sizeof (scsi_mmc_cdb_t));
+  scsi_mmc_cdb_t cdb = {{0, }};
 
   CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_CD);
   CDIO_MMC_SET_READ_TYPE  (cdb.field, sector_type);
@@ -380,9 +376,7 @@ static int
 _read_mode2_sectors_mmc (_img_private_t *p_env, void *p_buf, lba_t lba, 
 			 unsigned int nblocks, bool b_read_10)
 {
-  scsi_mmc_cdb_t cdb;
-
-  memset (&cdb, 0, sizeof (scsi_mmc_cdb_t));
+  scsi_mmc_cdb_t cdb = {{0, }};
 
   CDIO_MMC_SET_COMMAND(cdb.field, b_read_10 
 		       ? CDIO_MMC_GPCMD_READ_10 : CDIO_MMC_GPCMD_READ_CD);
@@ -772,12 +766,11 @@ static bool
 _init_cdtext_linux (_img_private_t *p_env)
 {
 
-  scsi_mmc_cdb_t cdb;
+  scsi_mmc_cdb_t cdb = {{0, }};
+
   unsigned char wdata[2000]= {0, };  /* Data read from device starts here */
   int status;
 
-  memset (&cdb, 0, sizeof (scsi_mmc_cdb_t));
-
   /* Operation code */
   CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_READ_TOC); 
 
@@ -825,14 +818,14 @@ _get_cdtext_linux (void *p_user_data, track_t i_track)
 
 }
 
-/*
- * Eject using SCSI MMC commands. Return 1 if successful, 0 otherwise.
+/*!
+ * Eject using SCSI MMC commands. Return 0 if successful.
  */
 static int 
 _eject_media_mmc(_img_private_t *p_env)
 {
   int i_status;
-  scsi_mmc_cdb_t cdb;
+  scsi_mmc_cdb_t cdb = {{0, }};
   uint8_t buf[1];
   
   CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL);