diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/ata/ata_all.c ./sys/cam/ata/ata_all.c
--- /storage/FreeBSD/head/sys/cam/ata/ata_all.c	2009-09-28 01:21:58.000000000 +0300
+++ ./sys/cam/ata/ata_all.c	2009-10-14 15:26:15.000000000 +0300
@@ -98,6 +98,11 @@ ata_28bit_cmd(struct ccb_ataio *ataio, u
 {
 	bzero(&ataio->cmd, sizeof(ataio->cmd));
 	ataio->cmd.flags = 0;
+	if (cmd == ATA_READ_DMA ||
+	    cmd == ATA_READ_DMA_QUEUED ||
+	    cmd == ATA_WRITE_DMA ||
+	    cmd == ATA_WRITE_DMA_QUEUED)
+		ataio->cmd.flags |= CAM_ATAIO_DMA;
 	ataio->cmd.command = cmd;
 	ataio->cmd.features = features;
 	ataio->cmd.lba_low = lba;
@@ -113,6 +118,11 @@ ata_48bit_cmd(struct ccb_ataio *ataio, u
 {
 	bzero(&ataio->cmd, sizeof(ataio->cmd));
 	ataio->cmd.flags = CAM_ATAIO_48BIT;
+	if (cmd == ATA_READ_DMA48 ||
+	    cmd == ATA_READ_DMA_QUEUED48 ||
+	    cmd == ATA_WRITE_DMA48 ||
+	    cmd == ATA_WRITE_DMA_QUEUED48)
+		ataio->cmd.flags |= CAM_ATAIO_DMA;
 	ataio->cmd.command = cmd;
 	ataio->cmd.features = features;
 	ataio->cmd.lba_low = lba;
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/ata/ata_all.h ./sys/cam/ata/ata_all.h
--- /storage/FreeBSD/head/sys/cam/ata/ata_all.h	2009-08-30 19:31:23.000000000 +0300
+++ ./sys/cam/ata/ata_all.h	2009-10-14 15:26:15.000000000 +0300
@@ -41,6 +41,7 @@ struct ata_cmd {
 #define		CAM_ATAIO_FPDMA		0x02	/* FPDMA command */
 #define		CAM_ATAIO_CONTROL	0x04	/* Control, not a command */
 #define		CAM_ATAIO_NEEDRESULT	0x08	/* Request requires result. */
+#define		CAM_ATAIO_DMA		0x10	/* DMA command */
 
 	u_int8_t	command;
 	u_int8_t	features;
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/ata/ata_da.c ./sys/cam/ata/ata_da.c
--- /storage/FreeBSD/head/sys/cam/ata/ata_da.c	2009-10-23 11:27:54.000000000 +0300
+++ ./sys/cam/ata/ata_da.c	2009-10-23 12:05:07.000000000 +0300
@@ -743,7 +743,7 @@ adaregister(struct cam_periph *periph, v
 	 * the end of probe.
 	 */
 	cam_periph_acquire(periph);
-	xpt_schedule(periph, /*priority*/5);
+	xpt_schedule(periph, CAM_PRIORITY_DEV);
 
 	/*
 	 * Schedule a periodic event to occasionally send an
@@ -1127,6 +1127,9 @@ adashutdown(void * arg, int howto)
 	TAILQ_FOREACH(periph, &adadriver.units, unit_links) {
 		union ccb ccb;
 
+		/* If we paniced with lock held - not recurse here. */
+		if (cam_periph_owned(periph))
+			continue;
 		cam_periph_lock(periph);
 		softc = (struct ada_softc *)periph->softc;
 		/*
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/ata/ata_pmp.c ./sys/cam/ata/ata_pmp.c
--- /storage/FreeBSD/head/sys/cam/ata/ata_pmp.c	2009-10-23 17:14:32.000000000 +0300
+++ ./sys/cam/ata/ata_pmp.c	2009-10-23 18:06:24.000000000 +0300
@@ -299,7 +299,7 @@ pmpasync(void *callback_arg, u_int32_t c
 			softc->found = 0; /* We have to reset everything. */
 		softc->state = PMP_STATE_PORTS;
 		cam_periph_acquire(periph);
-		xpt_schedule(periph, CAM_PRIORITY_DEV);
+		xpt_schedule(periph, CAM_PRIORITY_BUS);
 		break;
 	default:
 		cam_periph_async(periph, code, path, arg);
@@ -395,7 +395,7 @@ pmpregister(struct cam_periph *periph, v
 	 * the end of probe.
 	 */
 	(void)cam_periph_acquire(periph);
-	xpt_schedule(periph, CAM_PRIORITY_DEV);
+	xpt_schedule(periph, CAM_PRIORITY_BUS);
 
 	return(CAM_REQ_CMP);
 }
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/ata/ata_xpt.c ./sys/cam/ata/ata_xpt.c
--- /storage/FreeBSD/head/sys/cam/ata/ata_xpt.c	2009-10-23 17:14:32.000000000 +0300
+++ ./sys/cam/ata/ata_xpt.c	2009-10-23 17:13:12.000000000 +0300
@@ -179,10 +179,12 @@ static void	 ata_dev_async(u_int32_t asy
 				struct cam_ed *device,
 				void *async_arg);
 static void	 ata_action(union ccb *start_ccb);
+static void	 ata_done(union ccb *done_ccb);
 
 static struct xpt_xport ata_xport = {
 	.alloc_device = ata_alloc_device,
 	.action = ata_action,
+	.done = ata_done,
 	.async = ata_dev_async,
 };
 
@@ -272,7 +274,7 @@ probeschedule(struct cam_periph *periph)
 	else
 		softc->flags &= ~PROBE_NO_ANNOUNCE;
 
-	xpt_schedule(periph, ccb->ccb_h.pinfo.priority);
+	xpt_schedule(periph, CAM_PRIORITY_HOST);
 }
 
 static void
@@ -1243,6 +1245,36 @@ ata_action(union ccb *start_ccb)
 }
 
 static void
+ata_done(union ccb *done_ccb)
+{
+	struct	cam_path *path;
+	union	ccb *work_ccb;
+
+	switch (done_ccb->ccb_h.status & CAM_STATUS_MASK) {
+	case CAM_CMD_TIMEOUT:
+	case CAM_UNCOR_PARITY:
+		work_ccb = xpt_alloc_ccb_nowait();
+		if (work_ccb == NULL)
+			break;
+		if (xpt_create_path(&path, xpt_periph, done_ccb->ccb_h.path_id,
+		    CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
+			xpt_free_ccb(work_ccb);
+			break;
+		}
+		xpt_setup_ccb(&work_ccb->ccb_h, path, CAM_PRIORITY_NORMAL);
+		work_ccb->ccb_h.func_code = XPT_RESET_BUS;
+		work_ccb->ccb_h.cbfcnp = NULL;
+		CAM_DEBUG(path, CAM_DEBUG_SUBTRACE, ("Resetting Bus\n"));
+		xpt_action(work_ccb);
+		xpt_free_ccb(work_ccb);
+		break;
+	}	
+	
+	/* Call default done handler. */
+	xpt_done_default(done_ccb);
+}
+
+static void
 scsi_set_transfer_settings(struct ccb_trans_settings *cts, struct cam_ed *device,
 			   int async_update)
 {
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/cam.h ./sys/cam/cam.h
--- /storage/FreeBSD/head/sys/cam/cam.h	2009-10-23 11:27:54.000000000 +0300
+++ ./sys/cam/cam.h	2009-10-23 12:05:07.000000000 +0300
@@ -66,8 +66,11 @@ struct cam_periph;
  */
 typedef struct {
 	u_int32_t priority;
-#define CAM_PRIORITY_DEV	0
-#define CAM_PRIORITY_NORMAL	1
+#define CAM_PRIORITY_HOST	100
+#define CAM_PRIORITY_BUS	200
+#define CAM_PRIORITY_DEV	300
+#define CAM_PRIORITY_HIGH	400
+#define CAM_PRIORITY_NORMAL	500
 #define CAM_PRIORITY_NONE	(u_int32_t)-1
 	u_int32_t generation;
 	int       index;
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/cam_periph.h ./sys/cam/cam_periph.h
--- /storage/FreeBSD/head/sys/cam/cam_periph.h	2009-06-23 19:31:32.000000000 +0300
+++ ./sys/cam/cam_periph.h	2009-10-14 15:26:16.000000000 +0300
@@ -177,17 +177,9 @@ void		cam_periph_freeze_after_event(stru
 int		cam_periph_error(union ccb *ccb, cam_flags camflags,
 				 u_int32_t sense_flags, union ccb *save_ccb);
 
-static __inline void
-cam_periph_lock(struct cam_periph *periph)
-{
-	mtx_lock(periph->sim->mtx);
-}
-
-static __inline void
-cam_periph_unlock(struct cam_periph *periph)
-{
-	mtx_unlock(periph->sim->mtx);
-}
+#define cam_periph_lock(periph)		mtx_lock((periph)->sim->mtx)
+#define cam_periph_unlock(periph)	mtx_unlock((periph)->sim->mtx)
+#define cam_periph_owned(periph)	mtx_owned((periph)->sim->mtx)
 
 #endif /* _KERNEL */
 #endif /* _CAM_CAM_PERIPH_H */
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/cam_sim.h ./sys/cam/cam_sim.h
--- /storage/FreeBSD/head/sys/cam/cam_sim.h	2009-03-14 17:09:14.000000000 +0200
+++ ./sys/cam/cam_sim.h	2009-10-14 15:26:16.000000000 +0300
@@ -94,23 +94,13 @@ struct cam_sim {
 	const char		*sim_name;
 	void			*softc;
 	struct mtx		*mtx;
-	TAILQ_HEAD(, ccb_hdr)	sim_doneq;
+	struct cam_devq 	*devq;	/* Device Queue to use for this SIM */
 	TAILQ_ENTRY(cam_sim)	links;
 	u_int32_t		path_id;/* The Boot device may set this to 0? */
 	u_int32_t		unit_number;
 	u_int32_t		bus_id;
 	int			max_tagged_dev_openings;
 	int			max_dev_openings;
-	u_int32_t		flags;
-#define	CAM_SIM_REL_TIMEOUT_PENDING	0x01
-#define	CAM_SIM_MPSAFE			0x02
-#define CAM_SIM_ON_DONEQ		0x04
-	struct callout		callout;
-	struct cam_devq 	*devq;	/* Device Queue to use for this SIM */
-	int			refcount; /* References to the SIM. */
-
-	/* "Pool" of inactive ccbs managed by xpt_get_ccb and xpt_release_ccb */
-	SLIST_HEAD(,ccb_hdr)	ccb_freeq;
 	/*
 	 * Maximum size of ccb pool.  Modified as devices are added/removed
 	 * or have their * opening counts changed.
@@ -118,7 +108,15 @@ struct cam_sim {
 	u_int			max_ccbs;
 	/* Current count of allocated ccbs */
 	u_int			ccb_count;
-
+	struct callout		callout;
+	u_int32_t		flags;
+#define	CAM_SIM_REL_TIMEOUT_PENDING	0x01
+#define	CAM_SIM_MPSAFE			0x02
+#define CAM_SIM_ON_DONEQ		0x04
+	int			refcount; /* References to the SIM. */
+	TAILQ_HEAD(, ccb_hdr)	sim_doneq; /* Completed requests queue. */
+	/* "Pool" of inactive ccbs managed by xpt_get_ccb and xpt_release_ccb */
+	SLIST_HEAD(, ccb_hdr)	ccb_freeq;
 };
 
 #define CAM_SIM_LOCK(sim)	mtx_lock((sim)->mtx);
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/cam_xpt.c ./sys/cam/cam_xpt.c
--- /storage/FreeBSD/head/sys/cam/cam_xpt.c	2009-10-23 17:14:32.000000000 +0300
+++ ./sys/cam/cam_xpt.c	2009-10-23 17:13:13.000000000 +0300
@@ -812,7 +812,7 @@ xpt_scanner_thread(void *dummy)
 			else
 				ccb->ccb_h.func_code = XPT_SCAN_LUN;
 			ccb->ccb_h.cbfcnp = xptdone;
-			xpt_setup_ccb(&ccb->ccb_h, ccb->ccb_h.path, CAM_PRIORITY_NORMAL);
+			xpt_setup_ccb(&ccb->ccb_h, ccb->ccb_h.path, CAM_PRIORITY_BUS);
 			cam_periph_runccb(ccb, NULL, 0, 0, NULL);
 			xpt_free_path(ccb->ccb_h.path);
 			xpt_free_ccb(ccb);
@@ -2989,6 +2989,13 @@ xpt_action_default(union ccb *start_ccb)
 }
 
 void
+xpt_done_default(union ccb *done_ccb)
+{
+	/* Call the peripheral driver's callback */
+	(*done_ccb->ccb_h.cbfcnp)(done_ccb->ccb_h.path->periph, done_ccb);
+}
+
+void
 xpt_polled_action(union ccb *start_ccb)
 {
 	u_int32_t timeout;
@@ -3729,6 +3736,7 @@ xpt_release_ccb(union ccb *free_ccb)
 static struct xpt_xport xport_default = {
 	.alloc_device = xpt_alloc_device_default,
 	.action = xpt_action_default,
+	.done = xpt_done_default,
 	.async = xpt_dev_async_default,
 };
 
@@ -4808,7 +4816,7 @@ xpt_register_async(int event, ac_callbac
 		xptpath = 1;
 	}
 
-	xpt_setup_ccb(&csa.ccb_h, path, /*priority*/5);
+	xpt_setup_ccb(&csa.ccb_h, path, CAM_PRIORITY_NORMAL);
 	csa.ccb_h.func_code = XPT_SASYNC_CB;
 	csa.event_enable = event;
 	csa.callback = cbfunc;
@@ -4999,8 +5007,8 @@ camisr_runqueue(void *V_queue)
 			xpt_run_dev_sendq(ccb_h->path->bus);
 		}
 
-		/* Call the peripheral driver's callback */
-		(*ccb_h->cbfcnp)(ccb_h->path->periph, (union ccb *)ccb_h);
+		/* Call the XPT's callback */
+		(*(ccb_h->path->bus->xport->done))((union ccb *)ccb_h);
 	}
 }
 
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/cam_xpt.h ./sys/cam/cam_xpt.h
--- /storage/FreeBSD/head/sys/cam/cam_xpt.h	2009-07-13 09:04:53.000000000 +0300
+++ ./sys/cam/cam_xpt.h	2009-10-14 15:26:16.000000000 +0300
@@ -87,6 +87,7 @@ SLIST_HEAD(periph_list, cam_periph);
 
 void			xpt_action(union ccb *new_ccb);
 void			xpt_action_default(union ccb *new_ccb);
+void			xpt_done_default(union ccb *new_ccb);
 void			xpt_setup_ccb(struct ccb_hdr *ccb_h,
 				      struct cam_path *path,
 				      u_int32_t priority);
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/cam_xpt_internal.h ./sys/cam/cam_xpt_internal.h
--- /storage/FreeBSD/head/sys/cam/cam_xpt_internal.h	2009-10-21 18:27:48.000000000 +0300
+++ ./sys/cam/cam_xpt_internal.h	2009-10-22 10:32:59.000000000 +0300
@@ -41,6 +41,7 @@ typedef void (*xpt_release_device_func)(
 				        struct cam_et *target,
 				        struct cam_ed *device);
 typedef void (*xpt_action_func)(union ccb *start_ccb);
+typedef void (*xpt_done_func)(union ccb *done_ccb);
 typedef void (*xpt_dev_async_func)(u_int32_t async_code,
 				   struct cam_eb *bus,
 				   struct cam_et *target,
@@ -53,6 +54,7 @@ struct xpt_xport {
 	xpt_alloc_device_func	alloc_device;
 	xpt_release_device_func	reldev;
 	xpt_action_func		action;
+	xpt_done_func		done;
 	xpt_dev_async_func	async;
 	xpt_announce_periph_func announce;
 };
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/scsi/scsi_cd.c ./sys/cam/scsi/scsi_cd.c
--- /storage/FreeBSD/head/sys/cam/scsi/scsi_cd.c	2009-10-23 11:27:54.000000000 +0300
+++ ./sys/cam/scsi/scsi_cd.c	2009-10-23 12:05:08.000000000 +0300
@@ -965,9 +965,9 @@ cdregisterexit:
 	(void)cam_periph_hold(periph, PRIBIO);
 
 	if ((softc->flags & CD_FLAG_CHANGER) == 0)
-		xpt_schedule(periph, /*priority*/5);
+		xpt_schedule(periph, CAM_PRIORITY_DEV);
 	else
-		cdschedule(periph, /*priority*/ 5);
+		cdschedule(periph, CAM_PRIORITY_DEV);
 
 	return(CAM_REQ_CMP);
 }
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/scsi/scsi_ch.c ./sys/cam/scsi/scsi_ch.c
--- /storage/FreeBSD/head/sys/cam/scsi/scsi_ch.c	2009-10-23 11:27:54.000000000 +0300
+++ ./sys/cam/scsi/scsi_ch.c	2009-10-23 12:05:08.000000000 +0300
@@ -376,7 +376,7 @@ chregister(struct cam_periph *periph, vo
 	 * This first call can't block
 	 */
 	(void)cam_periph_hold(periph, PRIBIO);
-	xpt_schedule(periph, /*priority*/5);
+	xpt_schedule(periph, CAM_PRIORITY_DEV);
 
 	return(CAM_REQ_CMP);
 }
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/scsi/scsi_da.c ./sys/cam/scsi/scsi_da.c
--- /storage/FreeBSD/head/sys/cam/scsi/scsi_da.c	2009-10-23 11:27:54.000000000 +0300
+++ ./sys/cam/scsi/scsi_da.c	2009-10-23 17:19:06.000000000 +0300
@@ -1275,7 +1275,7 @@ daregister(struct cam_periph *periph, vo
 	 * the end of probe.
 	 */
 	(void)cam_periph_hold(periph, PRIBIO);
-	xpt_schedule(periph, /*priority*/5);
+	xpt_schedule(periph, CAM_PRIORITY_DEV);
 
 	/*
 	 * Schedule a periodic event to occasionally send an
@@ -1491,8 +1491,10 @@ dadone(struct cam_periph *periph, union 
 {
 	struct da_softc *softc;
 	struct ccb_scsiio *csio;
+	u_int32_t  priority;
 
 	softc = (struct da_softc *)periph->softc;
+	priority = done_ccb->ccb_h.pinfo.priority;
 	csio = &done_ccb->csio;
 	switch (csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK) {
 	case DA_CCB_BUFFER_IO:
@@ -1610,7 +1612,7 @@ dadone(struct cam_periph *periph, union 
 					softc->state = DA_STATE_PROBE2;
 					free(rdcap, M_SCSIDA);
 					xpt_release_ccb(done_ccb);
-					xpt_schedule(periph, /*priority*/5);
+					xpt_schedule(periph, priority);
 					return;
 				}
 			} else {
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/scsi/scsi_low.c ./sys/cam/scsi/scsi_low.c
--- /storage/FreeBSD/head/sys/cam/scsi/scsi_low.c	2009-10-22 10:34:23.000000000 +0300
+++ ./sys/cam/scsi/scsi_low.c	2009-10-22 10:32:59.000000000 +0300
@@ -979,7 +979,7 @@ scsi_low_rescan_bus_cam(slp)
 
 	ccb = xpt_alloc_ccb();
 	bzero(ccb, sizeof(union ccb));
-	xpt_setup_ccb(&ccb->ccb_h, path, 5);
+	xpt_setup_ccb(&ccb->ccb_h, path, CAM_PRIORITY_BUS);
 	ccb->ccb_h.func_code = XPT_SCAN_BUS;
 	ccb->ccb_h.cbfcnp = scsi_low_cam_rescan_callback;
 	ccb->crcn.flags = CAM_FLAG_NONE;
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/scsi/scsi_sg.c ./sys/cam/scsi/scsi_sg.c
--- /storage/FreeBSD/head/sys/cam/scsi/scsi_sg.c	2009-07-13 09:04:53.000000000 +0300
+++ ./sys/cam/scsi/scsi_sg.c	2009-10-14 15:26:17.000000000 +0300
@@ -510,7 +510,7 @@ sgioctl(struct cdev *dev, u_long cmd, ca
 			break;
 		}
 
-		ccb = cam_periph_getccb(periph, /*priority*/5);
+		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
 		csio = &ccb->csio;
 
 		error = copyin(req.cmdp, &csio->cdb_io.cdb_bytes,
@@ -729,7 +729,7 @@ sgwrite(struct cdev *dev, struct uio *ui
 
 	cam_periph_lock(periph);
 	sc = periph->softc;
-	xpt_setup_ccb(&ccb->ccb_h, periph->path, /*priority*/5);
+	xpt_setup_ccb(&ccb->ccb_h, periph->path, CAM_PRIORITY_NORMAL);
 	cam_fill_csio(csio,
 		      /*retries*/1,
 		      sgdone,
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/cam/scsi/scsi_xpt.c ./sys/cam/scsi/scsi_xpt.c
--- /storage/FreeBSD/head/sys/cam/scsi/scsi_xpt.c	2009-10-23 11:27:54.000000000 +0300
+++ ./sys/cam/scsi/scsi_xpt.c	2009-10-23 12:05:08.000000000 +0300
@@ -555,6 +555,7 @@ static void	 scsi_action(union ccb *star
 static struct xpt_xport scsi_xport = {
 	.alloc_device = scsi_alloc_device,
 	.action = scsi_action,
+	.done = xpt_done_default,
 	.async = scsi_dev_async,
 };
 
@@ -667,7 +668,7 @@ probeschedule(struct cam_periph *periph)
 	else
 		softc->flags &= ~PROBE_NO_ANNOUNCE;
 
-	xpt_schedule(periph, ccb->ccb_h.pinfo.priority);
+	xpt_schedule(periph, CAM_PRIORITY_HOST);
 }
 
 static void
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/conf/options ./sys/conf/options
--- /storage/FreeBSD/head/sys/conf/options	2009-10-22 10:34:23.000000000 +0300
+++ ./sys/conf/options	2009-10-22 10:32:59.000000000 +0300
@@ -350,6 +350,7 @@ ISCSI_INITIATOR_DEBUG	opt_iscsi_initiato
 # Options used in the 'ata' ATA/ATAPI driver
 ATA_STATIC_ID		opt_ata.h
 ATA_NOPCI		opt_ata.h
+ATA_CAM			opt_ata.h
 
 # Net stuff.
 ACCEPT_FILTER_DATA
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-all.c ./sys/dev/ata/ata-all.c
--- /storage/FreeBSD/head/sys/dev/ata/ata-all.c	2009-08-30 17:46:09.000000000 +0300
+++ ./sys/dev/ata/ata-all.c	2009-10-14 15:27:03.000000000 +0300
@@ -50,6 +50,16 @@ __FBSDID("$FreeBSD: head/sys/dev/ata/ata
 #include <dev/ata/ata-all.h>
 #include <ata_if.h>
 
+#ifdef ATA_CAM
+#include <cam/cam.h>
+#include <cam/cam_ccb.h>
+#include <cam/cam_sim.h>
+#include <cam/cam_xpt_sim.h>
+#include <cam/cam_xpt_periph.h>
+#include <cam/cam_debug.h>
+#endif
+
+#ifndef ATA_CAM
 /* device structure */
 static  d_ioctl_t       ata_ioctl;
 static struct cdevsw ata_cdevsw = {
@@ -58,14 +68,21 @@ static struct cdevsw ata_cdevsw = {
 	.d_ioctl =      ata_ioctl,
 	.d_name =       "ata",
 };
+#endif
 
 /* prototypes */
+#ifndef ATA_CAM
 static void ata_boot_attach(void);
 static device_t ata_add_child(device_t, struct ata_device *, int);
+#else
+static void ataaction(struct cam_sim *sim, union ccb *ccb);
+static void atapoll(struct cam_sim *sim);
+#endif
 static void ata_conn_event(void *, int);
 static void bswap(int8_t *, int);
 static void btrim(int8_t *, int);
 static void bpack(int8_t *, int8_t *, int);
+static void ata_interrupt_locked(void *data);
 
 /* global vars */
 MALLOC_DEFINE(M_ATA, "ata_generic", "ATA driver generic layer");
@@ -115,6 +132,9 @@ ata_attach(device_t dev)
 {
     struct ata_channel *ch = device_get_softc(dev);
     int error, rid;
+#ifdef ATA_CAM
+    struct cam_devq *devq;
+#endif
 
     /* check that we have a virgin channel to attach */
     if (ch->r_irq)
@@ -133,7 +153,9 @@ ata_attach(device_t dev)
     /* reset the controller HW, the channel and device(s) */
     while (ATA_LOCKING(dev, ATA_LF_LOCK) != ch->unit)
 	pause("ataatch", 1);
+#ifndef ATA_CAM
     ATA_RESET(dev);
+#endif
     ATA_LOCKING(dev, ATA_LF_UNLOCK);
 
     /* allocate DMA resources if DMA HW present*/
@@ -154,18 +176,61 @@ ata_attach(device_t dev)
 	return error;
     }
 
+#ifndef ATA_CAM
     /* probe and attach devices on this channel unless we are in early boot */
     if (!ata_delayed_attach)
 	ata_identify(dev);
-    return 0;
+    return (0);
+#else
+	mtx_lock(&ch->state_mtx);
+	/* Create the device queue for our SIM. */
+	devq = cam_simq_alloc(1);
+	if (devq == NULL) {
+		device_printf(dev, "Unable to allocate simq\n");
+		error = ENOMEM;
+		goto err1;
+	}
+	/* Construct SIM entry */
+	ch->sim = cam_sim_alloc(ataaction, atapoll, "ata", ch,
+	    device_get_unit(dev), &ch->state_mtx, 1, 0, devq);
+	if (ch->sim == NULL) {
+		device_printf(dev, "unable to allocate sim\n");
+		error = ENOMEM;
+		goto err2;
+	}
+	if (xpt_bus_register(ch->sim, dev, 0) != CAM_SUCCESS) {
+		device_printf(dev, "unable to register xpt bus\n");
+		error = ENXIO;
+		goto err2;
+	}
+	if (xpt_create_path(&ch->path, /*periph*/NULL, cam_sim_path(ch->sim),
+	    CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
+		device_printf(dev, "unable to create path\n");
+		error = ENXIO;
+		goto err3;
+	}
+	mtx_unlock(&ch->state_mtx);
+	return (0);
+
+err3:
+	xpt_bus_deregister(cam_sim_path(ch->sim));
+err2:
+	cam_sim_free(ch->sim, /*free_devq*/TRUE);
+err1:
+	bus_release_resource(dev, SYS_RES_IRQ, ATA_IRQ_RID, ch->r_irq);
+	mtx_unlock(&ch->state_mtx);
+	return (error);
+#endif
 }
 
 int
 ata_detach(device_t dev)
 {
     struct ata_channel *ch = device_get_softc(dev);
+#ifndef ATA_CAM
     device_t *children;
     int nchildren, i;
+#endif
 
     /* check that we have a valid channel to detach */
     if (!ch->r_irq)
@@ -176,6 +241,7 @@ ata_detach(device_t dev)
     ch->state |= ATA_STALL_QUEUE;
     mtx_unlock(&ch->state_mtx);
 
+#ifndef ATA_CAM
     /* detach & delete all children */
     if (!device_get_children(dev, &children, &nchildren)) {
 	for (i = 0; i < nchildren; i++)
@@ -183,8 +249,18 @@ ata_detach(device_t dev)
 		device_delete_child(dev, children[i]);
 	free(children, M_TEMP);
     } 
+#endif
     taskqueue_drain(taskqueue_thread, &ch->conntask);
 
+#ifdef ATA_CAM
+	mtx_lock(&ch->state_mtx);
+	xpt_async(AC_LOST_DEVICE, ch->path, NULL);
+	xpt_free_path(ch->path);
+	xpt_bus_deregister(cam_sim_path(ch->sim));
+	cam_sim_free(ch->sim, /*free_devq*/TRUE);
+	mtx_unlock(&ch->state_mtx);
+#endif
+
     /* release resources */
     bus_teardown_intr(dev, ch->r_irq, ch->ih);
     bus_release_resource(dev, SYS_RES_IRQ, ATA_IRQ_RID, ch->r_irq);
@@ -203,8 +279,11 @@ static void
 ata_conn_event(void *context, int dummy)
 {
     device_t dev = (device_t)context;
+    struct ata_channel *ch = device_get_softc(dev);
 
+    mtx_lock(&ch->state_mtx);
     ata_reinit(dev);
+    mtx_unlock(&ch->state_mtx);
 }
 
 int
@@ -212,6 +291,7 @@ ata_reinit(device_t dev)
 {
     struct ata_channel *ch = device_get_softc(dev);
     struct ata_request *request;
+#ifndef ATA_CAM
     device_t *children;
     int nchildren, i;
 
@@ -298,7 +378,23 @@ ata_reinit(device_t dev)
 
     /* kick off requests on the queue */
     ata_start(dev);
-    return 0;
+#else
+	if ((request = ch->running)) {
+		ch->running = NULL;
+		if (ch->state == ATA_ACTIVE)
+		    ch->state = ATA_IDLE;
+		callout_stop(&request->callout);
+		if (ch->dma.unload)
+		    ch->dma.unload(request);
+		request->result = ERESTART;
+		ata_cam_end_transaction(dev, request);
+	}
+	/* reset the controller HW, the channel and device(s) */
+	ATA_RESET(dev);
+	/* Tell the XPT about the event */
+	xpt_async(AC_BUS_RESET, ch->path, NULL);
+#endif
+	return(0);
 }
 
 int
@@ -310,6 +406,7 @@ ata_suspend(device_t dev)
     if (!dev || !(ch = device_get_softc(dev)))
 	return ENXIO;
 
+#ifndef ATA_CAM
     /* wait for the channel to be IDLE or detached before suspending */
     while (ch->r_irq) {
 	mtx_lock(&ch->state_mtx);
@@ -322,7 +419,8 @@ ata_suspend(device_t dev)
 	tsleep(ch, PRIBIO, "atasusp", hz/10);
     }
     ATA_LOCKING(dev, ATA_LF_UNLOCK);
-    return 0;
+#endif
+    return(0);
 }
 
 int
@@ -337,18 +435,36 @@ ata_resume(device_t dev)
     /* reinit the devices, we dont know what mode/state they are in */
     error = ata_reinit(dev);
 
+#ifndef ATA_CAM
     /* kick off requests on the queue */
     ata_start(dev);
+#endif
     return error;
 }
 
 void
 ata_interrupt(void *data)
 {
+#ifdef ATA_CAM
+    struct ata_channel *ch = (struct ata_channel *)data;
+
+    mtx_lock(&ch->state_mtx);
+#endif
+    ata_interrupt_locked(data);
+#ifdef ATA_CAM
+    mtx_unlock(&ch->state_mtx);
+#endif
+}
+
+static void
+ata_interrupt_locked(void *data)
+{
     struct ata_channel *ch = (struct ata_channel *)data;
     struct ata_request *request;
 
+#ifndef ATA_CAM
     mtx_lock(&ch->state_mtx);
+#endif
     do {
 	/* ignore interrupt if its not for us */
 	if (ch->hw.status && !ch->hw.status(ch->dev))
@@ -374,18 +490,25 @@ ata_interrupt(void *data)
 	    ch->running = NULL;
 	    if (ch->state == ATA_ACTIVE)
 		ch->state = ATA_IDLE;
+#ifdef ATA_CAM
+	    ata_cam_end_transaction(ch->dev, request);
+#else
 	    mtx_unlock(&ch->state_mtx);
 	    ATA_LOCKING(ch->dev, ATA_LF_UNLOCK);
 	    ata_finish(request);
+#endif
 	    return;
 	}
     } while (0);
+#ifndef ATA_CAM
     mtx_unlock(&ch->state_mtx);
+#endif
 }
 
 /*
  * device related interfaces
  */
+#ifndef ATA_CAM
 static int
 ata_ioctl(struct cdev *dev, u_long cmd, caddr_t data,
 	  int32_t flag, struct thread *td)
@@ -467,6 +590,7 @@ ata_ioctl(struct cdev *dev, u_long cmd, 
     }
     return error;
 }
+#endif
 
 int
 ata_device_ioctl(device_t dev, u_long cmd, caddr_t data)
@@ -566,6 +690,7 @@ ata_device_ioctl(device_t dev, u_long cm
     }
 }
 
+#ifndef ATA_CAM
 static void
 ata_boot_attach(void)
 {
@@ -590,11 +715,12 @@ ata_boot_attach(void)
 
     mtx_unlock(&Giant);     /* newbus suckage dealt with, release Giant */
 }
-
+#endif
 
 /*
  * misc support functions
  */
+#ifndef ATA_CAM
 static device_t
 ata_add_child(device_t parent, struct ata_device *atadev, int unit)
 {
@@ -609,6 +735,7 @@ ata_add_child(device_t parent, struct at
     }
     return child;
 }
+#endif
 
 int
 ata_getparam(struct ata_device *atadev, int init)
@@ -705,6 +832,7 @@ ata_getparam(struct ata_device *atadev, 
     return error;
 }
 
+#ifndef ATA_CAM
 int
 ata_identify(device_t dev)
 {
@@ -778,6 +906,7 @@ ata_identify(device_t dev)
     mtx_unlock(&Giant);
     return 0;
 }
+#endif
 
 void
 ata_default_registers(device_t dev)
@@ -798,10 +927,10 @@ ata_default_registers(device_t dev)
 void
 ata_modify_if_48bit(struct ata_request *request)
 {
-    struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
+    struct ata_channel *ch = device_get_softc(request->parent);
     struct ata_device *atadev = device_get_softc(request->dev);
 
-    atadev->flags &= ~ATA_D_48BIT_ACTIVE;
+    request->flags &= ~ATA_R_48BIT;
 
     if (((request->u.ata.lba + request->u.ata.count) >= ATA_MAX_28BIT_LBA ||
 	 request->u.ata.count > 256) &&
@@ -875,7 +1004,7 @@ ata_modify_if_48bit(struct ata_request *
 	default:
 	    return;
 	}
-	atadev->flags |= ATA_D_48BIT_ACTIVE;
+	request->flags |= ATA_R_48BIT;
     }
     else if (atadev->param.support.command2 & ATA_SUPPORT_ADDRESS48) {
 
@@ -893,7 +1022,7 @@ ata_modify_if_48bit(struct ata_request *
 	default:
 	    return;
 	}
-	atadev->flags |= ATA_D_48BIT_ACTIVE;
+	request->flags |= ATA_R_48BIT;
     }
 }
 
@@ -1084,6 +1213,288 @@ bpack(int8_t *src, int8_t *dst, int len)
 	dst[j] = 0x00;
 }
 
+#ifdef ATA_CAM
+void
+ata_cam_begin_transaction(device_t dev, union ccb *ccb)
+{
+	struct ata_channel *ch = device_get_softc(dev);
+	struct ata_request *request;
+
+	if (!(request = ata_alloc_request())) {
+		device_printf(dev, "FAILURE - out of memory in start\n");
+		ccb->ccb_h.status = CAM_REQ_INVALID;
+		xpt_done(ccb);
+		return;
+	}
+	bzero(request, sizeof(*request));
+
+	/* setup request */
+	request->dev = NULL;
+	request->parent = dev;
+	request->unit = ccb->ccb_h.target_id;
+	if (ccb->ccb_h.func_code == XPT_ATA_IO) {
+		request->data = ccb->ataio.data_ptr;
+		request->bytecount = ccb->ataio.dxfer_len;
+		request->u.ata.command = ccb->ataio.cmd.command;
+		request->u.ata.feature = ((uint16_t)ccb->ataio.cmd.features_exp << 8) |
+					  (uint16_t)ccb->ataio.cmd.features;
+		request->u.ata.count = ((uint16_t)ccb->ataio.cmd.sector_count_exp << 8) |
+					(uint16_t)ccb->ataio.cmd.sector_count;
+		if (ccb->ataio.cmd.flags & CAM_ATAIO_48BIT) {
+			request->flags |= ATA_R_48BIT;
+			request->u.ata.lba =
+				     ((uint64_t)ccb->ataio.cmd.lba_high_exp << 40) |
+				     ((uint64_t)ccb->ataio.cmd.lba_mid_exp << 32) |
+				     ((uint64_t)ccb->ataio.cmd.lba_low_exp << 24);
+		} else {
+			request->u.ata.lba =
+				     ((uint64_t)(ccb->ataio.cmd.device & 0x0f) << 24);
+		}
+		request->u.ata.lba |= ((uint64_t)ccb->ataio.cmd.lba_high << 16) |
+				      ((uint64_t)ccb->ataio.cmd.lba_mid << 8) |
+				       (uint64_t)ccb->ataio.cmd.lba_low;
+		if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE &&
+		    ccb->ataio.cmd.flags & CAM_ATAIO_DMA)
+			request->flags |= ATA_R_DMA;
+		if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN)
+			request->flags |= ATA_R_READ;
+		if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT)
+			request->flags |= ATA_R_WRITE;
+	} else {
+		request->data = ccb->csio.data_ptr;
+		request->bytecount = ccb->csio.dxfer_len;
+		bcopy((ccb->ccb_h.flags & CAM_CDB_POINTER) ?
+		    ccb->csio.cdb_io.cdb_ptr : ccb->csio.cdb_io.cdb_bytes,
+		    request->u.atapi.ccb, ccb->csio.cdb_len);
+		request->flags |= ATA_R_ATAPI;
+		if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE /*&&
+		    ccb->ataio.cmd.flags & CAM_ATAIO_DMA*/)
+			request->flags |= ATA_R_DMA;
+		if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN)
+			request->flags |= ATA_R_READ;
+		if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT)
+			request->flags |= ATA_R_WRITE;
+	}
+	request->transfersize = min(request->bytecount, 16*512);
+//	request->callback = ad_done;
+	request->retries = 0;
+	request->timeout = (ccb->ccb_h.timeout + 999) / 1000;
+	callout_init_mtx(&request->callout, &ch->state_mtx, CALLOUT_RETURNUNLOCKED);
+	request->ccb = ccb;
+
+	ch->running = request;
+	ch->state = ATA_ACTIVE;
+	if (ch->hw.begin_transaction(request) == ATA_OP_FINISHED) {
+	    ch->running = NULL;
+	    ch->state = ATA_IDLE;
+	    ata_cam_end_transaction(dev, request);
+	    return;
+	}
+}
+
+void
+ata_cam_end_transaction(device_t dev, struct ata_request *request)
+{
+	struct ata_channel *ch = device_get_softc(dev);
+	union ccb *ccb = request->ccb;
+
+	ccb->ccb_h.status &= ~CAM_STATUS_MASK;
+	if (request->flags & ATA_R_TIMEOUT) {
+		xpt_freeze_simq(ch->sim, 1);
+		ccb->ccb_h.status &= ~CAM_STATUS_MASK;
+		ccb->ccb_h.status |= CAM_CMD_TIMEOUT | CAM_RELEASE_SIMQ;
+	} else if (request->status & ATA_S_ERROR) {
+		if (ccb->ccb_h.func_code == XPT_ATA_IO) {
+			ccb->ccb_h.status |= CAM_ATA_STATUS_ERROR;
+		} else {
+			ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
+			ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
+		}
+	} else if (request->result == ERESTART)
+		ccb->ccb_h.status |= CAM_REQUEUE_REQ;
+	else if (request->result != 0)
+		ccb->ccb_h.status |= CAM_REQ_CMP_ERR;
+	else
+		ccb->ccb_h.status |= CAM_REQ_CMP;
+	if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP &&
+	    !(ccb->ccb_h.status & CAM_DEV_QFRZN)) {
+		xpt_freeze_devq(ccb->ccb_h.path, 1);
+		ccb->ccb_h.status |= CAM_DEV_QFRZN;
+	}
+	if (ccb->ccb_h.func_code == XPT_ATA_IO &&
+	    ((request->status & ATA_S_ERROR) ||
+	    (ccb->ataio.cmd.flags & CAM_ATAIO_NEEDRESULT))) {
+		struct ata_res *res = &ccb->ataio.res;
+		res->status = request->status;
+		res->error = request->error;
+		res->lba_low = request->u.ata.lba;
+		res->lba_mid = request->u.ata.lba >> 8;
+		res->lba_high = request->u.ata.lba >> 16;
+		res->device = request->u.ata.lba >> 24;
+		res->lba_low_exp = request->u.ata.lba >> 24;
+		res->lba_mid_exp = request->u.ata.lba >> 32;
+		res->lba_high_exp = request->u.ata.lba >> 40;
+		res->sector_count = request->u.ata.count;
+		res->sector_count_exp = request->u.ata.count >> 8;
+	}
+	ata_free_request(request);
+	xpt_done(ccb);
+}
+
+static void
+ataaction(struct cam_sim *sim, union ccb *ccb)
+{
+	device_t dev;
+	struct ata_channel *ch;
+
+	CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("ataaction func_code=%x\n",
+	    ccb->ccb_h.func_code));
+
+	ch = (struct ata_channel *)cam_sim_softc(sim);
+	dev = ch->dev;
+	switch (ccb->ccb_h.func_code) {
+	/* Common cases first */
+	case XPT_ATA_IO:	/* Execute the requested I/O operation */
+	case XPT_SCSI_IO:
+		if ((ch->devices & ((ATA_ATA_MASTER | ATA_ATAPI_MASTER)
+		    << ccb->ccb_h.target_id)) == 0) {
+			ccb->ccb_h.status = CAM_SEL_TIMEOUT;
+			xpt_done(ccb);
+			break;
+		}
+		if (ch->running)
+			device_printf(dev, "already running!\n");
+		if (ccb->ccb_h.func_code == XPT_ATA_IO &&
+		    (ccb->ataio.cmd.flags & CAM_ATAIO_CONTROL) &&
+		    (ccb->ataio.cmd.control & ATA_A_RESET)) {
+			struct ata_res *res = &ccb->ataio.res;
+			
+			bzero(res, sizeof(*res));
+			if (ch->devices & (ATA_ATA_MASTER << ccb->ccb_h.target_id)) {
+				res->lba_high = 0;
+				res->lba_mid = 0;
+			} else {
+				res->lba_high = 0xeb;
+				res->lba_mid = 0x14;
+			}
+			ccb->ccb_h.status = CAM_REQ_CMP;
+			xpt_done(ccb);
+			break;
+		}
+		ata_cam_begin_transaction(dev, ccb);
+		break;
+	case XPT_EN_LUN:		/* Enable LUN as a target */
+	case XPT_TARGET_IO:		/* Execute target I/O request */
+	case XPT_ACCEPT_TARGET_IO:	/* Accept Host Target Mode CDB */
+	case XPT_CONT_TARGET_IO:	/* Continue Host Target I/O Connection*/
+	case XPT_ABORT:			/* Abort the specified CCB */
+		/* XXX Implement */
+		ccb->ccb_h.status = CAM_REQ_INVALID;
+		xpt_done(ccb);
+		break;
+	case XPT_SET_TRAN_SETTINGS:
+	{
+		ccb->ccb_h.status = CAM_REQ_CMP;
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_GET_TRAN_SETTINGS:
+	/* Get default/user set transfer settings for the target */
+	{
+		struct	ccb_trans_settings *cts = &ccb->cts;
+
+		cts->protocol = PROTO_ATA;
+		cts->protocol_version = PROTO_VERSION_UNSPECIFIED;
+		cts->transport = XPORT_ATA;
+		cts->transport_version = XPORT_VERSION_UNSPECIFIED;
+		cts->proto_specific.valid = 0;
+		cts->xport_specific.sata.valid = 0;
+		ccb->ccb_h.status = CAM_REQ_CMP;
+		xpt_done(ccb);
+		break;
+	}
+#if 0
+	case XPT_CALC_GEOMETRY:
+	{
+		struct	  ccb_calc_geometry *ccg;
+		uint32_t size_mb;
+		uint32_t secs_per_cylinder;
+
+		ccg = &ccb->ccg;
+		size_mb = ccg->volume_size
+			/ ((1024L * 1024L) / ccg->block_size);
+		if (size_mb >= 1024 && (aha->extended_trans != 0)) {
+			if (size_mb >= 2048) {
+				ccg->heads = 255;
+				ccg->secs_per_track = 63;
+			} else {
+				ccg->heads = 128;
+				ccg->secs_per_track = 32;
+			}
+		} else {
+			ccg->heads = 64;
+			ccg->secs_per_track = 32;
+		}
+		secs_per_cylinder = ccg->heads * ccg->secs_per_track;
+		ccg->cylinders = ccg->volume_size / secs_per_cylinder;
+		ccb->ccb_h.status = CAM_REQ_CMP;
+		xpt_done(ccb);
+		break;
+	}
+#endif
+	case XPT_RESET_BUS:		/* Reset the specified SCSI bus */
+	case XPT_RESET_DEV:	/* Bus Device Reset the specified SCSI device */
+		ata_reinit(dev);
+		ccb->ccb_h.status = CAM_REQ_CMP;
+		xpt_done(ccb);
+		break;
+	case XPT_TERM_IO:		/* Terminate the I/O process */
+		/* XXX Implement */
+		ccb->ccb_h.status = CAM_REQ_INVALID;
+		xpt_done(ccb);
+		break;
+	case XPT_PATH_INQ:		/* Path routing inquiry */
+	{
+		struct ccb_pathinq *cpi = &ccb->cpi;
+
+		cpi->version_num = 1; /* XXX??? */
+		cpi->hba_inquiry = PI_SDTR_ABLE;
+		cpi->target_sprt = 0;
+		cpi->hba_misc = PIM_SEQSCAN;
+		cpi->hba_eng_cnt = 0;
+		cpi->max_target = 1;
+		cpi->max_lun = 0;
+		cpi->initiator_id = 0;
+		cpi->bus_id = cam_sim_bus(sim);
+		cpi->base_transfer_speed = 150000;
+		strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
+		strncpy(cpi->hba_vid, "ATA", HBA_IDLEN);
+		strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
+		cpi->unit_number = cam_sim_unit(sim);
+		cpi->transport = XPORT_ATA;
+		cpi->transport_version = XPORT_VERSION_UNSPECIFIED;
+		cpi->protocol = PROTO_ATA;
+		cpi->protocol_version = PROTO_VERSION_UNSPECIFIED;
+		cpi->maxio = ch->dma.max_iosize ? ch->dma.max_iosize : DFLTPHYS;
+		cpi->ccb_h.status = CAM_REQ_CMP;
+		xpt_done(ccb);
+		break;
+	}
+	default:
+		ccb->ccb_h.status = CAM_REQ_INVALID;
+		xpt_done(ccb);
+		break;
+	}
+}
+
+static void
+atapoll(struct cam_sim *sim)
+{
+	struct ata_channel *ch = (struct ata_channel *)cam_sim_softc(sim);
+
+	ata_interrupt_locked(ch);
+}
+#endif
 
 /*
  * module handeling
@@ -1091,10 +1502,13 @@ bpack(int8_t *src, int8_t *dst, int len)
 static int
 ata_module_event_handler(module_t mod, int what, void *arg)
 {
+#ifndef ATA_CAM
     static struct cdev *atacdev;
+#endif
 
     switch (what) {
     case MOD_LOAD:
+#ifndef ATA_CAM
 	/* register controlling device */
 	atacdev = make_dev(&ata_cdevsw, 0, UID_ROOT, GID_OPERATOR, 0600, "ata");
 
@@ -1112,11 +1526,14 @@ ata_module_event_handler(module_t mod, i
 		free(ata_delayed_attach, M_TEMP);
 	    }
 	}
+#endif
 	return 0;
 
     case MOD_UNLOAD:
+#ifndef ATA_CAM
 	/* deregister controlling device */
 	destroy_dev(atacdev);
+#endif
 	return 0;
 
     default:
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-all.h ./sys/dev/ata/ata-all.h
--- /storage/FreeBSD/head/sys/dev/ata/ata-all.h	2009-06-24 21:56:47.000000000 +0300
+++ ./sys/dev/ata/ata-all.h	2009-10-14 15:27:03.000000000 +0300
@@ -246,7 +246,7 @@
 #define ATA_AHCI_CL_OFFSET              0
 #define ATA_AHCI_FB_OFFSET              (ATA_AHCI_CL_SIZE * 32)
 #define ATA_AHCI_CT_OFFSET              (ATA_AHCI_FB_OFFSET + 4096)
-#define ATA_AHCI_CT_SIZE                (1024 + 128)
+#define ATA_AHCI_CT_SIZE                (2176 + 128)
 
 struct ata_ahci_dma_prd {
     u_int64_t                   dba;
@@ -260,7 +260,7 @@ struct ata_ahci_cmd_tab {
     u_int8_t                    cfis[64];
     u_int8_t                    acmd[32];
     u_int8_t                    reserved[32];
-#define ATA_AHCI_DMA_ENTRIES            64
+#define ATA_AHCI_DMA_ENTRIES            129
     struct ata_ahci_dma_prd     prd_tab[ATA_AHCI_DMA_ENTRIES];
 } __packed;
 
@@ -355,6 +355,7 @@ struct ata_composite {
 struct ata_request {
     device_t                    dev;            /* device handle */
     device_t                    parent;         /* channel handle */
+    int				unit;		/* physical unit */
     union {
 	struct {
 	    u_int8_t            command;        /* command reg */
@@ -380,6 +381,7 @@ struct ata_request {
 #define         ATA_R_DMA               0x00000010
 #define         ATA_R_QUIET             0x00000020
 #define         ATA_R_TIMEOUT           0x00000040
+#define         ATA_R_48BIT             0x00000080
 
 #define         ATA_R_ORDERED           0x00000100
 #define         ATA_R_AT_HEAD           0x00000200
@@ -387,6 +389,9 @@ struct ata_request {
 #define         ATA_R_THREAD            0x00000800
 #define         ATA_R_DIRECT            0x00001000
 
+#define         ATA_R_ATAPI16           0x00010000
+#define         ATA_R_ATAPI_INTR        0x00020000
+
 #define         ATA_R_DEBUG             0x10000000
 #define         ATA_R_DANGER1           0x20000000
 #define         ATA_R_DANGER2           0x40000000
@@ -407,6 +412,9 @@ struct ata_request {
     struct ata_composite        *composite;     /* for composite atomic ops */
     void                        *driver;        /* driver specific */
     TAILQ_ENTRY(ata_request)    chain;          /* list management */
+#ifdef ATA_CAM
+    union ccb			*ccb;
+#endif
 };
 
 /* define this for debugging request processing */
@@ -414,7 +422,7 @@ struct ata_request {
 #define ATA_DEBUG_RQ(request, string) \
     { \
     if (request->flags & ATA_R_DEBUG) \
-	device_printf(request->dev, "req=%p %s " string "\n", \
+	device_printf(request->parent, "req=%p %s " string "\n", \
 		      request, ata_cmd2str(request)); \
     }
 #else
@@ -440,7 +448,6 @@ struct ata_device {
 #define         ATA_D_USE_CHS           0x0001
 #define         ATA_D_MEDIA_CHANGED     0x0002
 #define         ATA_D_ENC_PRESENT       0x0004
-#define         ATA_D_48BIT_ACTIVE      0x0008
 };
 
 /* structure for holding DMA Physical Region Descriptors (PRD) entries */
@@ -474,7 +481,7 @@ struct ata_dma {
     u_int8_t                    *work;          /* workspace */
     bus_addr_t                  work_bus;       /* bus address of dmatab */
 
-#define ATA_DMA_SLOTS			32
+#define ATA_DMA_SLOTS			1
     int				dma_slots;	/* DMA slots allocated */
     struct ata_dmaslot		slot[ATA_DMA_SLOTS];
     u_int32_t                   alignment;      /* DMA SG list alignment */
@@ -550,6 +557,10 @@ struct ata_channel {
     struct ata_request          *freezepoint;   /* composite freezepoint */
     struct ata_request          *running;       /* currently running request */
     struct task			conntask;	/* PHY events handling task */
+#ifdef ATA_CAM
+	struct cam_sim		*sim;
+	struct cam_path		*path;
+#endif
 };
 
 /* disk bay/enclosure related */
@@ -589,6 +600,10 @@ int ata_pmode(struct ata_params *ap);
 int ata_wmode(struct ata_params *ap);
 int ata_umode(struct ata_params *ap);
 int ata_limit_mode(device_t dev, int mode, int maxmode);
+#ifdef ATA_CAM
+void ata_cam_begin_transaction(device_t dev, union ccb *ccb);
+void ata_cam_end_transaction(device_t dev, struct ata_request *request);
+#endif
 
 /* ata-queue.c: */
 int ata_controlcmd(device_t dev, u_int8_t command, u_int16_t feature, u_int64_t lba, u_int16_t count);
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-dma.c ./sys/dev/ata/ata-dma.c
--- /storage/FreeBSD/head/sys/dev/ata/ata-dma.c	2009-09-06 17:23:22.000000000 +0300
+++ ./sys/dev/ata/ata-dma.c	2009-10-14 15:27:03.000000000 +0300
@@ -78,7 +78,7 @@ ata_dmainit(device_t dev)
     ch->dma.segsize = 65536;
     ch->dma.max_iosize = 128 * DEV_BSIZE;
     ch->dma.max_address = BUS_SPACE_MAXADDR_32BIT;
-    ch->dma.dma_slots = 6;
+    ch->dma.dma_slots = 1;
 
     if (bus_dma_tag_create(bus_get_dma_tag(dev), ch->dma.alignment, 0,
 			   ch->dma.max_address, BUS_SPACE_MAXADDR,
@@ -256,37 +256,36 @@ static int
 ata_dmaload(struct ata_request *request, void *addr, int *entries)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
     struct ata_dmasetprd_args dspa;
     int error;
 
     ATA_DEBUG_RQ(request, "dmaload");
 
     if (request->dma) {
-	device_printf(request->dev,
+	device_printf(request->parent,
 		      "FAILURE - already active DMA on this device\n");
 	return EIO;
     }
     if (!request->bytecount) {
-	device_printf(request->dev,
+	device_printf(request->parent,
 		      "FAILURE - zero length DMA transfer attempted\n");
 	return EIO;
     }
     if (request->bytecount & (ch->dma.alignment - 1)) {
-	device_printf(request->dev,
+	device_printf(request->parent,
 		      "FAILURE - odd-sized DMA transfer attempt %d %% %d\n",
 		      request->bytecount, ch->dma.alignment);
 	return EIO;
     }
     if (request->bytecount > ch->dma.max_iosize) {
-	device_printf(request->dev,
+	device_printf(request->parent,
 		      "FAILURE - oversized DMA transfer attempt %d > %d\n",
 		      request->bytecount, ch->dma.max_iosize);
 	return EIO;
     }
 
-    /* set our slot, unit for simplicity XXX SOS NCQ will change that */
-    request->dma = &ch->dma.slot[atadev->unit];
+    /* set our slot. XXX SOS NCQ will change that */
+    request->dma = &ch->dma.slot[0];
 
     if (addr)
 	dspa.dmatab = addr;
@@ -297,7 +296,7 @@ ata_dmaload(struct ata_request *request,
 				 request->data, request->bytecount,
 				 ch->dma.setprd, &dspa, BUS_DMA_NOWAIT)) ||
 				 (error = dspa.error)) {
-	device_printf(request->dev, "FAILURE - load data\n");
+	device_printf(request->parent, "FAILURE - load data\n");
 	goto error;
     }
 
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-lowlevel.c ./sys/dev/ata/ata-lowlevel.c
--- /storage/FreeBSD/head/sys/dev/ata/ata-lowlevel.c	2009-03-14 17:10:01.000000000 +0200
+++ ./sys/dev/ata/ata-lowlevel.c	2009-10-14 15:27:03.000000000 +0300
@@ -47,7 +47,7 @@ __FBSDID("$FreeBSD: head/sys/dev/ata/ata
 
 /* prototypes */
 static int ata_generic_status(device_t dev);
-static int ata_wait(struct ata_channel *ch, struct ata_device *, u_int8_t);
+static int ata_wait(struct ata_channel *ch, int unit, u_int8_t);
 static void ata_pio_read(struct ata_request *, int);
 static void ata_pio_write(struct ata_request *, int);
 static void ata_tf_read(struct ata_request *);
@@ -77,7 +77,6 @@ int
 ata_begin_transaction(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
     int dummy, error;
 
     ATA_DEBUG_RQ(request, "begin transaction");
@@ -88,9 +87,6 @@ ata_begin_transaction(struct ata_request
 	 (ATA_R_ATAPI | ATA_R_DMA | ATA_R_WRITE)))
 	request->flags &= ~ATA_R_DMA;
 
-    /* check for 48 bit access and convert if needed */
-    ata_modify_if_48bit(request);
-
     switch (request->flags & (ATA_R_ATAPI | ATA_R_DMA)) {
 
     /* ATA PIO data transfer and control commands */
@@ -101,7 +97,7 @@ ata_begin_transaction(struct ata_request
 
 	    /* issue command */
 	    if (ch->hw.command(request)) {
-		device_printf(request->dev, "error issuing %s command\n",
+		device_printf(request->parent, "error issuing %s command\n",
 			   ata_cmd2str(request));
 		request->result = EIO;
 		goto begin_finished;
@@ -122,8 +118,8 @@ ata_begin_transaction(struct ata_request
 
 	    /* if write command output the data */
 	    if (write) {
-		if (ata_wait(ch, atadev, (ATA_S_READY | ATA_S_DRQ)) < 0) {
-		    device_printf(request->dev,
+		if (ata_wait(ch, request->unit, (ATA_S_READY | ATA_S_DRQ)) < 0) {
+		    device_printf(request->parent,
 				  "timeout waiting for write DRQ\n");
 		    request->result = EIO;
 		    goto begin_finished;
@@ -137,14 +133,14 @@ ata_begin_transaction(struct ata_request
     case ATA_R_DMA:
 	/* check sanity, setup SG list and DMA engine */
 	if ((error = ch->dma.load(request, NULL, &dummy))) {
-	    device_printf(request->dev, "setting up DMA failed\n");
+	    device_printf(request->parent, "setting up DMA failed\n");
 	    request->result = error;
 	    goto begin_finished;
 	}
 
 	/* issue command */
 	if (ch->hw.command(request)) {
-	    device_printf(request->dev, "error issuing %s command\n",
+	    device_printf(request->parent, "error issuing %s command\n",
 		       ata_cmd2str(request));
 	    request->result = EIO;
 	    goto begin_finished;
@@ -152,7 +148,7 @@ ata_begin_transaction(struct ata_request
 
 	/* start DMA engine */
 	if (ch->dma.start && ch->dma.start(request)) {
-	    device_printf(request->dev, "error starting DMA\n");
+	    device_printf(request->parent, "error starting DMA\n");
 	    request->result = EIO;
 	    goto begin_finished;
 	}
@@ -162,7 +158,7 @@ ata_begin_transaction(struct ata_request
     case ATA_R_ATAPI:
 	/* is this just a POLL DSC command ? */
 	if (request->u.atapi.ccb[0] == ATAPI_POLL_DSC) {
-	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(atadev->unit));
+	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(request->unit));
 	    DELAY(10);
 	    if (!(ATA_IDX_INB(ch, ATA_ALTSTAT) & ATA_S_DSC))
 		request->result = EBUSY;
@@ -171,7 +167,7 @@ ata_begin_transaction(struct ata_request
 
 	/* start ATAPI operation */
 	if (ch->hw.command(request)) {
-	    device_printf(request->dev, "error issuing ATA PACKET command\n");
+	    device_printf(request->parent, "error issuing ATA PACKET command\n");
 	    request->result = EIO;
 	    goto begin_finished;
 	}
@@ -181,7 +177,7 @@ ata_begin_transaction(struct ata_request
     case ATA_R_ATAPI|ATA_R_DMA:
 	/* is this just a POLL DSC command ? */
 	if (request->u.atapi.ccb[0] == ATAPI_POLL_DSC) {
-	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(atadev->unit));
+	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(request->unit));
 	    DELAY(10);
 	    if (!(ATA_IDX_INB(ch, ATA_ALTSTAT) & ATA_S_DSC))
 		request->result = EBUSY;
@@ -190,14 +186,14 @@ ata_begin_transaction(struct ata_request
 
 	/* check sanity, setup SG list and DMA engine */
 	if ((error = ch->dma.load(request, NULL, &dummy))) {
-	    device_printf(request->dev, "setting up DMA failed\n");
+	    device_printf(request->parent, "setting up DMA failed\n");
 	    request->result = error;
 	    goto begin_finished;
 	}
 
 	/* start ATAPI operation */
 	if (ch->hw.command(request)) {
-	    device_printf(request->dev, "error issuing ATA PACKET command\n");
+	    device_printf(request->parent, "error issuing ATA PACKET command\n");
 	    request->result = EIO;
 	    goto begin_finished;
 	}
@@ -229,7 +225,6 @@ int
 ata_end_transaction(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
     int length;
 
     ATA_DEBUG_RQ(request, "end transaction");
@@ -266,8 +261,8 @@ ata_end_transaction(struct ata_request *
 
 		if (request->u.ata.command != ATA_ATAPI_IDENTIFY)
 		    flags |= ATA_S_READY;
-		if (ata_wait(ch, atadev, flags) < 0) {
-		    device_printf(request->dev,
+		if (ata_wait(ch, request->unit, flags) < 0) {
+		    device_printf(request->parent,
 				  "timeout waiting for read DRQ\n");
 		    request->result = EIO;
 		    goto end_finished;
@@ -290,8 +285,8 @@ ata_end_transaction(struct ata_request *
 		if (request->flags & ATA_R_WRITE) {
 
 		    /* if we get an error here we are done with the HW */
-		    if (ata_wait(ch, atadev, (ATA_S_READY | ATA_S_DRQ)) < 0) {
-			device_printf(request->dev,
+		    if (ata_wait(ch, request->unit, (ATA_S_READY | ATA_S_DRQ)) < 0) {
+			device_printf(request->parent,
 				      "timeout waiting for write DRQ\n");
 			request->status = ATA_IDX_INB(ch, ATA_STATUS);
 			goto end_finished;
@@ -347,20 +342,19 @@ ata_end_transaction(struct ata_request *
 	    DELAY(10);
 
 	    if (!(request->status & ATA_S_DRQ)) {
-		device_printf(request->dev, "command interrupt without DRQ\n");
+		device_printf(request->parent, "command interrupt without DRQ\n");
 		request->status = ATA_S_ERROR;
 		goto end_finished;
 	    }
 	    ATA_IDX_OUTSW_STRM(ch, ATA_DATA, (int16_t *)request->u.atapi.ccb,
-			       (atadev->param.config &
-				ATA_PROTO_MASK)== ATA_PROTO_ATAPI_12 ? 6 : 8);
+			       (request->flags & ATA_R_ATAPI16) ? 8 : 6);
 	    /* return wait for interrupt */
 	    goto end_continue;
 
 	case ATAPI_P_WRITE:
 	    if (request->flags & ATA_R_READ) {
 		request->status = ATA_S_ERROR;
-		device_printf(request->dev,
+		device_printf(request->parent,
 			      "%s trying to write on read buffer\n",
 			   ata_cmd2str(request));
 		goto end_finished;
@@ -378,7 +372,7 @@ ata_end_transaction(struct ata_request *
 	case ATAPI_P_READ:
 	    if (request->flags & ATA_R_WRITE) {
 		request->status = ATA_S_ERROR;
-		device_printf(request->dev,
+		device_printf(request->parent,
 			      "%s trying to read on write buffer\n",
 			   ata_cmd2str(request));
 		goto end_finished;
@@ -393,7 +387,7 @@ ata_end_transaction(struct ata_request *
 	    goto end_continue;
 
 	case ATAPI_P_DONEDRQ:
-	    device_printf(request->dev,
+	    device_printf(request->parent,
 			  "WARNING - %s DONEDRQ non conformant device\n",
 			  ata_cmd2str(request));
 	    if (request->flags & ATA_R_READ) {
@@ -415,7 +409,7 @@ ata_end_transaction(struct ata_request *
 	    goto end_finished;
 
 	default:
-	    device_printf(request->dev, "unknown transfer phase\n");
+	    device_printf(request->parent, "unknown transfer phase\n");
 	    request->status = ATA_S_ERROR;
 	}
 
@@ -603,7 +597,7 @@ ata_generic_status(device_t dev)
 }
 
 static int
-ata_wait(struct ata_channel *ch, struct ata_device *atadev, u_int8_t mask)
+ata_wait(struct ata_channel *ch, int unit, u_int8_t mask)
 {
     u_int8_t status;
     int timeout = 0;
@@ -616,7 +610,7 @@ ata_wait(struct ata_channel *ch, struct 
 
 	/* if drive fails status, reselect the drive and try again */
 	if (status == 0xff) {
-	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(atadev->unit));
+	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(unit));
 	    timeout += 1000;
 	    DELAY(1000);
 	    continue;
@@ -657,14 +651,13 @@ int
 ata_generic_command(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
 
     /* select device */
-    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_D_LBA | ATA_DEV(atadev->unit));
+    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_D_LBA | ATA_DEV(request->unit));
 
     /* ready to issue command ? */
-    if (ata_wait(ch, atadev, 0) < 0) { 
-	device_printf(request->dev, "timeout waiting to issue command\n");
+    if (ata_wait(ch, request->unit, 0) < 0) { 
+	device_printf(request->parent, "timeout waiting to issue command\n");
 	return -1;
     }
 
@@ -673,6 +666,7 @@ ata_generic_command(struct ata_request *
 
     if (request->flags & ATA_R_ATAPI) {
 	int timeout = 5000;
+	int res;
 
 	/* issue packet command to controller */
 	if (request->flags & ATA_R_DMA) {
@@ -688,9 +682,16 @@ ata_generic_command(struct ata_request *
 	ATA_IDX_OUTB(ch, ATA_COMMAND, ATA_PACKET_CMD);
 
 	/* command interrupt device ? just return and wait for interrupt */
-	if ((atadev->param.config & ATA_DRQ_MASK) == ATA_DRQ_INTR)
+	if (request->flags & ATA_R_ATAPI_INTR)
 	    return 0;
 
+	/* command processed ? */
+	res = ata_wait(ch, request->unit, 0);
+	if (res != 0) {
+	    if (res < 0)
+		    device_printf(request->parent, "timeout waiting for PACKET command\n");
+	    return (-1);
+	}
 	/* wait for ready to write ATAPI command block */
 	while (timeout--) {
 	    int reason = ATA_IDX_INB(ch, ATA_IREASON);
@@ -702,7 +703,7 @@ ata_generic_command(struct ata_request *
 	    DELAY(20);
 	}
 	if (timeout <= 0) {
-	    device_printf(request->dev, "timeout waiting for ATAPI ready\n");
+	    device_printf(request->parent, "timeout waiting for ATAPI ready\n");
 	    request->result = EIO;
 	    return -1;
 	}
@@ -712,8 +713,7 @@ ata_generic_command(struct ata_request *
 		    
 	/* output command block */
 	ATA_IDX_OUTSW_STRM(ch, ATA_DATA, (int16_t *)request->u.atapi.ccb,
-			   (atadev->param.config & ATA_PROTO_MASK) ==
-			   ATA_PROTO_ATAPI_12 ? 6 : 8);
+			   (request->flags & ATA_R_ATAPI16) ? 8 : 6);
     }
     else {
 	ch->hw.tf_write(request);
@@ -728,9 +728,8 @@ static void
 ata_tf_read(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	ATA_IDX_OUTB(ch, ATA_CONTROL, ATA_A_4BIT | ATA_A_HOB);
 	request->u.ata.count = (ATA_IDX_INB(ch, ATA_COUNT) << 8);
 	request->u.ata.lba =
@@ -758,9 +757,11 @@ static void
 ata_tf_write(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
+#ifndef ATA_CAM
     struct ata_device *atadev = device_get_softc(request->dev);
+#endif
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	ATA_IDX_OUTB(ch, ATA_FEATURE, request->u.ata.feature >> 8);
 	ATA_IDX_OUTB(ch, ATA_FEATURE, request->u.ata.feature);
 	ATA_IDX_OUTB(ch, ATA_COUNT, request->u.ata.count >> 8);
@@ -771,11 +772,12 @@ ata_tf_write(struct ata_request *request
 	ATA_IDX_OUTB(ch, ATA_CYL_LSB, request->u.ata.lba >> 8);
 	ATA_IDX_OUTB(ch, ATA_CYL_MSB, request->u.ata.lba >> 40);
 	ATA_IDX_OUTB(ch, ATA_CYL_MSB, request->u.ata.lba >> 16);
-	ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_LBA | ATA_DEV(atadev->unit));
+	ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_LBA | ATA_DEV(request->unit));
     }
     else {
 	ATA_IDX_OUTB(ch, ATA_FEATURE, request->u.ata.feature);
 	ATA_IDX_OUTB(ch, ATA_COUNT, request->u.ata.count);
+#ifndef ATA_CAM
 	if (atadev->flags & ATA_D_USE_CHS) {
 	    int heads, sectors;
     
@@ -793,18 +795,21 @@ ata_tf_write(struct ata_request *request
 			 (request->u.ata.lba / (sectors * heads)));
 	    ATA_IDX_OUTB(ch, ATA_CYL_MSB,
 			 (request->u.ata.lba / (sectors * heads)) >> 8);
-	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(atadev->unit) | 
+	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(request->unit) | 
 			 (((request->u.ata.lba% (sectors * heads)) /
 			   sectors) & 0xf));
 	}
 	else {
+#endif
 	    ATA_IDX_OUTB(ch, ATA_SECTOR, request->u.ata.lba);
 	    ATA_IDX_OUTB(ch, ATA_CYL_LSB, request->u.ata.lba >> 8);
 	    ATA_IDX_OUTB(ch, ATA_CYL_MSB, request->u.ata.lba >> 16);
 	    ATA_IDX_OUTB(ch, ATA_DRIVE,
-			 ATA_D_IBM | ATA_D_LBA | ATA_DEV(atadev->unit) |
+			 ATA_D_IBM | ATA_D_LBA | ATA_DEV(request->unit) |
 			 ((request->u.ata.lba >> 24) & 0x0f));
+#ifndef ATA_CAM
 	}
+#endif
     }
 }
 
@@ -825,7 +830,7 @@ ata_pio_read(struct ata_request *request
 			  size / sizeof(int32_t));
 
     if (request->transfersize < length) {
-	device_printf(request->dev, "WARNING - %s read data overrun %d>%d\n",
+	device_printf(request->parent, "WARNING - %s read data overrun %d>%d\n",
 		   ata_cmd2str(request), length, request->transfersize);
 	for (resid = request->transfersize; resid < length;
 	     resid += sizeof(int16_t))
@@ -850,7 +855,7 @@ ata_pio_write(struct ata_request *reques
 			   size / sizeof(int32_t));
 
     if (request->transfersize < length) {
-	device_printf(request->dev, "WARNING - %s write data underrun %d>%d\n",
+	device_printf(request->parent, "WARNING - %s write data underrun %d>%d\n",
 		   ata_cmd2str(request), length, request->transfersize);
 	for (resid = request->transfersize; resid < length;
 	     resid += sizeof(int16_t))
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-pci.c ./sys/dev/ata/ata-pci.c
--- /storage/FreeBSD/head/sys/dev/ata/ata-pci.c	2009-04-30 00:17:22.000000000 +0300
+++ ./sys/dev/ata/ata-pci.c	2009-10-14 15:27:03.000000000 +0300
@@ -477,7 +477,7 @@ ata_pci_dmareset(device_t dev)
     ch->dma.flags &= ~ATA_DMA_ACTIVE;
     ATA_IDX_OUTB(ch, ATA_BMSTAT_PORT, ATA_BMSTAT_INTERRUPT | ATA_BMSTAT_ERROR);
     if ((request = ch->running)) {
-	device_printf(request->dev, "DMA reset calling unload\n");
+	device_printf(dev, "DMA reset calling unload\n");
 	ch->dma.unload(request);
     }
 }
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-queue.c ./sys/dev/ata/ata-queue.c
--- /storage/FreeBSD/head/sys/dev/ata/ata-queue.c	2009-10-23 18:06:50.000000000 +0300
+++ ./sys/dev/ata/ata-queue.c	2009-10-23 18:06:24.000000000 +0300
@@ -52,17 +52,25 @@ void
 ata_queue_request(struct ata_request *request)
 {
     struct ata_channel *ch;
+    struct ata_device *atadev = device_get_softc(request->dev);
 
     /* treat request as virgin (this might be an ATA_R_REQUEUE) */
     request->result = request->status = request->error = 0;
 
-    /* check that the device is still valid */
+    /* Prepare paramers required by low-level code. */
+    request->unit = atadev->unit;
     if (!(request->parent = device_get_parent(request->dev))) {
 	request->result = ENXIO;
 	if (request->callback)
 	    (request->callback)(request);
 	return;
     }
+    if ((atadev->param.config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_16)
+	request->flags |= ATA_R_ATAPI16;
+    if ((atadev->param.config & ATA_DRQ_MASK) == ATA_DRQ_INTR)
+	request->flags |= ATA_R_ATAPI_INTR;
+    if ((request->flags & ATA_R_ATAPI) == 0)
+	ata_modify_if_48bit(request);
     ch = device_get_softc(request->parent);
     callout_init_mtx(&request->callout, &ch->state_mtx, CALLOUT_RETURNUNLOCKED);
     if (!request->callback && !(request->flags & ATA_R_REQUEUE))
@@ -503,11 +511,18 @@ ata_timeout(struct ata_request *request)
      */
     if (ch->state == ATA_ACTIVE) {
 	request->flags |= ATA_R_TIMEOUT;
-	mtx_unlock(&ch->state_mtx);
-	ATA_LOCKING(ch->dev, ATA_LF_UNLOCK);
 	if (ch->dma.unload)
 	    ch->dma.unload(request);
+#ifdef ATA_CAM
+	ch->running = NULL;
+	ch->state = ATA_IDLE;
+	ata_cam_end_transaction(ch->dev, request);
+#endif
+	mtx_unlock(&ch->state_mtx);
+	ATA_LOCKING(ch->dev, ATA_LF_UNLOCK);
+#ifndef ATA_CAM
 	ata_finish(request);
+#endif
     }
     else {
 	mtx_unlock(&ch->state_mtx);
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/ata-sata.c ./sys/dev/ata/ata-sata.c
--- /storage/FreeBSD/head/sys/dev/ata/ata-sata.c	2009-06-24 21:56:47.000000000 +0300
+++ ./sys/dev/ata/ata-sata.c	2009-10-14 15:27:03.000000000 +0300
@@ -246,11 +246,10 @@ ata_sata_setmode(device_t dev, int mode)
 int
 ata_request2fis_h2d(struct ata_request *request, u_int8_t *fis)
 {
-    struct ata_device *atadev = device_get_softc(request->dev);
 
     if (request->flags & ATA_R_ATAPI) {
 	fis[0] = 0x27;  		/* host to device */
-	fis[1] = 0x80 | (atadev->unit & 0x0f);
+	fis[1] = 0x80 | (request->unit & 0x0f);
 	fis[2] = ATA_PACKET_CMD;
 	if (request->flags & (ATA_R_READ | ATA_R_WRITE))
 	    fis[3] = ATA_F_DMA;
@@ -263,16 +262,15 @@ ata_request2fis_h2d(struct ata_request *
 	return 20;
     }
     else {
-	ata_modify_if_48bit(request);
 	fis[0] = 0x27;			/* host to device */
-	fis[1] = 0x80 | (atadev->unit & 0x0f);
+	fis[1] = 0x80 | (request->unit & 0x0f);
 	fis[2] = request->u.ata.command;
 	fis[3] = request->u.ata.feature;
 	fis[4] = request->u.ata.lba;
 	fis[5] = request->u.ata.lba >> 8;
 	fis[6] = request->u.ata.lba >> 16;
 	fis[7] = ATA_D_LBA;
-	if (!(atadev->flags & ATA_D_48BIT_ACTIVE))
+	if (!(request->flags & ATA_R_48BIT))
 	    fis[7] |= (ATA_D_IBM | (request->u.ata.lba >> 24 & 0x0f));
 	fis[8] = request->u.ata.lba >> 24;
 	fis[9] = request->u.ata.lba >> 32; 
@@ -339,9 +337,6 @@ ata_pm_identify(device_t dev)
 		      pm_chipid, pm_revision, pm_ports);
     }
 
-    /* realloc space for needed DMA slots */
-    ch->dma.dma_slots = pm_ports;
-
     /* reset all ports and register if anything connected */
     for (port=0; port < pm_ports; port++) {
 	u_int32_t signature;
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-ahci.c ./sys/dev/ata/chipsets/ata-ahci.c
--- /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-ahci.c	2009-07-08 09:00:09.000000000 +0300
+++ ./sys/dev/ata/chipsets/ata-ahci.c	2009-10-14 15:27:03.000000000 +0300
@@ -385,23 +385,22 @@ ata_ahci_status(device_t dev)
 static int
 ata_ahci_begin_transaction(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
     struct ata_ahci_cmd_tab *ctp;
     struct ata_ahci_cmd_list *clp;
     int offset = ch->unit << 7;
-    int port = atadev->unit & 0x0f;
+    int port = request->unit & 0x0f;
     int entries = 0;
     int fis_size;
 	
     /* get a piece of the workspace for this request */
     ctp = (struct ata_ahci_cmd_tab *)
-	  (ch->dma.work + ATA_AHCI_CT_OFFSET + (ATA_AHCI_CT_SIZE*request->tag));
+	  (ch->dma.work + ATA_AHCI_CT_OFFSET);
 
     /* setup the FIS for this request */
     if (!(fis_size = ata_ahci_setup_fis(ctp, request))) {
-	device_printf(request->dev, "setting up SATA FIS failed\n");
+	device_printf(request->parent, "setting up SATA FIS failed\n");
 	request->result = EIO;
 	return ATA_OP_FINISHED;
     }
@@ -409,7 +408,7 @@ ata_ahci_begin_transaction(struct ata_re
     /* if request moves data setup and load SG list */
     if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
 	if (ch->dma.load(request, ctp->prd_tab, &entries)) {
-	    device_printf(request->dev, "setting up DMA failed\n");
+	    device_printf(request->parent, "setting up DMA failed\n");
 	    request->result = EIO;
 	    return ATA_OP_FINISHED;
 	}
@@ -417,7 +416,7 @@ ata_ahci_begin_transaction(struct ata_re
 
     /* setup the command list entry */
     clp = (struct ata_ahci_cmd_list *)
-	  (ch->dma.work + ATA_AHCI_CL_OFFSET + (ATA_AHCI_CL_SIZE*request->tag));
+	  (ch->dma.work + ATA_AHCI_CL_OFFSET);
 
     clp->prd_length = entries;
     clp->cmd_flags = (request->flags & ATA_R_WRITE ? ATA_AHCI_CMD_WRITE : 0) |
@@ -426,12 +425,7 @@ ata_ahci_begin_transaction(struct ata_re
 		     (fis_size / sizeof(u_int32_t)) |
     		     (port << 12);
     clp->bytecount = 0;
-    clp->cmd_table_phys = htole64(ch->dma.work_bus + ATA_AHCI_CT_OFFSET +
-				  (ATA_AHCI_CT_SIZE * request->tag));
-
-    /* clear eventual ACTIVE bit */
-    ATA_IDX_OUTL(ch, ATA_SACTIVE,
-		 ATA_IDX_INL(ch, ATA_SACTIVE) & (1 << request->tag));
+    clp->cmd_table_phys = htole64(ch->dma.work_bus + ATA_AHCI_CT_OFFSET);
 
     /* set command type bit */
     if (request->flags & ATA_R_ATAPI)
@@ -444,7 +438,7 @@ ata_ahci_begin_transaction(struct ata_re
 		 ~ATA_AHCI_P_CMD_ATAPI);
 
     /* issue command to controller */
-    ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CI + offset, (1 << request->tag));
+    ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CI + offset, 1);
     
     if (!(request->flags & ATA_R_ATAPI)) {
 	/* device reset doesn't interrupt */
@@ -476,7 +470,7 @@ ata_ahci_begin_transaction(struct ata_re
 static int
 ata_ahci_end_transaction(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
     struct ata_ahci_cmd_list *clp;
     u_int32_t tf_data;
@@ -495,13 +489,12 @@ ata_ahci_end_transaction(struct ata_requ
 
     /* on control commands read back registers to the request struct */
     if (request->flags & ATA_R_CONTROL) {
-	struct ata_device *atadev = device_get_softc(request->dev);
 	u_int8_t *fis = ch->dma.work + ATA_AHCI_FB_OFFSET + 0x40;
 
 	request->u.ata.count = fis[12] | ((u_int16_t)fis[13] << 8);
 	request->u.ata.lba = fis[4] | ((u_int64_t)fis[5] << 8) |
 			     ((u_int64_t)fis[6] << 16);
-	if (atadev->flags & ATA_D_48BIT_ACTIVE)
+	if (request->flags & ATA_R_48BIT)
 	    request->u.ata.lba |= ((u_int64_t)fis[8] << 24) |
 				  ((u_int64_t)fis[9] << 32) |
 				  ((u_int64_t)fis[10] << 40);
@@ -511,7 +504,7 @@ ata_ahci_end_transaction(struct ata_requ
 
     /* record how much data we actually moved */
     clp = (struct ata_ahci_cmd_list *)
-	  (ch->dma.work + ATA_AHCI_CL_OFFSET + (ATA_AHCI_CL_SIZE*request->tag));
+	  (ch->dma.work + ATA_AHCI_CL_OFFSET);
     request->donecount = clp->bytecount;
 
     /* release SG list etc */
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-intel.c ./sys/dev/ata/chipsets/ata-intel.c
--- /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-intel.c	2009-06-24 22:49:16.000000000 +0300
+++ ./sys/dev/ata/chipsets/ata-intel.c	2009-10-14 15:27:03.000000000 +0300
@@ -466,10 +466,12 @@ ata_intel_31244_status(device_t dev)
 static void
 ata_intel_31244_tf_write(struct ata_request *request)
 {
-    struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
+    struct ata_channel *ch = device_get_softc(request->parent);
+#ifndef ATA_CAM
     struct ata_device *atadev = device_get_softc(request->dev);
+#endif
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	ATA_IDX_OUTW(ch, ATA_FEATURE, request->u.ata.feature);
 	ATA_IDX_OUTW(ch, ATA_COUNT, request->u.ata.count);
 	ATA_IDX_OUTW(ch, ATA_SECTOR, ((request->u.ata.lba >> 16) & 0xff00) |
@@ -478,11 +480,12 @@ ata_intel_31244_tf_write(struct ata_requ
 				       ((request->u.ata.lba >> 8) & 0x00ff));
 	ATA_IDX_OUTW(ch, ATA_CYL_MSB, ((request->u.ata.lba >> 32) & 0xff00) | 
 				       ((request->u.ata.lba >> 16) & 0x00ff));
-	ATA_IDX_OUTW(ch, ATA_DRIVE, ATA_D_LBA | ATA_DEV(atadev->unit));
+	ATA_IDX_OUTW(ch, ATA_DRIVE, ATA_D_LBA | ATA_DEV(request->unit));
     }
     else {
 	ATA_IDX_OUTB(ch, ATA_FEATURE, request->u.ata.feature);
 	ATA_IDX_OUTB(ch, ATA_COUNT, request->u.ata.count);
+#ifndef ATA_CAM
 	if (atadev->flags & ATA_D_USE_CHS) {
 	    int heads, sectors;
     
@@ -499,18 +502,21 @@ ata_intel_31244_tf_write(struct ata_requ
 			 (request->u.ata.lba / (sectors * heads)));
 	    ATA_IDX_OUTB(ch, ATA_CYL_MSB,
 			 (request->u.ata.lba / (sectors * heads)) >> 8);
-	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(atadev->unit) | 
+	    ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(request->unit) | 
 			 (((request->u.ata.lba% (sectors * heads)) /
 			   sectors) & 0xf));
 	}
 	else {
+#endif
 	    ATA_IDX_OUTB(ch, ATA_SECTOR, request->u.ata.lba);
 	    ATA_IDX_OUTB(ch, ATA_CYL_LSB, request->u.ata.lba >> 8);
 	    ATA_IDX_OUTB(ch, ATA_CYL_MSB, request->u.ata.lba >> 16);
 	    ATA_IDX_OUTB(ch, ATA_DRIVE,
-			 ATA_D_IBM | ATA_D_LBA | ATA_DEV(atadev->unit) |
+			 ATA_D_IBM | ATA_D_LBA | ATA_DEV(request->unit) |
 			 ((request->u.ata.lba >> 24) & 0x0f));
+#ifndef ATA_CAM
 	}
+#endif
     }
 }
 
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-marvell.c ./sys/dev/ata/chipsets/ata-marvell.c
--- /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-marvell.c	2009-10-07 08:22:18.000000000 +0300
+++ ./sys/dev/ata/chipsets/ata-marvell.c	2009-10-14 15:27:03.000000000 +0300
@@ -346,7 +346,7 @@ ata_marvell_edma_status(device_t dev)
 static int
 ata_marvell_edma_begin_transaction(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
     u_int32_t req_in;
     u_int8_t *bytep;
@@ -355,7 +355,9 @@ ata_marvell_edma_begin_transaction(struc
 
     /* only DMA R/W goes through the EMDA machine */
     if (request->u.ata.command != ATA_READ_DMA &&
-	request->u.ata.command != ATA_WRITE_DMA) {
+	request->u.ata.command != ATA_WRITE_DMA &&
+	request->u.ata.command != ATA_READ_DMA48 &&
+	request->u.ata.command != ATA_WRITE_DMA48) {
 
 	/* disable the EDMA machinery */
 	if (ATA_INL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch)) & 0x00000001)
@@ -363,12 +365,9 @@ ata_marvell_edma_begin_transaction(struc
 	return ata_begin_transaction(request);
     }
 
-    /* check for 48 bit access and convert if needed */
-    ata_modify_if_48bit(request);
-
     /* check sanity, setup SG list and DMA engine */
     if ((error = ch->dma.load(request, NULL, NULL))) {
-	device_printf(request->dev, "setting up DMA failed\n");
+	device_printf(request->parent, "setting up DMA failed\n");
 	request->result = error;
 	return ATA_OP_FINISHED;
     }
@@ -438,7 +437,7 @@ ata_marvell_edma_begin_transaction(struc
 static int
 ata_marvell_edma_end_transaction(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
     int offset = (ch->unit > 3 ? 0x30014 : 0x20014);
     u_int32_t icr = ATA_INL(ctlr->r_res1, offset);
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-promise.c ./sys/dev/ata/chipsets/ata-promise.c
--- /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-promise.c	2009-06-24 22:49:16.000000000 +0300
+++ ./sys/dev/ata/chipsets/ata-promise.c	2009-10-14 15:27:03.000000000 +0300
@@ -387,11 +387,10 @@ ata_promise_status(device_t dev)
 static int
 ata_promise_dmastart(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev  = device_get_softc(request->dev);
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	ATA_OUTB(ctlr->r_res1, 0x11,
 		 ATA_INB(ctlr->r_res1, 0x11) | (ch->unit ? 0x08 : 0x02));
 	ATA_OUTL(ctlr->r_res1, ch->unit ? 0x24 : 0x20,
@@ -411,12 +410,11 @@ ata_promise_dmastart(struct ata_request 
 static int
 ata_promise_dmastop(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev  = device_get_softc(request->dev);
     int error;
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	ATA_OUTB(ctlr->r_res1, 0x11,
 		 ATA_INB(ctlr->r_res1, 0x11) & ~(ch->unit ? 0x08 : 0x02));
 	ATA_OUTL(ctlr->r_res1, ch->unit ? 0x24 : 0x20, 0);
@@ -682,9 +680,8 @@ ata_promise_mio_status(device_t dev)
 static int
 ata_promise_mio_command(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
 
     u_int32_t *wordp = (u_int32_t *)ch->dma.work;
 
@@ -693,7 +690,7 @@ ata_promise_mio_command(struct ata_reque
     if ((ctlr->chip->cfg2 == PR_SATA2) ||
         ((ctlr->chip->cfg2 == PR_CMBO2) && (ch->unit < 2))) {
 	/* set portmultiplier port */
-	ATA_OUTB(ctlr->r_res2, 0x4e8 + (ch->unit << 8), atadev->unit & 0x0f);
+	ATA_OUTB(ctlr->r_res2, 0x4e8 + (ch->unit << 8), request->unit & 0x0f);
     }
 
     /* XXX SOS add ATAPI commands support later */
@@ -1051,7 +1048,7 @@ ata_promise_sx4_intr(void *data)
 static int
 ata_promise_sx4_command(struct ata_request *request)
 {
-    device_t gparent = GRANDPARENT(request->dev);
+    device_t gparent = device_get_parent(request->parent);
     struct ata_pci_controller *ctlr = device_get_softc(gparent);
     struct ata_channel *ch = device_get_softc(request->parent);
     struct ata_dma_prdentry *prd;
@@ -1158,15 +1155,14 @@ ata_promise_sx4_command(struct ata_reque
 static int
 ata_promise_apkt(u_int8_t *bytep, struct ata_request *request)
 { 
-    struct ata_device *atadev = device_get_softc(request->dev);
     int i = 12;
 
     bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_PDC_WAIT_NBUSY|ATA_DRIVE;
-    bytep[i++] = ATA_D_IBM | ATA_D_LBA | ATA_DEV(atadev->unit);
+    bytep[i++] = ATA_D_IBM | ATA_D_LBA | ATA_DEV(request->unit);
     bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_CTL;
     bytep[i++] = ATA_A_4BIT;
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	bytep[i++] = ATA_PDC_2B | ATA_PDC_WRITE_REG | ATA_FEATURE;
 	bytep[i++] = request->u.ata.feature >> 8;
 	bytep[i++] = request->u.ata.feature;
@@ -1183,7 +1179,7 @@ ata_promise_apkt(u_int8_t *bytep, struct
 	bytep[i++] = request->u.ata.lba >> 40;
 	bytep[i++] = request->u.ata.lba >> 16;
 	bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_DRIVE;
-	bytep[i++] = ATA_D_LBA | ATA_DEV(atadev->unit);
+	bytep[i++] = ATA_D_LBA | ATA_DEV(request->unit);
     }
     else {
 	bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_FEATURE;
@@ -1197,8 +1193,7 @@ ata_promise_apkt(u_int8_t *bytep, struct
 	bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_CYL_MSB;
 	bytep[i++] = request->u.ata.lba >> 16;
 	bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_DRIVE;
-	bytep[i++] = (atadev->flags & ATA_D_USE_CHS ? 0 : ATA_D_LBA) |
-		     ATA_D_IBM | ATA_DEV(atadev->unit) |
+	bytep[i++] = ATA_D_LBA | ATA_D_IBM | ATA_DEV(request->unit) |
 		     ((request->u.ata.lba >> 24)&0xf);
     }
     bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_END | ATA_COMMAND;
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-serverworks.c ./sys/dev/ata/chipsets/ata-serverworks.c
--- /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-serverworks.c	2009-06-24 22:49:16.000000000 +0300
+++ ./sys/dev/ata/chipsets/ata-serverworks.c	2009-10-14 15:27:03.000000000 +0300
@@ -228,9 +228,8 @@ static void
 ata_serverworks_tf_read(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
-    struct ata_device *atadev = device_get_softc(request->dev);
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	u_int16_t temp;
 
 	request->u.ata.count = ATA_IDX_INW(ch, ATA_COUNT);
@@ -257,9 +256,11 @@ static void
 ata_serverworks_tf_write(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);
+#ifndef ATA_CAM
     struct ata_device *atadev = device_get_softc(request->dev);
+#endif
 
-    if (atadev->flags & ATA_D_48BIT_ACTIVE) {
+    if (request->flags & ATA_R_48BIT) {
 	ATA_IDX_OUTW(ch, ATA_FEATURE, request->u.ata.feature);
 	ATA_IDX_OUTW(ch, ATA_COUNT, request->u.ata.count);
 	ATA_IDX_OUTW(ch, ATA_SECTOR, ((request->u.ata.lba >> 16) & 0xff00) |
@@ -268,11 +269,12 @@ ata_serverworks_tf_write(struct ata_requ
 				       ((request->u.ata.lba >> 8) & 0x00ff));
 	ATA_IDX_OUTW(ch, ATA_CYL_MSB, ((request->u.ata.lba >> 32) & 0xff00) | 
 				       ((request->u.ata.lba >> 16) & 0x00ff));
-	ATA_IDX_OUTW(ch, ATA_DRIVE, ATA_D_LBA | ATA_DEV(atadev->unit));
+	ATA_IDX_OUTW(ch, ATA_DRIVE, ATA_D_LBA | ATA_DEV(request->unit));
     }
     else {
 	ATA_IDX_OUTW(ch, ATA_FEATURE, request->u.ata.feature);
 	ATA_IDX_OUTW(ch, ATA_COUNT, request->u.ata.count);
+#ifndef ATA_CAM
 	if (atadev->flags & ATA_D_USE_CHS) {
 	    int heads, sectors;
     
@@ -289,18 +291,21 @@ ata_serverworks_tf_write(struct ata_requ
 			 (request->u.ata.lba / (sectors * heads)));
 	    ATA_IDX_OUTW(ch, ATA_CYL_MSB,
 			 (request->u.ata.lba / (sectors * heads)) >> 8);
-	    ATA_IDX_OUTW(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(atadev->unit) | 
+	    ATA_IDX_OUTW(ch, ATA_DRIVE, ATA_D_IBM | ATA_DEV(request->unit) | 
 			 (((request->u.ata.lba% (sectors * heads)) /
 			   sectors) & 0xf));
 	}
 	else {
+#endif
 	    ATA_IDX_OUTW(ch, ATA_SECTOR, request->u.ata.lba);
 	    ATA_IDX_OUTW(ch, ATA_CYL_LSB, request->u.ata.lba >> 8);
 	    ATA_IDX_OUTW(ch, ATA_CYL_MSB, request->u.ata.lba >> 16);
 	    ATA_IDX_OUTW(ch, ATA_DRIVE,
-			 ATA_D_IBM | ATA_D_LBA | ATA_DEV(atadev->unit) |
+			 ATA_D_IBM | ATA_D_LBA | ATA_DEV(request->unit) |
 			 ((request->u.ata.lba >> 24) & 0x0f));
+#ifndef ATA_CAM
 	}
+#endif
     }
 }
 
diff -ruNp --exclude .svn -I FreeBSD /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-siliconimage.c ./sys/dev/ata/chipsets/ata-siliconimage.c
--- /storage/FreeBSD/head/sys/dev/ata/chipsets/ata-siliconimage.c	2009-06-24 22:49:16.000000000 +0300
+++ ./sys/dev/ata/chipsets/ata-siliconimage.c	2009-10-14 15:27:03.000000000 +0300
@@ -340,6 +340,7 @@ ata_sii_ch_attach(device_t dev)
 	ATA_OUTL(ctlr->r_res2, 0x148 + (unit01 << 7) + (unit10 << 8),(1 << 16));
     }
 
+    ch->dma.max_iosize = (ATA_DMA_ENTRIES - 1) * PAGE_SIZE;
     if (ctlr->chip->cfg2 & SII_BUG) {
 	/* work around errata in early chips */
 	ch->dma.boundary = 8192;
@@ -457,7 +458,7 @@ struct ata_siiprb_dma_prdentry {
     u_int32_t control;
 } __packed;
 
-#define ATA_SIIPRB_DMA_ENTRIES		125
+#define ATA_SIIPRB_DMA_ENTRIES		129
 struct ata_siiprb_ata_command {
     struct ata_siiprb_dma_prdentry prd[ATA_SIIPRB_DMA_ENTRIES];
 } __packed;
@@ -542,7 +543,7 @@ ata_siiprb_status(device_t dev)
 static int
 ata_siiprb_begin_transaction(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
     struct ata_siiprb_command *prb;
     struct ata_siiprb_dma_prdentry *prd;
@@ -556,28 +557,25 @@ ata_siiprb_begin_transaction(struct ata_
     }
 
     /* get a piece of the workspace for this request */
-    prb = (struct ata_siiprb_command *)
-	(ch->dma.work + (sizeof(struct ata_siiprb_command) * request->tag));
+    prb = (struct ata_siiprb_command *)ch->dma.work;
 
     /* clear the prb structure */
     bzero(prb, sizeof(struct ata_siiprb_command));
 
     /* setup the FIS for this request */
     if (!ata_request2fis_h2d(request, &prb->fis[0])) {
-        device_printf(request->dev, "setting up SATA FIS failed\n");
+        device_printf(request->parent, "setting up SATA FIS failed\n");
         request->result = EIO;
         return ATA_OP_FINISHED;
     }
 
     /* setup transfer type */
     if (request->flags & ATA_R_ATAPI) {
-        struct ata_device *atadev = device_get_softc(request->dev);
-
 	bcopy(request->u.atapi.ccb, prb->u.atapi.ccb, 16);
-	if ((atadev->param.config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_12)
-	    ATA_OUTL(ctlr->r_res2, 0x1004 + offset, 0x00000020);
-	else
+	if (request->flags & ATA_R_ATAPI16)
 	    ATA_OUTL(ctlr->r_res2, 0x1000 + offset, 0x00000020);
+	else
+	    ATA_OUTL(ctlr->r_res2, 0x1004 + offset, 0x00000020);
 	if (request->flags & ATA_R_READ)
 	    prb->control = htole16(0x0010);
 	if (request->flags & ATA_R_WRITE)
@@ -590,19 +588,16 @@ ata_siiprb_begin_transaction(struct ata_
     /* if request moves data setup and load SG list */
     if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
 	if (ch->dma.load(request, prd, NULL)) {
-	    device_printf(request->dev, "setting up DMA failed\n");
+	    device_printf(request->parent, "setting up DMA failed\n");
 	    request->result = EIO;
 	    return ATA_OP_FINISHED;
 	}
     }
 
     /* activate the prb */
-    prb_bus = ch->dma.work_bus +
-	      (sizeof(struct ata_siiprb_command) * request->tag);
-    ATA_OUTL(ctlr->r_res2,
-	     0x1c00 + offset + (request->tag * sizeof(u_int64_t)), prb_bus);
-    ATA_OUTL(ctlr->r_res2,
-	     0x1c04 + offset + (request->tag * sizeof(u_int64_t)), prb_bus>>32);
+    prb_bus = ch->dma.work_bus;
+    ATA_OUTL(ctlr->r_res2, 0x1c00 + offset, prb_bus);
+    ATA_OUTL(ctlr->r_res2, 0x1c04 + offset, prb_bus>>32);
 
     /* start the timeout */
     callout_reset(&request->callout, request->timeout * hz,
@@ -613,7 +608,7 @@ ata_siiprb_begin_transaction(struct ata_
 static int
 ata_siiprb_end_transaction(struct ata_request *request)
 {
-    struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
+    struct ata_pci_controller *ctlr=device_get_softc(device_get_parent(request->parent));
     struct ata_channel *ch = device_get_softc(request->parent);
     struct ata_siiprb_command *prb;
     int offset = ch->unit * 0x2000;
@@ -623,7 +618,7 @@ ata_siiprb_end_transaction(struct ata_re
     callout_stop(&request->callout);
     
     prb = (struct ata_siiprb_command *)
-	((u_int8_t *)rman_get_virtual(ctlr->r_res2)+(request->tag << 7)+offset);
+	((u_int8_t *)rman_get_virtual(ctlr->r_res2) + offset);
 
     /* any controller errors flagged ? */
     if ((error = ATA_INL(ctlr->r_res2, 0x1024 + offset))) {
@@ -659,12 +654,10 @@ ata_siiprb_end_transaction(struct ata_re
 
     /* on control commands read back registers to the request struct */
     if (request->flags & ATA_R_CONTROL) {
-        struct ata_device *atadev = device_get_softc(request->dev);
-
 	request->u.ata.count = prb->fis[12] | ((u_int16_t)prb->fis[13] << 8);
 	request->u.ata.lba = prb->fis[4] | ((u_int64_t)prb->fis[5] << 8) |
 			     ((u_int64_t)prb->fis[6] << 16);
-	if (atadev->flags & ATA_D_48BIT_ACTIVE)
+	if (request->flags & ATA_R_48BIT)
 	    request->u.ata.lba |= ((u_int64_t)prb->fis[8] << 24) |
 				  ((u_int64_t)prb->fis[9] << 32) |
 				  ((u_int64_t)prb->fis[10] << 40);
@@ -907,6 +900,7 @@ ata_siiprb_dmainit(device_t dev)
     /* note start and stop are not used here */
     ch->dma.setprd = ata_siiprb_dmasetprd;
     ch->dma.max_address = BUS_SPACE_MAXADDR;
+    ch->dma.max_iosize = (ATA_SIIPRB_DMA_ENTRIES - 1) * PAGE_SIZE;
 }
 
 ATA_DECLARE_DRIVER(ata_sii);