Merge bk://kernel.bkbits.net/jgarzik/net-drivers-2.5

into penguin.transmeta.com:/home/penguin/torvalds/repositories/kernel/linux

drivers/block/cciss_scsi.c

@@ -1379,10 +1379,10 @@ cciss_scsi_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *))
 
 	// Get the ptr to our adapter structure (hba[i]) out of cmd->host.
 	// We violate cmd->host privacy here.  (Is there another way?)
-	c = (ctlr_info_t **) &cmd->host->hostdata[0];	
+	c = (ctlr_info_t **) &cmd->device->host->hostdata[0];
 	ctlr = (*c)->ctlr;
 
-	rc = lookup_scsi3addr(ctlr, cmd->channel, cmd->target, cmd->lun, 
+	rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id, cmd->device->lun, 
 			scsi3addr);
 	if (rc != 0) {
 		/* the scsi nexus does not match any that we presented... */

drivers/media/video/tuner-3036.c

@@ -185,22 +185,20 @@ tuner_probe(struct i2c_adapter *adap)
 static struct i2c_driver 
 i2c_driver_tuner = 
 {
-	"sab3036",		/* name       */
-	I2C_DRIVERID_SAB3036,	/* ID         */
-        I2C_DF_NOTIFY,
-	tuner_probe,
-	tuner_detach,
-	tuner_command
+	.owner		=	THIS_MODULE,
+	.name		=	"sab3036",
+	.id		=	I2C_DRIVERID_SAB3036,
+        .flags		=	I2C_DF_NOTIFY,
+	.attach_adapter =	tuner_probe,
+	.detach_client  =	tuner_detach,
+	.command	=	tuner_command
 };
 
 static struct i2c_client client_template =
 {
-        "SAB3036",		/* name       */
-        -1,
-        0,
-        0,
-        NULL,
-        &i2c_driver_tuner
+        .name 		= "SAB3036",
+        .id 		= -1,
+        .driver		= &i2c_driver_tuner
 };
 
 int __init

drivers/message/i2o/Kconfig

@@ -50,19 +50,6 @@ config I2O_BLOCK
 	  whenever you want). If you want to compile it as a module, say M
 	  here and read <file:Documentation/modules.txt>.
 
-config I2O_LAN
-	tristate "I2O LAN OSM"
-	depends on NET && I2O
-	help
-	  Include support for the LAN OSM. You will also need to include
-	  support for token ring or FDDI if you wish to use token ring or FDDI
-	  I2O cards with this driver.
-
-	  This support is also available as a module called i2o_lan ( = code
-	  which can be inserted in and removed from the running kernel
-	  whenever you want). If you want to compile it as a module, say M
-	  here and read <file:Documentation/modules.txt>.
-
 config I2O_SCSI
 	tristate "I2O SCSI OSM"
 	depends on I2O && SCSI

drivers/message/i2o/Makefile

@@ -8,6 +8,5 @@
 obj-$(CONFIG_I2O_PCI)	+= i2o_pci.o
 obj-$(CONFIG_I2O)	+= i2o_core.o i2o_config.o
 obj-$(CONFIG_I2O_BLOCK)	+= i2o_block.o
-obj-$(CONFIG_I2O_LAN)	+= i2o_lan.o
 obj-$(CONFIG_I2O_SCSI)	+= i2o_scsi.o
 obj-$(CONFIG_I2O_PROC)	+= i2o_proc.o

drivers/message/i2o/i2o_scsi.c

@@ -224,7 +224,7 @@ static void i2o_scsi_reply(struct i2o_handler *h, struct i2o_controller *c, stru
 			spin_unlock_irqrestore(&retry_lock, flags);
 			/* Create a scsi error for this */
 			current_command = (Scsi_Cmnd *)m[3];
-			lock = current_command->host->host_lock;
+			lock = current_command->device->host->host_lock;
 			printk("Aborted %ld\n", current_command->serial_number);
 
 			spin_lock_irqsave(lock, flags);
@@ -328,7 +328,7 @@ static void i2o_scsi_reply(struct i2o_handler *h, struct i2o_controller *c, stru
 	else if (current_command->request_bufflen)
 		pci_unmap_single(c->pdev, (dma_addr_t)((long)current_command->SCp.ptr), current_command->request_bufflen, scsi_to_pci_dma_dir(current_command->sc_data_direction));
 
-	lock = current_command->host->host_lock;
+	lock = current_command->device->host->host_lock;
 	spin_lock_irqsave(lock, flags);
 	current_command->scsi_done(current_command);
 	spin_unlock_irqrestore(lock, flags);
@@ -606,7 +606,7 @@ static int i2o_scsi_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 	 *	Do the incoming paperwork
 	 */
 	 
-	host = SCpnt->host;
+	host = SCpnt->device->host;
 	hostdata = (struct i2o_scsi_host *)host->hostdata;
 	 
 	c = hostdata->controller;
@@ -615,13 +615,13 @@ static int i2o_scsi_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 
 	SCpnt->scsi_done = done;
 	
-	if(SCpnt->target > 15)
+	if(SCpnt->device->id > 15)
 	{
-		printk(KERN_ERR "i2o_scsi: Wild target %d.\n", SCpnt->target);
+		printk(KERN_ERR "i2o_scsi: Wild target %d.\n", SCpnt->device->id);
 		return -1;
 	}
 	
-	tid = hostdata->task[SCpnt->target][SCpnt->lun];
+	tid = hostdata->task[SCpnt->device->id][SCpnt->device->lun];
 	
 	dprintk(("qcmd: Tid = %d\n", tid));
 	
@@ -712,10 +712,10 @@ static int i2o_scsi_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 		 *	with tagged queueing. We throw in the odd ordered
 		 *	tag to stop them starving themselves.
 		 */
-		if((jiffies - hostdata->tagclock[SCpnt->target][SCpnt->lun]) > (5*HZ))
+		if((jiffies - hostdata->tagclock[SCpnt->device->id][SCpnt->device->lun]) > (5*HZ))
 		{
 			tag=0x01800000;		/* ORDERED! */
-			hostdata->tagclock[SCpnt->target][SCpnt->lun]=jiffies;
+			hostdata->tagclock[SCpnt->device->id][SCpnt->device->lun]=jiffies;
 		}
 		else
 		{
@@ -916,9 +916,9 @@ int i2o_scsi_abort(Scsi_Cmnd * SCpnt)
 	
 	printk(KERN_WARNING "i2o_scsi: Aborting command block.\n");
 	
-	host = SCpnt->host;
+	host = SCpnt->device->host;
 	hostdata = (struct i2o_scsi_host *)host->hostdata;
-	tid = hostdata->task[SCpnt->target][SCpnt->lun];
+	tid = hostdata->task[SCpnt->device->id][SCpnt->device->lun];
 	if(tid==-1)
 	{
 		printk(KERN_ERR "i2o_scsi: Impossible command to abort!\n");
@@ -982,7 +982,7 @@ static int i2o_scsi_bus_reset(Scsi_Cmnd * SCpnt)
 	 */
 
 	
-	host = SCpnt->host;
+	host = SCpnt->device->host;
 
 	spin_unlock_irq(host->host_lock);
 

drivers/net/depca.c

@@ -252,6 +252,7 @@
 #include <linux/types.h>
 #include <linux/unistd.h>
 #include <linux/ctype.h>
+#include <linux/mca-legacy.h>
 
 #include <asm/uaccess.h>
 #include <asm/bitops.h>

drivers/net/eexpress.c

@@ -114,6 +114,7 @@
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/mca.h>
+#include <linux/mca-legacy.h>
 #include <linux/spinlock.h>
 
 #include <asm/system.h>

drivers/net/fc/iph5526.c

@@ -3913,9 +3913,9 @@ int iph5526_queuecommand(Scsi_Cmnd *Cmnd, void (*done) (Scsi_Cmnd *))
 int int_required = 0;
 u_int r_ctl = FC4_DEVICE_DATA | UNSOLICITED_COMMAND;
 u_int type = TYPE_FCP | SEQUENCE_INITIATIVE;
-u_int frame_class = Cmnd->target;
+u_int frame_class = Cmnd->device->id;
 u_short ox_id = OX_ID_FIRST_SEQUENCE;
-struct Scsi_Host *host = Cmnd->host;
+struct Scsi_Host *host = Cmnd->device->host;
 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata*)host->hostdata;
 struct fc_info *fi = hostdata->fi;
 struct fc_node_info *q;
@@ -3937,9 +3937,9 @@ u_long flags;
 				hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_ORDERED;
 				break;
 			default:
-				if ((jiffies - hostdata->tag_ages[Cmnd->target]) > (5 * HZ)) {
+				if ((jiffies - hostdata->tag_ages[Cmnd->device->id]) > (5 * HZ)) {
 					hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_ORDERED;
-					hostdata->tag_ages[Cmnd->target] = jiffies;
+					hostdata->tag_ages[Cmnd->device->id] = jiffies;
 				}
 				else
 					hostdata->cmnd.fcp_cntl = FCP_CNTL_QTYPE_SIMPLE;
@@ -3953,7 +3953,7 @@ u_long flags;
 	hostdata->cmnd.fcp_addr[3] = 0;
 	hostdata->cmnd.fcp_addr[2] = 0;
 	hostdata->cmnd.fcp_addr[1] = 0;
-	hostdata->cmnd.fcp_addr[0] = htons(Cmnd->lun);
+	hostdata->cmnd.fcp_addr[0] = htons(Cmnd->device->lun);
 
 	memcpy(&hostdata->cmnd.fcp_cdb, Cmnd->cmnd, Cmnd->cmd_len);
 	hostdata->cmnd.fcp_data_len = htonl(Cmnd->request_bufflen);
@@ -3985,7 +3985,7 @@ u_long flags;
 	
 	memcpy(fi->q.ptr_fcp_cmnd[fi->q.fcp_cmnd_indx], &(hostdata->cmnd), sizeof(fcp_cmd));	
 	
-	q = resolve_target(fi, Cmnd->target);
+	q = resolve_target(fi, Cmnd->device->id);
 
 	if (q == NULL) {
 	u_int bad_id = fi->g.my_ddaa | 0xFE;
@@ -4022,7 +4022,7 @@ u_long flags;
 
 int iph5526_abort(Scsi_Cmnd *Cmnd)
 {
-struct Scsi_Host *host = Cmnd->host;
+struct Scsi_Host *host = Cmnd->device->host;
 struct iph5526_hostdata *hostdata = (struct iph5526_hostdata *)host->hostdata;
 struct fc_info *fi = hostdata->fi;
 struct fc_node_info *q;
@@ -4036,7 +4036,7 @@ u_long flags;
 	
 	spin_lock_irqsave(&fi->fc_lock, flags);
 	
-	q = resolve_target(fi, Cmnd->target);
+	q = resolve_target(fi, Cmnd->device->id);
 	if (q == NULL) {
 	u_int bad_id = fi->g.my_ddaa | 0xFE;
 		/* This should not happen as we should always be able to

drivers/net/starfire.c

@@ -339,7 +339,7 @@ do { \
 		intr_enable = readl(ioaddr + IntrEnable); \
 		intr_enable &= ~(IntrRxDone | IntrRxEmpty); \
 		writel(intr_enable, ioaddr + IntrEnable); \
-		readl(ioaddr + IntrEnable); \	/* flush PCI posting buffers */
+		readl(ioaddr + IntrEnable); /* flush PCI posting buffers */ \
 	} else { \
 		/* Paranoia check */ \
 		intr_enable = readl(ioaddr + IntrEnable); \

drivers/scsi/NCR53c406a.c

@@ -697,7 +697,7 @@ static int NCR53c406a_queue(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 
 	/* We are locked here already by the mid layer */
 	REG0;
-	outb(SCpnt->target, DEST_ID);	/* set destination */
+	outb(SCpnt->device->id, DEST_ID);	/* set destination */
 	outb(FLUSH_FIFO, CMD_REG);	/* reset the fifos */
 
 	for (i = 0; i < SCpnt->cmd_len; i++) {

drivers/scsi/aha1740.c

@@ -315,8 +315,8 @@ static int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
 {
     unchar direction;
     unchar *cmd = (unchar *) SCpnt->cmnd;
-    unchar target = SCpnt->target;
-    struct aha1740_hostdata *host = HOSTDATA(SCpnt->host);
+    unchar target = SCpnt->device->id;
+    struct aha1740_hostdata *host = HOSTDATA(SCpnt->device->host);
     unsigned long flags;
     void *buff = SCpnt->request_buffer;
     int bufflen = SCpnt->request_bufflen;
@@ -416,7 +416,7 @@ static int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
 	host->ecb[ecbno].datalen = bufflen;
 	host->ecb[ecbno].dataptr = isa_virt_to_bus(buff);
     }
-    host->ecb[ecbno].lun = SCpnt->lun;
+    host->ecb[ecbno].lun = SCpnt->device->lun;
     host->ecb[ecbno].ses = 1;	/* Suppress underrun errors */
     host->ecb[ecbno].dir = direction;
     host->ecb[ecbno].ars = 1;  /* Yes, get the sense on an error */
@@ -449,7 +449,7 @@ static int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
 #define LOOPCNT_WARN 10		/* excessive mbxout wait -> syslog-msg */
 #define LOOPCNT_MAX 1000000	/* mbxout deadlock -> panic() after ~ 2 sec. */
 	int loopcnt;
-	unsigned int base = SCpnt->host->io_port;
+	unsigned int base = SCpnt->device->host->io_port;
 	DEB(printk("aha1740[%d] critical section\n",ecbno));
 
 	spin_lock_irqsave(&aha1740_lock, flags);

drivers/scsi/fd_mcs.c

@@ -87,6 +87,7 @@
 #include <linux/delay.h>
 #include <linux/mca.h>
 #include <linux/spinlock.h>
+#include <linux/mca-legacy.h>
 
 #include <asm/io.h>
 #include <asm/system.h>
@@ -732,7 +733,7 @@ static void fd_mcs_intr(int irq, void *dev_id, struct pt_regs *regs)
 		outb(0x40 | FIFO_COUNT, Interrupt_Cntl_port);
 
 		outb(0x82, SCSI_Cntl_port);	/* Bus Enable + Select */
-		outb(adapter_mask | (1 << current_SC->target), SCSI_Data_NoACK_port);
+		outb(adapter_mask | (1 << current_SC->device->id), SCSI_Data_NoACK_port);
 
 		/* Stop arbitration and enable parity */
 		outb(0x10 | PARITY_MASK, TMC_Cntl_port);
@@ -744,7 +745,7 @@ static void fd_mcs_intr(int irq, void *dev_id, struct pt_regs *regs)
 		status = inb(SCSI_Status_port);
 		if (!(status & 0x01)) {
 			/* Try again, for slow devices */
-			if (fd_mcs_select(shpnt, current_SC->target)) {
+			if (fd_mcs_select(shpnt, current_SC->device->id)) {
 #if EVERY_ACCESS
 				printk(" SFAIL ");
 #endif
@@ -802,7 +803,7 @@ static void fd_mcs_intr(int irq, void *dev_id, struct pt_regs *regs)
 #endif
 #if ERRORS_ONLY
 			if (current_SC->SCp.Status && current_SC->SCp.Status != 2 && current_SC->SCp.Status != 8) {
-				printk("ERROR fd_mcs: target = %d, command = %x, status = %x\n", current_SC->target, current_SC->cmnd[0], current_SC->SCp.Status);
+				printk("ERROR fd_mcs: target = %d, command = %x, status = %x\n", current_SC->device->id, current_SC->cmnd[0], current_SC->SCp.Status);
 			}
 #endif
 			break;
@@ -1150,7 +1151,7 @@ static int fd_mcs_release(struct Scsi_Host *shpnt)
 
 static int fd_mcs_queue(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 {
-	struct Scsi_Host *shpnt = SCpnt->host;
+	struct Scsi_Host *shpnt = SCpnt->device->host;
 
 	if (in_command) {
 		panic("fd_mcs: fd_mcs_queue() NOT REENTRANT!\n");
@@ -1243,7 +1244,7 @@ static void fd_mcs_print_info(Scsi_Cmnd * SCpnt)
 		break;
 	}
 
-	printk("(%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n", SCpnt->SCp.phase, SCpnt->target, *(unsigned char *) SCpnt->cmnd, SCpnt->use_sg, SCpnt->request_bufflen);
+	printk("(%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n", SCpnt->SCp.phase, SCpnt->device->id, *(unsigned char *) SCpnt->cmnd, SCpnt->use_sg, SCpnt->request_bufflen);
 	printk("sent_command = %d, have_data_in = %d, timeout = %d\n", SCpnt->SCp.sent_command, SCpnt->SCp.have_data_in, SCpnt->timeout);
 #if DEBUG_RACE
 	printk("in_interrupt_flag = %d\n", in_interrupt_flag);
@@ -1286,7 +1287,7 @@ static void fd_mcs_print_info(Scsi_Cmnd * SCpnt)
 
 static int fd_mcs_abort(Scsi_Cmnd * SCpnt)
 {
-	struct Scsi_Host *shpnt = SCpnt->host;
+	struct Scsi_Host *shpnt = SCpnt->device->host;
 
 	unsigned long flags;
 #if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
@@ -1331,7 +1332,7 @@ static int fd_mcs_device_reset(Scsi_Cmnd * SCpnt)
 }
 
 static int fd_mcs_bus_reset(Scsi_Cmnd * SCpnt) {
-	struct Scsi_Host *shpnt = SCpnt->host;
+	struct Scsi_Host *shpnt = SCpnt->device->host;
 
 #if DEBUG_RESET
 	static int called_once = 0;

drivers/scsi/ibmmca.c

@@ -39,6 +39,7 @@
 #include <linux/string.h>
 #include <linux/spinlock.h>
 #include <linux/init.h>
+#include <linux/mca-legacy.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
@@ -668,8 +669,8 @@ static void interrupt_handler(int irq, void *dev_id, struct pt_regs *regs)
 	ld(ihost_index)[ldn].cmd = NULL;
 #ifdef IM_DEBUG_TIMEOUT
 	if (cmd) {
-		if ((cmd->target == TIMEOUT_PUN) && (cmd->lun == TIMEOUT_LUN)) {
-			printk("IBM MCA SCSI: Ignoring interrupt from pun=%x, lun=%x.\n", cmd->target, cmd->lun);
+		if ((cmd->target == TIMEOUT_PUN) && (cmd->device->lun == TIMEOUT_LUN)) {
+			printk("IBM MCA SCSI: Ignoring interrupt from pun=%x, lun=%x.\n", cmd->target, cmd->device->lun);
 			return;
 		}
 	}
@@ -1824,7 +1825,7 @@ static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 	int i;
 	struct scatterlist *sl;
 
-	shpnt = cmd->host;
+	shpnt = cmd->device->host;
 	/* search for the right hostadapter */
 	for (host_index = 0; hosts[host_index] && hosts[host_index]->host_no != shpnt->host_no; host_index++);
 
@@ -1836,16 +1837,16 @@ static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 	}
 	max_pun = subsystem_maxid(host_index);
 	if (ibm_ansi_order) {
-		target = max_pun - 1 - cmd->target;
-		if ((target <= subsystem_pun(host_index)) && (cmd->target <= subsystem_pun(host_index)))
+		target = max_pun - 1 - cmd->device->id;
+		if ((target <= subsystem_pun(host_index)) && (cmd->device->id <= subsystem_pun(host_index)))
 			target--;
-		else if ((target >= subsystem_pun(host_index)) && (cmd->target >= subsystem_pun(host_index)))
+		else if ((target >= subsystem_pun(host_index)) && (cmd->device->id >= subsystem_pun(host_index)))
 			target++;
 	} else
-		target = cmd->target;
+		target = cmd->device->id;
 
 	/* if (target,lun) is NO LUN or not existing at all, return error */
-	if ((get_scsi(host_index)[target][cmd->lun] == TYPE_NO_LUN) || (get_scsi(host_index)[target][cmd->lun] == TYPE_NO_DEVICE)) {
+	if ((get_scsi(host_index)[target][cmd->device->lun] == TYPE_NO_LUN) || (get_scsi(host_index)[target][cmd->device->lun] == TYPE_NO_DEVICE)) {
 		cmd->result = DID_NO_CONNECT << 16;
 		if (done)
 			done(cmd);
@@ -1853,7 +1854,7 @@ static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 	}
 
 	/*if (target,lun) unassigned, do further checks... */
-	ldn = get_ldn(host_index)[target][cmd->lun];
+	ldn = get_ldn(host_index)[target][cmd->device->lun];
 	if (ldn >= MAX_LOG_DEV) {	/* on invalid ldn do special stuff */
 		if (ldn > MAX_LOG_DEV) {	/* dynamical remapping if ldn unassigned */
 			current_ldn = next_ldn(host_index);	/* stop-value for one circle */
@@ -1864,7 +1865,7 @@ static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 					next_ldn(host_index) = 7;
 				if (current_ldn == next_ldn(host_index)) {	/* One circle done ? */
 					/* no non-processing ldn found */
-					printk("IBM MCA SCSI: Cannot assign SCSI-device dynamically!\n" "              On ldn 7-14 SCSI-commands everywhere in progress.\n" "              Reporting DID_NO_CONNECT for device (%d,%d).\n", target, cmd->lun);
+					printk("IBM MCA SCSI: Cannot assign SCSI-device dynamically!\n" "              On ldn 7-14 SCSI-commands everywhere in progress.\n" "              Reporting DID_NO_CONNECT for device (%d,%d).\n", target, cmd->device->lun);
 					cmd->result = DID_NO_CONNECT << 16;	/* return no connect */
 					if (done)
 						done(cmd);
@@ -1884,26 +1885,26 @@ static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 			/* set reduced interrupt_handler-mode for checking */
 			local_checking_phase_flag(host_index) = 1;
 			/* map found ldn to pun,lun */
-			get_ldn(host_index)[target][cmd->lun] = next_ldn(host_index);
+			get_ldn(host_index)[target][cmd->device->lun] = next_ldn(host_index);
 			/* change ldn to the right value, that is now next_ldn */
 			ldn = next_ldn(host_index);
 			/* unassign all ldns (pun,lun,ldn does not matter for remove) */
 			immediate_assign(host_index, 0, 0, 0, REMOVE_LDN);
 			/* set only LDN for remapped device */
-			immediate_assign(host_index, target, cmd->lun, ldn, SET_LDN);
+			immediate_assign(host_index, target, cmd->device->lun, ldn, SET_LDN);
 			/* get device information for ld[ldn] */
 			if (device_exists(host_index, ldn, &ld(host_index)[ldn].block_length, &ld(host_index)[ldn].device_type)) {
 				ld(host_index)[ldn].cmd = NULL;	/* To prevent panic set 0, because
 								   devices that were not assigned,
 								   should have nothing in progress. */
-				get_scsi(host_index)[target][cmd->lun] = ld(host_index)[ldn].device_type;
+				get_scsi(host_index)[target][cmd->device->lun] = ld(host_index)[ldn].device_type;
 				/* increase assignment counters for statistics in /proc */
 				IBM_DS(host_index).dynamical_assignments++;
 				IBM_DS(host_index).ldn_assignments[ldn]++;
 			} else
 				/* panic here, because a device, found at boottime has
 				   vanished */
-				panic("IBM MCA SCSI: ldn=0x%x, SCSI-device on (%d,%d) vanished!\n", ldn, target, cmd->lun);
+				panic("IBM MCA SCSI: ldn=0x%x, SCSI-device on (%d,%d) vanished!\n", ldn, target, cmd->device->lun);
 			/* unassign again all ldns (pun,lun,ldn does not matter for remove) */
 			immediate_assign(host_index, 0, 0, 0, REMOVE_LDN);
 			/* remap all ldns, as written in the pun/lun table */
@@ -1919,7 +1920,7 @@ static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 			local_checking_phase_flag(host_index) = 0;
 #ifdef IM_DEBUG_PROBE
 			/* Information on syslog terminal */
-			printk("IBM MCA SCSI: ldn=0x%x dynamically reassigned to (%d,%d).\n", ldn, target, cmd->lun);
+			printk("IBM MCA SCSI: ldn=0x%x dynamically reassigned to (%d,%d).\n", ldn, target, cmd->device->lun);
 #endif
 			/* increase next_ldn for next dynamical assignment */
 			next_ldn(host_index)++;
@@ -2141,7 +2142,7 @@ static int ibmmca_abort(Scsi_Cmnd * cmd)
 	printk("IBM MCA SCSI: Abort subroutine called...\n");
 #endif
 
-	shpnt = cmd->host;
+	shpnt = cmd->device->host;
 	/* search for the right hostadapter */
 	for (host_index = 0; hosts[host_index] && hosts[host_index]->host_no != shpnt->host_no; host_index++);
 
@@ -2149,7 +2150,7 @@ static int ibmmca_abort(Scsi_Cmnd * cmd)
 		cmd->result = DID_NO_CONNECT << 16;
 		if (cmd->scsi_done)
 			(cmd->scsi_done) (cmd);
-		shpnt = cmd->host;
+		shpnt = cmd->device->host;
 #ifdef IM_DEBUG_PROBE
 		printk(KERN_DEBUG "IBM MCA SCSI: Abort adapter selection failed!\n");
 #endif
@@ -2157,17 +2158,17 @@ static int ibmmca_abort(Scsi_Cmnd * cmd)
 	}
 	max_pun = subsystem_maxid(host_index);
 	if (ibm_ansi_order) {
-		target = max_pun - 1 - cmd->target;
-		if ((target <= subsystem_pun(host_index)) && (cmd->target <= subsystem_pun(host_index)))
+		target = max_pun - 1 - cmd->device->id;
+		if ((target <= subsystem_pun(host_index)) && (cmd->device->id <= subsystem_pun(host_index)))
 			target--;
-		else if ((target >= subsystem_pun(host_index)) && (cmd->target >= subsystem_pun(host_index)))
+		else if ((target >= subsystem_pun(host_index)) && (cmd->device->id >= subsystem_pun(host_index)))
 			target++;
 	} else
-		target = cmd->target;
+		target = cmd->device->id;
 
 	/* get logical device number, and disable system interrupts */
-	printk(KERN_WARNING "IBM MCA SCSI: Sending abort to device pun=%d, lun=%d.\n", target, cmd->lun);
-	ldn = get_ldn(host_index)[target][cmd->lun];
+	printk(KERN_WARNING "IBM MCA SCSI: Sending abort to device pun=%d, lun=%d.\n", target, cmd->device->lun);
+	ldn = get_ldn(host_index)[target][cmd->device->lun];
 
 	/*if cmd for this ldn has already finished, no need to abort */
 	if (!ld(host_index)[ldn].cmd) {
@@ -2242,7 +2243,7 @@ static int ibmmca_host_reset(Scsi_Cmnd * cmd)
 		BUG();
 
 	ticks = IM_RESET_DELAY * HZ;
-	shpnt = cmd->host;
+	shpnt = cmd->device->host;
 	/* search for the right hostadapter */
 	for (host_index = 0; hosts[host_index] && hosts[host_index]->host_no != shpnt->host_no; host_index++);
 

drivers/scsi/ppa.c

@@ -148,7 +148,7 @@ int ppa_detect(Scsi_Host_Template * host)
 		      "pardevice is owning the port for too longtime!\n",
 			   i);
 		    parport_unregister_device(ppa_hosts[i].dev);
-		    spin_lock_irq(ppa_hosts[i].cur_cmd->host->host_lock);
+		    spin_lock_irq(ppa_hosts[i].cur_cmd->device->host->host_lock);
 		    return 0;
 		}
 	    }
@@ -635,7 +635,7 @@ static int ppa_init(int host_no)
 
 static inline int ppa_send_command(Scsi_Cmnd * cmd)
 {
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
     int k;
 
     w_ctr(PPA_BASE(host_no), 0x0c);
@@ -661,7 +661,7 @@ static int ppa_completion(Scsi_Cmnd * cmd)
      *  0     Told to schedule
      *  1     Finished data transfer
      */
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
     unsigned short ppb = PPA_BASE(host_no);
     unsigned long start_jiffies = jiffies;
 
@@ -752,7 +752,7 @@ static int ppa_completion(Scsi_Cmnd * cmd)
 int ppa_command(Scsi_Cmnd * cmd)
 {
     static int first_pass = 1;
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
 
     if (first_pass) {
 	printk("ppa: using non-queuing interface\n");
@@ -774,7 +774,7 @@ int ppa_command(Scsi_Cmnd * cmd)
 	schedule();
 
     if (cmd->SCp.phase)		/* Only disconnect if we have connected */
-	ppa_disconnect(cmd->host->unique_id);
+	ppa_disconnect(cmd->device->host->unique_id);
 
     ppa_pb_release(host_no);
     ppa_hosts[host_no].cur_cmd = 0;
@@ -807,7 +807,7 @@ static void ppa_interrupt(void *data)
     case DID_OK:
 	break;
     case DID_NO_CONNECT:
-	printk("ppa: no device at SCSI ID %i\n", cmd->target);
+	printk("ppa: no device at SCSI ID %i\n", cmd->device->target);
 	break;
     case DID_BUS_BUSY:
 	printk("ppa: BUS BUSY - EPP timeout detected\n");
@@ -836,21 +836,21 @@ static void ppa_interrupt(void *data)
 #endif
 
     if (cmd->SCp.phase > 1)
-	ppa_disconnect(cmd->host->unique_id);
+	ppa_disconnect(cmd->device->host->unique_id);
     if (cmd->SCp.phase > 0)
-	ppa_pb_release(cmd->host->unique_id);
+	ppa_pb_release(cmd->device->host->unique_id);
 
     tmp->cur_cmd = 0;
     
-    spin_lock_irqsave(cmd->host->host_lock, flags);
+    spin_lock_irqsave(cmd->device->host->host_lock, flags);
     cmd->scsi_done(cmd);
-    spin_unlock_irqrestore(cmd->host->host_lock, flags);
+    spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
     return;
 }
 
 static int ppa_engine(ppa_struct * tmp, Scsi_Cmnd * cmd)
 {
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
     unsigned short ppb = PPA_BASE(host_no);
     unsigned char l = 0, h = 0;
     int retv;
@@ -900,7 +900,7 @@ static int ppa_engine(ppa_struct * tmp, Scsi_Cmnd * cmd)
 	}
 
     case 2:			/* Phase 2 - We are now talking to the scsi bus */
-	if (!ppa_select(host_no, cmd->target)) {
+	if (!ppa_select(host_no, cmd->device->id)) {
 	    ppa_fail(host_no, DID_NO_CONNECT);
 	    return 0;
 	}
@@ -966,7 +966,7 @@ static int ppa_engine(ppa_struct * tmp, Scsi_Cmnd * cmd)
 
 int ppa_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 {
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
 
     if (ppa_hosts[host_no].cur_cmd) {
 	printk("PPA: bug in ppa_queuecommand\n");
@@ -1011,7 +1011,7 @@ int ppa_biosparam(struct scsi_device *sdev, struct block_device *dev,
 
 int ppa_abort(Scsi_Cmnd * cmd)
 {
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
     /*
      * There is no method for aborting commands since Iomega
      * have tied the SCSI_MESSAGE line high in the interface
@@ -1039,7 +1039,7 @@ static void ppa_reset_pulse(unsigned int base)
 
 int ppa_reset(Scsi_Cmnd * cmd)
 {
-    int host_no = cmd->host->unique_id;
+    int host_no = cmd->device->host->unique_id;
 
     if (cmd->SCp.phase)
 	ppa_disconnect(host_no);

drivers/scsi/seagate.c

@@ -683,8 +683,8 @@ static int seagate_st0x_queue_command (Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmn
 
 	DANY ("seagate: que_command");
 	done_fn = done;
-	current_target = SCpnt->target;
-	current_lun = SCpnt->lun;
+	current_target = SCpnt->device->id;
+	current_lun = SCpnt->device->lun;
 	current_cmnd = SCpnt->cmnd;
 	current_data = (unsigned char *) SCpnt->request_buffer;
 	current_bufflen = SCpnt->request_bufflen;
@@ -713,7 +713,7 @@ static int seagate_st0x_queue_command (Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmn
 #endif				/* LINKED */
 			reconnect = CAN_RECONNECT;
 
-		result = internal_command(SCint->target, SCint->lun, SCint->cmnd,
+		result = internal_command(SCint->device->id, SCint->device->lun, SCint->cmnd,
 				      SCint->request_buffer, SCint->request_bufflen, reconnect);
 		if (msg_byte(result) == DISCONNECT)
 			break;
@@ -729,7 +729,7 @@ static int seagate_st0x_queue_command (Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmn
 
 static int seagate_st0x_command(Scsi_Cmnd * SCpnt)
 {
-	return internal_command (SCpnt->target, SCpnt->lun, SCpnt->cmnd,
+	return internal_command (SCpnt->device->id, SCpnt->device->lun, SCpnt->cmnd,
 				 SCpnt->request_buffer, SCpnt->request_bufflen,
 				 (int) NO_RECONNECT);
 }

drivers/scsi/sym53c416.c

@@ -763,7 +763,7 @@ int sym53c416_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
 	int i;
 
 	/* Store base register as we can have more than one controller in the system */
-	base = SCpnt->host->io_port;
+	base = SCpnt->device->host->io_port;
 	current_command = SCpnt;                  /* set current command                */
 	current_command->scsi_done = done;        /* set ptr to done function           */
 	current_command->SCp.phase = command_ph;  /* currect phase is the command phase */
@@ -771,7 +771,7 @@ int sym53c416_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
 	current_command->SCp.Message = 0;
 
 	spin_lock_irqsave(&sym53c416_lock, flags);
-	outb(SCpnt->target, base + DEST_BUS_ID); /* Set scsi id target        */
+	outb(SCpnt->device->id, base + DEST_BUS_ID); /* Set scsi id target        */
 	outb(FLUSH_FIFO, base + COMMAND_REG);    /* Flush SCSI and PIO FIFO's */
 	/* Write SCSI command into the SCSI fifo */
 	for(i = 0; i < SCpnt->cmd_len; i++)
@@ -819,7 +819,7 @@ static int sym53c416_host_reset(Scsi_Cmnd *SCpnt)
 	int i;
 
 	/* printk("sym53c416_reset\n"); */
-	base = SCpnt->host->io_port;
+	base = SCpnt->device->host->io_port;
 	/* search scsi_id - fixme, we shouldnt need to iterate for this! */
 	for(i = 0; i < host_index && scsi_id != -1; i++)
 		if(hosts[i].base == base)

drivers/scsi/ultrastor.c

@@ -504,7 +504,7 @@ static int ultrastor_14f_detect(Scsi_Host_Template * tpnt)
      * Brrr, &config.mscp[0].SCint->host) it is something magical....
      * XXX and FIXME
      */
-    if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", &config.mscp[0].SCint->host)) {
+    if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", &config.mscp[0].SCint->device->host)) {
 	printk("Unable to allocate IRQ%u for UltraStor controller.\n",
 	       config.interrupt);
 	goto out_release_port;
@@ -714,9 +714,9 @@ static int ultrastor_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
 
        ???  Which other device types should never use the cache?   */
     my_mscp->ca = SCpnt->device->type != TYPE_TAPE;
-    my_mscp->target_id = SCpnt->target;
+    my_mscp->target_id = SCpnt->device->id;
     my_mscp->ch_no = 0;
-    my_mscp->lun = SCpnt->lun;
+    my_mscp->lun = SCpnt->device->lun;
     if (SCpnt->use_sg) {
 	/* Set scatter/gather flag in SCSI command packet */
 	my_mscp->sg = TRUE;
@@ -832,7 +832,7 @@ static int ultrastor_abort(Scsi_Cmnd *SCpnt)
     unsigned char old_aborted;
     unsigned long flags;
     void (*done)(Scsi_Cmnd *);
-    struct Scsi_Host *host = SCpnt->host;
+    struct Scsi_Host *host = SCpnt->device->host;
 
     if(config.slot) 
       return FAILED;  /* Do not attempt an abort for the 24f */
@@ -954,7 +954,7 @@ static int ultrastor_host_reset(Scsi_Cmnd * SCpnt)
 {
     unsigned long flags;
     int i;
-    struct Scsi_Host *host = SCpnt->host;
+    struct Scsi_Host *host = SCpnt->device->host;
     
 #if (ULTRASTOR_DEBUG & UD_RESET)
     printk("US14F: reset: called\n");

drivers/scsi/wd7000.c

@@ -1122,13 +1122,13 @@ static int wd7000_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 	register unchar *cdb = (unchar *) SCpnt->cmnd;
 	register unchar idlun;
 	register short cdblen;
-	Adapter *host = (Adapter *) SCpnt->host->hostdata;
+	Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
 
 	cdblen = SCpnt->cmd_len;
-	idlun = ((SCpnt->target << 5) & 0xe0) | (SCpnt->lun & 7);
+	idlun = ((SCpnt->device->id << 5) & 0xe0) | (SCpnt->device->lun & 7);
 	SCpnt->scsi_done = done;
 	SCpnt->SCp.phase = 1;
-	scb = alloc_scbs(SCpnt->host, 1);
+	scb = alloc_scbs(SCpnt->device->host, 1);
 	scb->idlun = idlun;
 	memcpy(scb->cdb, cdb, cdblen);
 	scb->direc = 0x40;	/* Disable direction check */
@@ -1141,7 +1141,7 @@ static int wd7000_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 		struct scatterlist *sg = (struct scatterlist *) SCpnt->request_buffer;
 		unsigned i;
 
-		if (SCpnt->host->sg_tablesize == SG_NONE) {
+		if (SCpnt->device->host->sg_tablesize == SG_NONE) {
 			panic("wd7000_queuecommand: scatter/gather not supported.\n");
 		}
 		dprintk("Using scatter/gather with %d elements.\n", SCpnt->use_sg);
@@ -1646,7 +1646,7 @@ static int wd7000_detect(Scsi_Host_Template * tpnt)
  */
 static int wd7000_abort(Scsi_Cmnd * SCpnt)
 {
-	Adapter *host = (Adapter *) SCpnt->host->hostdata;
+	Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
 
 	if (inb(host->iobase + ASC_STAT) & INT_IM) {
 		printk("wd7000_abort: lost interrupt\n");
@@ -1677,7 +1677,7 @@ static int wd7000_device_reset(Scsi_Cmnd * SCpnt)
 
 static int wd7000_host_reset(Scsi_Cmnd * SCpnt)
 {
-	Adapter *host = (Adapter *) SCpnt->host->hostdata;
+	Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
 
 	if (wd7000_adapter_reset(host) < 0)
 		return FAILED;

include/linux/mca-legacy.h

@@ -7,6 +7,8 @@
 #ifndef _LINUX_MCA_LEGACY_H
 #define _LINUX_MCA_LEGACY_H
 
+#warning "MCA legacy - please move your driver to the new sysfs api"
+
 /* MCA_NOTFOUND is an error condition.  The other two indicate
  * motherboard POS registers contain the adapter.  They might be
  * returned by the mca_find_adapter() function, and can be used as