v2.4.7.2 -> v2.4.7.3

  - Ben Collins: 1394 updates
  - Matthew Dharm: USB storage update
  - Ion Badulescu: starfire driver update
  - VM aging cleanups

Makefile

 VERSION = 2
 PATCHLEVEL = 4
 SUBLEVEL = 8
-EXTRAVERSION =-pre2
+EXTRAVERSION =-pre3
 
 KERNELRELEASE=$(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)
 

drivers/ieee1394/hosts.c

@@ -147,10 +147,6 @@ static void init_hosts(struct hpsb_host_template *tmpl)
         int count;
         struct hpsb_host *host;
 
-	/* PCI cards should register one host at a time */
-	if (tmpl->detect_hosts == NULL)
-		return;
-
         count = tmpl->detect_hosts(tmpl);
 
         for (host = tmpl->hosts; host != NULL; host = host->next) {
@@ -254,8 +250,13 @@ static int remove_template(struct hpsb_host_template *tmpl)
 int hpsb_register_lowlevel(struct hpsb_host_template *tmpl)
 {
         add_template(tmpl);
-        HPSB_DEBUG("Registered %s driver, initializing now", tmpl->name);
-        init_hosts(tmpl);
+
+	/* PCI cards should be smart and use the PCI detection layer, and
+	 * not this one shot deal. detect_hosts() will be obsoleted soon. */
+	if (tmpl->detect_hosts != NULL) {
+		HPSB_DEBUG("Registered %s driver, initializing now", tmpl->name);
+		init_hosts(tmpl);
+	}
 
         return 0;
 }

drivers/ieee1394/ieee1394_core.c

@@ -293,12 +293,13 @@ static void build_speed_map(struct hpsb_host *host, int nodecount)
 void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid)
 {
         if (host->in_bus_reset) {
-                HPSB_DEBUG("Including SelfID 0x%x", sid);
+#ifdef CONFIG_IEEE1394_VERBOSEDEBUG
+                HPSB_INFO("Including SelfID 0x%x", sid);
+#endif
                 host->topology_map[host->selfid_count++] = sid;
         } else {
-                /* FIXME - info on which host */
-                HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from %s",
-			    sid, host->template->name);
+                HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d",
+			    sid, (host->node_id & BUS_MASK) >> 6);
         }
 }
 

drivers/ieee1394/ieee1394_syms.c

@@ -76,5 +76,5 @@ EXPORT_SYMBOL(highlevel_remove_host);
 EXPORT_SYMBOL(highlevel_host_reset);
 EXPORT_SYMBOL(highlevel_add_one_host);
 EXPORT_SYMBOL(hpsb_guid_get_handle);
-EXPORT_SYMBOL(hpsb_get_host_by_ge);
+EXPORT_SYMBOL(hpsb_get_host_by_ne);
 EXPORT_SYMBOL(hpsb_guid_fill_packet);

drivers/ieee1394/nodemgr.c

@@ -39,18 +39,31 @@
  * XXX: Most of this isn't done yet :)  */
 
 
-static atomic_t outstanding_requests;
-
 static LIST_HEAD(node_list);
 rwlock_t node_lock = RW_LOCK_UNLOCKED;
 
 static LIST_HEAD(host_info_list);
 spinlock_t host_info_lock = SPIN_LOCK_UNLOCKED;
 
+struct bus_options {
+	u8	irmc;		/* Iso Resource Manager Capable */
+	u8	cmc;		/* Cycle Master Capable */
+	u8	isc;		/* Iso Capable */
+	u8	bmc;		/* Bus Master Capable */
+	u8	pmc;		/* Power Manager Capable (PNP spec) */
+	u8	cyc_clk_acc;	/* Cycle clock accuracy */
+	u8	generation;	/* Incremented when configrom changes */
+	u8	lnkspd;		/* Link speed */
+	u16	max_rec;	/* Maximum packet size node can receive */
+	atomic_t changed;	/* We set this to 1 if generation has changed */
+};
+
 struct host_info {
 	struct hpsb_host *host;
-	int pid;
-	wait_queue_head_t reset_wait;
+	pid_t pid;			/* PID of the nodemgr thread */
+	pid_t ppid;			/* Parent PID for the thread */
+	struct tq_struct task;		/* Used to kickstart the thread */
+	wait_queue_head_t reset_wait;	/* Wait queue awoken on bus reset */
 	struct list_head list;
 };
 
@@ -62,70 +75,126 @@ struct node_entry {
 
         struct hpsb_host *host;
         nodeid_t node_id;
-        
+
+	struct bus_options busopt;
+
         atomic_t generation;
 };
 
 static struct node_entry *create_node_entry(void)
 {
-        struct node_entry *ge;
+        struct node_entry *ne;
         unsigned long flags;
 
-        ge = kmalloc(sizeof(struct node_entry), SLAB_ATOMIC);
-        if (!ge) return NULL;
+        ne = kmalloc(sizeof(struct node_entry), SLAB_ATOMIC);
+        if (!ne) return NULL;
 
-        INIT_LIST_HEAD(&ge->list);
-        atomic_set(&ge->refcount, 0);
-        ge->guid = (u64) -1;
-        ge->host = NULL;
-        ge->node_id = 0;
-        atomic_set(&ge->generation, -1);
+        INIT_LIST_HEAD(&ne->list);
+        atomic_set(&ne->refcount, 0);
+        ne->guid = (u64) -1;
+        ne->host = NULL;
+        ne->node_id = 0;
+        atomic_set(&ne->generation, -1);
+	atomic_set(&ne->busopt.changed, 0);
 
         write_lock_irqsave(&node_lock, flags);
-        list_add_tail(&ge->list, &node_list);
+        list_add_tail(&ne->list, &node_list);
         write_unlock_irqrestore(&node_lock, flags);
 
-        return ge;
+        return ne;
 }
 
 static struct node_entry *find_entry(u64 guid)
 {
         struct list_head *lh;
-        struct node_entry *ge;
+        struct node_entry *ne;
         
         lh = node_list.next;
         while (lh != &node_list) {
-                ge = list_entry(lh, struct node_entry, list);
-                if (ge->guid == guid) return ge;
+                ne = list_entry(lh, struct node_entry, list);
+                if (ne->guid == guid) return ne;
                 lh = lh->next;
         }
 
         return NULL;
 }
 
-static void associate_guid(struct hpsb_host *host, nodeid_t nodeid, u64 guid)
+static int register_guid(struct hpsb_host *host, nodeid_t nodeid, u64 guid,
+			  quadlet_t busoptions)
 {
-        struct node_entry *ge;
-        unsigned long flags;
-
-        HPSB_DEBUG("Node %d on %s host: GUID %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
-                   nodeid & NODE_MASK, host->template->name, ((u8 *)&guid)[0],
-		   ((u8 *)&guid)[1], ((u8 *)&guid)[2], ((u8 *)&guid)[3],
-		   ((u8 *)&guid)[4], ((u8 *)&guid)[5], ((u8 *)&guid)[6],
-		   ((u8 *)&guid)[7]);
+        struct node_entry *ne;
+        unsigned long flags, new = 0;
 
         read_lock_irqsave(&node_lock, flags);
-        ge = find_entry(guid);
+        ne = find_entry(guid);
         read_unlock_irqrestore(&node_lock, flags);
 
-        if (!ge) ge = create_node_entry();
-        if (!ge) return;
+	/* New entry */
+	if (!ne) {
+		if ((ne = create_node_entry()) == NULL)
+			return -1;
 
-        ge->host = host;
-        ge->node_id = nodeid;
-        ge->guid = guid;
+		HPSB_DEBUG("%s added: node %d, bus %d: GUID %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
+			   (host->node_id == nodeid) ? "Local host" : "Device",
+			   nodeid & NODE_MASK, (nodeid & BUS_MASK) >> 6, ((u8 *)&guid)[0],
+			   ((u8 *)&guid)[1], ((u8 *)&guid)[2], ((u8 *)&guid)[3],
+			   ((u8 *)&guid)[4], ((u8 *)&guid)[5], ((u8 *)&guid)[6],
+			   ((u8 *)&guid)[7]);
 
-        atomic_set(&ge->generation, get_hpsb_generation());
+		ne->guid = guid;
+		new = 1;
+	}
+
+	if (!new && ne->node_id != nodeid)
+		HPSB_DEBUG("Node %d changed to %d on bus %d",
+			   ne->node_id & NODE_MASK, nodeid & NODE_MASK, (nodeid & BUS_MASK) >> 6);
+
+	ne->host = host;
+        ne->node_id = nodeid;
+
+        atomic_set(&ne->generation, get_hpsb_generation());
+
+	/* Now set the bus options. Only do all this crap if this is a new
+	 * node, or if the generation number has changed.  */
+	if (new || ne->busopt.generation != ((busoptions >> 6) & 0x3)) {
+		ne->busopt.irmc		= (busoptions >> 31) & 1;
+		ne->busopt.cmc		= (busoptions >> 30) & 1;
+		ne->busopt.isc		= (busoptions >> 29) & 1;
+		ne->busopt.bmc		= (busoptions >> 28) & 1;
+		ne->busopt.pmc		= (busoptions >> 27) & 1;
+		ne->busopt.cyc_clk_acc	= (busoptions >> 16) & 0xff;
+		ne->busopt.max_rec	= 1 << (((busoptions >> 12) & 0xf) + 1);
+		ne->busopt.generation	= (busoptions >> 6) & 0x3;
+		ne->busopt.lnkspd	= busoptions & 0x7;
+
+		new = 1; /* To make sure we probe the rest of the ConfigROM too */
+	}
+
+#ifdef CONFIG_IEEE1394_VERBOSEDEBUG
+	HPSB_DEBUG("raw=0x%08x irmc=%d cmc=%d isc=%d bmc=%d pmc=%d cyc_clk_acc=%d "
+		   "max_rec=%d gen=%d lspd=%d\n", busoptions,
+		   ne->busopt.irmc, ne->busopt.cmc, ne->busopt.isc, ne->busopt.bmc,
+		   ne->busopt.pmc, ne->busopt.cyc_clk_acc, ne->busopt.max_rec,
+		   ne->busopt.generation, ne->busopt.lnkspd);
+#endif
+
+	return new;
+}
+
+static void nodemgr_remove_node(struct node_entry *ne)
+{
+	HPSB_DEBUG("Device removed: node %d, bus %d: GUID "
+		   "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
+		   ne->node_id & NODE_MASK, (ne->node_id & BUS_MASK) >> 6,
+		   ((u8 *)&ne->guid)[0], ((u8 *)&ne->guid)[1],
+		   ((u8 *)&ne->guid)[2], ((u8 *)&ne->guid)[3],
+		   ((u8 *)&ne->guid)[4], ((u8 *)&ne->guid)[5],
+		   ((u8 *)&ne->guid)[6], ((u8 *)&ne->guid)[7]);
+
+	list_del(&ne->list);
+	kfree(ne);
+
+	return;
 }
 
 /* This is where we probe the nodes for their information and provided
@@ -133,94 +202,150 @@ static void associate_guid(struct hpsb_host *host, nodeid_t nodeid, u64 guid)
 static void nodemgr_node_probe(struct hpsb_host *host)
 {
         struct selfid *sid = (struct selfid *)host->topology_map;
+	struct list_head *lh;
+	struct node_entry *ne;
         int nodecount = host->node_count;
         nodeid_t nodeid = LOCAL_BUS;
 	quadlet_t buffer[5], quad;
 	octlet_t base = CSR_REGISTER_BASE + CSR_CONFIG_ROM;
-	int retval;
+	int flags;
 
 	/* We need to detect when the ConfigROM's generation has changed,
 	 * so we only update the node's info when it needs to be.  */
         for (; nodecount; nodecount--, nodeid++, sid++) {
-		int header_count = 0;
-		unsigned header_size = 0;
+		int retries = 3;
+		int header_count;
+		unsigned header_size;
+		octlet_t guid;
+
+		/* Skip extended, and non-active node's */
                 while (sid->extended)
 			sid++;
                 if (!sid->link_active)
 			continue;
-		if (nodeid == host->node_id)
+
+		/* Just use our local ROM */
+		if (nodeid == host->node_id) {
+			int i;
+			for (i = 0; i < 5; i++)
+				buffer[i] = be32_to_cpu(host->csr.rom[i]);
+			goto set_options;
+		}
+
+retry_configrom:
+		
+		if (!retries--) {
+			HPSB_ERR("Giving up on node %d for ConfigROM probe, too many errors",
+				 nodeid & NODE_MASK);
 			continue;
+		}
 
-		HPSB_DEBUG("Initiating ConfigROM request for node %d", nodeid & NODE_MASK);
+		header_count = 0;
+		header_size = 0;
 
-		retval = hpsb_read(host, nodeid, base, &quad, 4);
-		buffer[header_count++] = be32_to_cpu(quad);
+#ifdef CONFIG_IEEE1394_VERBOSEDEBUG
+		HPSB_INFO("Initiating ConfigROM request for node %d", nodeid & NODE_MASK);
+#endif
+
+		/* Now, P1212 says that devices should support 64byte block
+		 * reads, aligned on 64byte boundaries. That doesn't seem
+		 * to work though, and we are forced to doing quadlet
+		 * sized reads.  */
 
-		if (retval) {
-			HPSB_ERR("ConfigROM quadlet transaction error for %d",
+		if (hpsb_read(host, nodeid, base, &quad, 4)) {
+			HPSB_ERR("ConfigROM quadlet transaction error for node %d",
 				 nodeid & NODE_MASK);
-			continue;
+			goto retry_configrom;
 		}
+		buffer[header_count++] = be32_to_cpu(quad);
 
 		header_size = buffer[0] >> 24;
 
 		if (header_size < 4) {
-			HPSB_INFO("Node %d on %s host has non-standard ROM format (%d quads), "
-				  "cannot parse", nodeid & NODE_MASK, host->template->name,
+			HPSB_INFO("Node %d on bus %d has non-standard ROM format (%d quads), "
+				  "cannot parse", nodeid & NODE_MASK, (nodeid & BUS_MASK) >> 6,
 				  header_size);
 			continue;
 		}
 
 		while (header_count <= header_size && (header_count<<2) < sizeof(buffer)) {
-			retval = hpsb_read(host, nodeid, base + (header_count<<2), &quad, 4);
-			buffer[header_count++] = be32_to_cpu(quad);
-
-			if (retval) {
+			if (hpsb_read(host, nodeid, base + (header_count<<2), &quad, 4)) {
 				HPSB_ERR("ConfigROM quadlet transaction error for %d",
 					 nodeid & NODE_MASK);
-				goto failed_read;
+				goto retry_configrom;
 			}
-
+			buffer[header_count++] = be32_to_cpu(quad);
+		}
+set_options:
+		guid = be64_to_cpu(((u64)buffer[3] << 32) | buffer[4]);
+		switch (register_guid(host, nodeid, guid, buffer[2])) {
+			case -1:
+				HPSB_ERR("Failed to register node in ConfigROM probe");
+				continue;
+			case 1:
+				/* Need to probe the rest of the ConfigROM
+				 * here.  */
+				break;
+			default:
+				/* Nothing to do, this is an old unchanged
+				 * node.  */
+				break;
 		}
-
-		associate_guid(host, nodeid, be64_to_cpu(((u64)buffer[3] << 32) | buffer[4]));
-failed_read:
-		continue;
         }
 
-	/* Need to detect when nodes are no longer associated with
-	 * anything. I believe we can do this using the generation of the
-	 * entries after a reset, compared the the hosts generation.  */
+	/* Now check to see if we have any nodes that aren't referenced
+	 * any longer.  */
+        write_lock_irqsave(&node_lock, flags);
+	lh = node_list.next;
+	while (lh != &node_list) {
+		ne = list_entry(lh, struct node_entry, list);
+
+		/* Only checking this host */
+		if (ne->host != host)
+			continue;
+
+		/* If the generation didn't get updated, then either the
+		 * node was removed, or it failed the above probe. Either
+		 * way, we remove references to it, since they are
+		 * invalid.  */
+		if (atomic_read(&ne->generation) != get_hpsb_generation())
+			nodemgr_remove_node(ne);
+
+		lh = lh->next;
+	}
+	write_unlock_irqrestore(&node_lock, flags);
+
+	return;
 }
 
 
 struct node_entry *hpsb_guid_get_handle(u64 guid)
 {
         unsigned long flags;
-        struct node_entry *ge;
+        struct node_entry *ne;
 
         read_lock_irqsave(&node_lock, flags);
-        ge = find_entry(guid);
-        if (ge) atomic_inc(&ge->refcount);
+        ne = find_entry(guid);
+        if (ne) atomic_inc(&ne->refcount);
         read_unlock_irqrestore(&node_lock, flags);
 
-        return ge;
+        return ne;
 }
 
-struct hpsb_host *hpsb_get_host_by_ge(struct node_entry *ge)
+struct hpsb_host *hpsb_get_host_by_ne(struct node_entry *ne)
 {
-        if (atomic_read(&ge->generation) != get_hpsb_generation()) return NULL;
-        if (ge->node_id == ge->host->node_id) return ge->host;
+        if (atomic_read(&ne->generation) != get_hpsb_generation()) return NULL;
+        if (ne->node_id == ne->host->node_id) return ne->host;
         return NULL;
 }
 
-int hpsb_guid_fill_packet(struct node_entry *ge, struct hpsb_packet *pkt)
+int hpsb_guid_fill_packet(struct node_entry *ne, struct hpsb_packet *pkt)
 {
-        if (atomic_read(&ge->generation) != get_hpsb_generation()) return 0;
+        if (atomic_read(&ne->generation) != get_hpsb_generation()) return 0;
 
-        pkt->host = ge->host;
-        pkt->node_id = ge->node_id;
-        pkt->generation = atomic_read(&ge->generation);
+        pkt->host = ne->host;
+        pkt->node_id = ne->node_id;
+        pkt->generation = atomic_read(&ne->generation);
         return 1;
 }
 
@@ -229,33 +354,38 @@ static int nodemgr_reset_handler(void *__hi)
 	struct host_info *hi = (struct host_info *)__hi;
 	struct hpsb_host *host = hi->host;
 
-	/* Standard thread setup */
+
 	lock_kernel();
-	daemonize();
-	strcpy(current->comm, "NodeMngr");
-	unlock_kernel();
 
-	for (;;) {
-		if (signal_pending(current))
-			break;
+	siginitsetinv(&current->blocked, sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM));
 
-		/* Let's take a short pause to make sure all the devices
-		 * have time to settle.  */
+	strcpy(current->comm, "NodeMngr");
+
+	unlock_kernel();
 
+	do {
 		current->state = TASK_INTERRUPTIBLE;
 		schedule_timeout(HZ/50);
 
-		if (hi && host)
+		if (hi && host) {
 			nodemgr_node_probe(host);
-
-		/* Wait for the next bus reset */
-		if (hi && host)
 			interruptible_sleep_on(&hi->reset_wait);
-	}
+		} else
+			break;
+
+	} while (!signal_pending(current) && hi);
 
 	return(0);
 }
 
+static void nodemgr_schedule_thread (void *__hi)
+{
+	struct host_info *hi = (struct host_info *)__hi;
+
+	hi->ppid = current->pid;
+	hi->pid = kernel_thread(nodemgr_reset_handler, hi, 0);
+}
+
 static void nodemgr_add_host(struct hpsb_host *host)
 {
 	struct host_info *hi = kmalloc (sizeof (struct host_info), GFP_KERNEL);
@@ -266,10 +396,14 @@ static void nodemgr_add_host(struct hpsb_host *host)
 		return;
 	}
 
+	/* We simply initialize the struct here. We don't start the thread
+	 * until the first bus reset.  */
 	hi->host = host;
 	INIT_LIST_HEAD(&hi->list);
 	hi->pid = -1;
+	hi->ppid = -1;
 	init_waitqueue_head(&hi->reset_wait);
+	INIT_TQUEUE(&hi->task, nodemgr_schedule_thread, hi);
 
 	spin_lock_irqsave (&host_info_lock, flags);
 	list_add_tail (&hi->list, &host_info_list);
@@ -278,14 +412,6 @@ static void nodemgr_add_host(struct hpsb_host *host)
 	return;
 }
 
-static void nodemgr_schedule_thread (void *__hi)
-{
-	struct host_info *hi = (struct host_info *)__hi;
-
-	hi->pid = kernel_thread(nodemgr_reset_handler, hi,
-				CLONE_FS|CLONE_FILES|CLONE_SIGHAND);
-}
-
 static void nodemgr_host_reset(struct hpsb_host *host)
 {
 	struct list_head *lh;
@@ -311,18 +437,7 @@ static void nodemgr_host_reset(struct hpsb_host *host)
 	if (hi->pid >= 0) {
 		wake_up(&hi->reset_wait);
 	} else {
-		if (in_interrupt()) {
-			static struct tq_struct task;
-			memset(&task, 0, sizeof(struct tq_struct));
-
-			task.routine = nodemgr_schedule_thread;
-			task.data = (void*)hi;
-
-			if (schedule_task(&task) < 0)
-				HPSB_ERR ("Failed to schedule Node Manager thread!\n");
-		} else {
-			nodemgr_schedule_thread(hi);
-		}
+		schedule_task(&hi->task);
 	}
 
 done_reset_host:
@@ -335,8 +450,24 @@ static void nodemgr_remove_host(struct hpsb_host *host)
 {
 	struct list_head *lh;
 	struct host_info *hi = NULL;
+	struct node_entry *ne;
 	int flags;
 
+	/* First remove all node entries for this host */
+	write_lock_irqsave(&node_lock, flags);
+	lh = node_list.next;
+	while (lh != &node_list) {
+		ne = list_entry(lh, struct node_entry, list);
+
+		/* Only checking this host */
+		if (ne->host != host)
+			continue;
+
+		nodemgr_remove_node(ne);
+		lh = lh->next;
+	}
+	write_unlock_irqrestore(&node_lock, flags);
+
 	spin_lock_irqsave (&host_info_lock, flags);
 	lh = host_info_list.next;
 	while (lh != &host_info_list) {
@@ -349,15 +480,24 @@ static void nodemgr_remove_host(struct hpsb_host *host)
 	}
 
 	if (hi == NULL) {
-		HPSB_ERR ("Could not remove non-exitent host in Node Manager");
+		HPSB_ERR ("Could not remove non-existent host in Node Manager");
 		goto done_remove_host;
 	}
 
-	if (hi->pid >= 0)
-		kill_proc(hi->pid, SIGINT, 1);
+	mb();
+
+	if (hi->pid >= 0) {
+		/* Kill the proc */
+		kill_proc(hi->pid, SIGKILL, 1);
 
-	current->state = TASK_INTERRUPTIBLE;
-	schedule_timeout(HZ*2);   /* 2 second delay */
+		/* XXX: We need a better way... */
+		current->state = TASK_INTERRUPTIBLE;
+		schedule_timeout(HZ/20);
+
+		/* Now tell the parent to sluff off the zombied body */
+		mb();
+		kill_proc(hi->ppid, SIGCHLD, 1);
+	}
 
 	kfree (hi);
 
@@ -377,8 +517,6 @@ static struct hpsb_highlevel *hl;
 
 void init_ieee1394_nodemgr(void)
 {
-        atomic_set(&outstanding_requests, 0);
-
         hl = hpsb_register_highlevel("Node manager", &guid_ops);
         if (!hl) {
                 HPSB_ERR("Out of memory during ieee1394 initialization");

drivers/ieee1394/nodemgr.h

@@ -50,7 +50,7 @@ hpsb_guid_t hpsb_guid_get_handle(u64 guid);
  * Note that the local GUID currently isn't collected, so this will always
  * return NULL.
  */
-struct hpsb_host *hpsb_get_host_by_ge(hpsb_guid_t handle);
+struct hpsb_host *hpsb_get_host_by_ne(hpsb_guid_t handle);
 
 /*
  * This will fill in the given, pre-initialised hpsb_packet with the current

drivers/ieee1394/ohci1394.c

@@ -36,14 +36,8 @@
  * . Async Stream Packets
  * . DMA error recovery
  *
- * Things to be fixed:
- * . Latency problems on UltraSPARC
- *
  * Known bugs:
- * . SelfID are sometimes not received properly 
- *   if card is initialized with no other nodes 
- *   on the bus
- * . Apple PowerBook detected but not working yet
+ * . Apple PowerBook detected but not working yet (still true?)
  */
 
 /* 
@@ -277,10 +271,7 @@ static int handle_selfid(struct ti_ohci *ohci, struct hpsb_host *host,
 	size_t size;
 	quadlet_t q0, q1;
 
-	/* SelfID handling seems much easier than for the aic5800 chip.
-	   All the self-id packets, including this devices own self-id,
-	   should be correctly arranged in the selfid buffer at this
-	   stage */
+	mdelay(10);
 
 	/* Check status of self-id reception */
 
@@ -320,7 +311,7 @@ static int handle_selfid(struct ti_ohci *ohci, struct hpsb_host *host,
 		}
 		
 		if (q0 == ~q1) {
-			PRINT(KERN_DEBUG, ohci->id, "SelfID packet 0x%x received", q0);
+			DBGMSG (ohci->id, "SelfID packet 0x%x received", q0);
 			hpsb_selfid_received(host, cpu_to_be32(q0));
 			if (((q0 & 0x3f000000) >> 24) == phyid)
 				DBGMSG (ohci->id, "SelfID for this node is 0x%08x", q0);
@@ -332,7 +323,7 @@ static int handle_selfid(struct ti_ohci *ohci, struct hpsb_host *host,
 		size -= 2;
 	}
 
-	PRINT(KERN_DEBUG, ohci->id, "SelfID complete");
+	DBGMSG(ohci->id, "SelfID complete");
 
 	hpsb_selfid_complete(host, phyid, isroot);
 	return 0;
@@ -346,10 +337,10 @@ static int ohci_soft_reset(struct ti_ohci *ohci) {
 	for (i = 0; i < OHCI_LOOP_COUNT; i++) {
 		if (reg_read(ohci, OHCI1394_HCControlSet) & 0x00010000)
 			break;
-		mdelay(10);
+		mdelay(1);
 	}
 
-	PRINT(KERN_DEBUG, ohci->id, "Soft reset finished");
+	DBGMSG (ohci->id, "Soft reset finished");
 
 	return 0;
 }
@@ -458,41 +449,32 @@ static int get_nb_iso_ctx(struct ti_ohci *ohci, int reg)
 	return ctx;
 }
 
+static void ohci_init_config_rom(struct ti_ohci *ohci);
+
 /* Global initialization */
 static int ohci_initialize(struct hpsb_host *host)
 {
 	struct ti_ohci *ohci=host->hostdata;
 	int retval, i;
+	quadlet_t buf;
 
 	spin_lock_init(&ohci->phy_reg_lock);
 	spin_lock_init(&ohci->event_lock);
   
-	/*
-	 * Tip by James Goodwin <jamesg@Filanet.com>:
-	 * We need to add delays after the soft reset, setting LPS, and
-	 * enabling our link. This might fixes the self-id reception 
-	 * problem at initialization.
-	 */ 
-
 	/* Soft reset */
 	if ((retval = ohci_soft_reset(ohci)) < 0)
 		return retval;
 
-	/* 
-	 * Delay after soft reset to make sure everything has settled
-	 * down (sanity)
-	 */
-	mdelay(10);    
-  
+	/* Put some defaults to these undefined bus options */
+	buf = reg_read(ohci, OHCI1394_BusOptions);
+	buf |=  0x60000000; /* Enable CMC and ISC */
+	buf &= ~0x00ff0000; /* XXX: Set cyc_clk_acc to zero for now */
+	buf &= ~0x98000000; /* Disable PMC, IRMC and BMC */
+	reg_write(ohci, OHCI1394_BusOptions, buf);
+
 	/* Set Link Power Status (LPS) */
 	reg_write(ohci, OHCI1394_HCControlSet, 0x00080000);
 
-	/*
-	 * Delay after setting LPS in order to make sure link/phy
-	 * communication is established
-	 */
-	mdelay(10);   
-
 	/* Set the bus number */
 	reg_write(ohci, OHCI1394_NodeID, 0x0000ffc0);
 
@@ -515,13 +497,15 @@ static int ohci_initialize(struct hpsb_host *host)
 	/* enable self-id dma */
 	reg_write(ohci, OHCI1394_LinkControlSet, 0x00000200);
 
-	/* Set the configuration ROM mapping register */
+	/* Set the Config ROM mapping register */
 	reg_write(ohci, OHCI1394_ConfigROMmap, ohci->csr_config_rom_bus);
 
+	/* Initialize the Config ROM */
+	ohci_init_config_rom(ohci);
+
+	/* Now get our max packet size */
 	ohci->max_packet_size = 
 		1<<(((reg_read(ohci, OHCI1394_BusOptions)>>12)&0xf)+1);
-	PRINT(KERN_DEBUG, ohci->id, "Max packet size = %d bytes",
-	       ohci->max_packet_size);
 
 	/* Don't accept phy packets into AR request context */ 
 	reg_write(ohci, OHCI1394_LinkControlClear, 0x00000400);
@@ -622,6 +606,14 @@ static int ohci_initialize(struct hpsb_host *host)
 	/* Enable link */
 	reg_write(ohci, OHCI1394_HCControlSet, 0x00020000);
 
+	buf = reg_read(ohci, OHCI1394_Version);
+	PRINT(KERN_INFO, ohci->id, "OHCI-1394 %d.%d (PCI): IRQ=[%d]  MMIO=[%lx-%lx]"
+	      "  Max Packet=[%d]", ((((buf) >> 16) & 0xf) + (((buf) >> 20) & 0xf) * 10),
+	      ((((buf) >> 4) & 0xf) + ((buf) & 0xf) * 10), ohci->dev->irq,
+	      pci_resource_start(ohci->dev, 0),
+	      pci_resource_start(ohci->dev, 0) + pci_resource_len(ohci->dev, 0),
+	      ohci->max_packet_size);
+
 	return 1;
 }
 
@@ -884,7 +876,7 @@ static int ohci_devctl(struct hpsb_host *host, enum devctl_cmd cmd, int arg)
 
 	switch (cmd) {
 	case RESET_BUS:
-		PRINT (KERN_DEBUG, ohci->id, "Resetting bus on request%s",
+		DBGMSG(ohci->id, "Bus reset requested%s",
 		       ((host->attempt_root || attempt_root) ? 
 		       " and attempting to become root" : ""));
 		set_phy_reg_mask (ohci, 1, 0x40 | ((host->attempt_root || attempt_root) ?
@@ -1076,10 +1068,13 @@ static void ohci_irq_handler(int irq, void *dev_id,
 	struct hpsb_host *host = ohci->host;
 	int phyid = -1, isroot = 0, flags;
 
-	/* Read the interrupt event register */
+	/* Read the interrupt event register. We don't clear the bus reset
+	 * here. We wait till we get a selfid complete interrupt and clear
+	 * it then, and _only_ then.  */
 	spin_lock_irqsave(&ohci->event_lock, flags);
 	event = reg_read(ohci, OHCI1394_IntEventClear);
-	reg_write(ohci, OHCI1394_IntEventClear, event);
+	reg_write(ohci, OHCI1394_IntEventClear,
+		  event & ~(OHCI1394_selfIDComplete|OHCI1394_busReset));
 	spin_unlock_irqrestore(&ohci->event_lock, flags);
 
 	if (!event) return;
@@ -1093,15 +1088,12 @@ static void ohci_irq_handler(int irq, void *dev_id,
 		return;
 	}
 
-	/* Someone wants a bus reset. Better watch what you wish for...
-	 *
-	 * XXX: Read 6.1.1 of the OHCI1394 spec. We need to take special
-	 * care with the BusReset Interrupt, before and until the SelfID
-	 * phase is over. This is why the SelfID phase sometimes fails for
-	 * this driver.  */
+	/* Someone wants a bus reset. Better watch what you wish for... */
 	if (event & OHCI1394_busReset) {
 		if (!host->in_bus_reset) {
-			PRINT(KERN_DEBUG, ohci->id, "Bus reset requested");
+			DBGMSG(ohci->id, "Bus reset requested%s",
+			      ((host->attempt_root || attempt_root) ?
+			      " and attempting to become root" : ""));
 			
 			/* Wait for the AT fifo to be flushed */
 			dma_trm_reset(ohci->at_req_context);
@@ -1112,7 +1104,8 @@ static void ohci_irq_handler(int irq, void *dev_id,
 			
 			ohci->NumBusResets++;
 		}
-		event &= ~OHCI1394_busReset;
+		/* Mask out everything except selfid */
+		event &= OHCI1394_selfIDComplete;
 	}
 
 	/* XXX: We need a way to also queue the OHCI1394_reqTxComplete,
@@ -1219,7 +1212,7 @@ static void ohci_irq_handler(int irq, void *dev_id,
 				phyid =  node_id & 0x0000003f;
 				isroot = (node_id & 0x40000000) != 0;
 
-				PRINT(KERN_DEBUG, ohci->id,
+				DBGMSG(ohci->id,
 				      "SelfID interrupt received "
 				      "(phyid %d, %s)", phyid, 
 				      (isroot ? "root" : "not root"));
@@ -1249,6 +1242,12 @@ static void ohci_irq_handler(int irq, void *dev_id,
 		} else
 			PRINT(KERN_ERR, ohci->id, 
 			      "SelfID received outside of bus reset sequence");
+
+		/* Clear everything, it's a new day */
+		spin_lock_irqsave(&ohci->event_lock, flags);
+		reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
+		spin_unlock_irqrestore(&ohci->event_lock, flags);
+
 		event &= ~OHCI1394_selfIDComplete;
 	}
 	if (event & OHCI1394_phyRegRcvd) {
@@ -1260,6 +1259,9 @@ static void ohci_irq_handler(int irq, void *dev_id,
 			      "Physical register received outside of bus reset sequence");
 		event &= ~OHCI1394_phyRegRcvd;
 	}
+
+	/* Make sure we handle everything, just in case we accidentally
+	 * enabled an interrupt that we didn't write a handler for.  */
 	if (event)
 		PRINT(KERN_ERR, ohci->id, "Unhandled interrupt(s) 0x%08x\n",
 		      event);
@@ -1374,7 +1376,7 @@ static void dma_rcv_tasklet (unsigned long data)
 				spin_unlock_irqrestore(&d->lock, flags);
 				return;
 			}
-#if 0
+
 			if (le32_to_cpu(d->prg_cpu[(idx+1)%d->num_desc]->status)
 			    == d->buf_size) {
 				/* Other part of packet not written yet.
@@ -1387,7 +1389,7 @@ static void dma_rcv_tasklet (unsigned long data)
 				spin_unlock_irqrestore(&d->lock, flags);
 				return;
 			}
-#endif
+
 			split_left = length;
 			split_ptr = (char *)d->spb;
 			memcpy(split_ptr,buf_ptr,d->buf_size-offset);
@@ -1448,7 +1450,7 @@ static void dma_rcv_tasklet (unsigned long data)
 			hpsb_packet_received(ohci->host, d->spb, 
 					     length-4, ack);
 		}
-#if OHCI1394_DEBUG
+#ifdef OHCI1394_DEBUG
 		else
 			PRINT (KERN_DEBUG, ohci->id, "Got phy packet ctx=%d ... discarded",
 			       d->ctx);
@@ -1837,41 +1839,47 @@ struct config_rom_ptr {
 
 #define cf_put_keyval(cr, key, val) (((cr)->data++)[0] = cpu_to_be32((key) << 24) | (val))
 
-#define cf_put_crc16(cr, unit) \
-	(*(cr)->unitdir[unit].start = cpu_to_be32(((cr)->unitdir[unit].length << 16) | \
-	 ohci_crc16((cr)->unitdir[unit].start + 1, (cr)->unitdir[unit].length)))
-
-#define cf_unit_begin(cr, unit)					\
-do {								\
-	if ((cr)->unitdir[unit].refer != NULL) {		\
-		*(cr)->unitdir[unit].refer |=			\
-			(cr)->data - (cr)->unitdir[unit].refer;	\
-		cf_put_crc16(cr, (cr)->unitdir[unit].refunit);	\
-        }							\
-        (cr)->unitnum = (unit);					\
-        (cr)->unitdir[unit].start = (cr)->data++;		\
-} while (0)
-
-#define cf_put_refer(cr, key, unit)			\
-do {							\
-	(cr)->unitdir[unit].refer = (cr)->data;		\
-	(cr)->unitdir[unit].refunit = (cr)->unitnum;	\
-	((cr)->data++)[0] = cpu_to_be32((key) << 24);		\
-} while(0)
+static inline void cf_put_crc16(struct config_rom_ptr *cr, int unit)
+{
+	*cr->unitdir[unit].start =
+		cpu_to_be32((cr->unitdir[unit].length << 16) |
+			    ohci_crc16(cr->unitdir[unit].start + 1,
+				       cr->unitdir[unit].length));
+}
 
-#define cf_unit_end(cr)						\
-do {								\
-	(cr)->unitdir[(cr)->unitnum].length = (cr)->data -	\
-		((cr)->unitdir[(cr)->unitnum].start + 1);	\
-	cf_put_crc16((cr), (cr)->unitnum);			\
-} while(0)
+static inline void cf_unit_begin(struct config_rom_ptr *cr, int unit)
+{
+	if (cr->unitdir[unit].refer != NULL) {
+		*cr->unitdir[unit].refer |=
+			cr->data - cr->unitdir[unit].refer;
+		cf_put_crc16(cr, cr->unitdir[unit].refunit);
+	}
+	cr->unitnum = unit;
+	cr->unitdir[unit].start = cr->data++;
+}
+
+static inline void cf_put_refer(struct config_rom_ptr *cr, char key, int unit)
+{
+	cr->unitdir[unit].refer = cr->data;
+	cr->unitdir[unit].refunit = cr->unitnum;
+	(cr->data++)[0] = cpu_to_be32(key << 24);
+}
+
+static inline void cf_unit_end(struct config_rom_ptr *cr)
+{
+	cr->unitdir[cr->unitnum].length = cr->data -
+		(cr->unitdir[cr->unitnum].start + 1);
+	cf_put_crc16(cr, cr->unitnum);
+}
+
+/* End of NetBSD derived code.  */
 
 static void ohci_init_config_rom(struct ti_ohci *ohci)
 {
 	struct config_rom_ptr cr;
 
 	memset(&cr, 0, sizeof(cr));
-	memset (ohci->csr_config_rom_cpu, 0, sizeof (ohci->csr_config_rom_cpu));
+	memset(ohci->csr_config_rom_cpu, 0, sizeof (ohci->csr_config_rom_cpu));
 
 	cr.data = ohci->csr_config_rom_cpu;
 
@@ -1887,7 +1895,7 @@ static void ohci_init_config_rom(struct ti_ohci *ohci)
 		reg_read(ohci, OHCI1394_GUIDLo));
 
 	/* IEEE P1212 suggests the initial ROM header CRC should only
-	 * cover the header itself (and not the entire ROM). Since we use
+	 * cover the header itself (and not the entire ROM). Since we do
 	 * this, then we can make our bus_info_len the same as the CRC
 	 * length.  */
 	ohci->csr_config_rom_cpu[0] |= cpu_to_be32(
@@ -1981,7 +1989,7 @@ int ohci_compare_swap(struct ti_ohci *ohci, quadlet_t *data,
 		if (reg_read(ohci, OHCI1394_CSRControl) & 0x80000000)
 			break;
 
-		mdelay(10);
+		mdelay(1);
 	}
 
 	*data = reg_read(ohci, OHCI1394_CSRData);
@@ -1998,29 +2006,15 @@ static quadlet_t ohci_hw_csr_reg(struct hpsb_host *host, int reg,
 	return data;
 }
 
-struct hpsb_host_template *get_ohci_template(void)
-{
-	static struct hpsb_host_template tmpl;
-	static int initialized = 0;
-
-	if (!initialized) {
-		memset (&tmpl, 0, sizeof (struct hpsb_host_template));
-
-		/* Initialize by field names so that a template structure
-		 * reorganization does not influence this code. */
-		tmpl.name = "ohci1394";
-
-		tmpl.initialize_host = ohci_initialize;
-		tmpl.release_host = ohci_remove;
-		tmpl.get_rom = get_ohci_rom;
-		tmpl.transmit_packet = ohci_transmit;
-		tmpl.devctl = ohci_devctl;
-		tmpl.hw_csr_reg = ohci_hw_csr_reg;
-		initialized = 1;
-	}
-
-	return &tmpl;
-}
+static struct hpsb_host_template ohci_template = {
+	name:			OHCI1394_DRIVER_NAME,
+	initialize_host:	ohci_initialize,
+	release_host:		ohci_remove,
+	get_rom:		get_ohci_rom,
+	transmit_packet:	ohci_transmit,
+	devctl:			ohci_devctl,
+	hw_csr_reg:		ohci_hw_csr_reg,
+};
 
 static int __devinit ohci1394_add_one(struct pci_dev *dev, const struct pci_device_id *ent)
 {
@@ -2040,7 +2034,7 @@ static int __devinit ohci1394_add_one(struct pci_dev *dev, const struct pci_devi
         }
         pci_set_master(dev);
 
-	host = hpsb_get_host(get_ohci_template(), sizeof (struct ti_ohci));
+	host = hpsb_get_host(&ohci_template, sizeof (struct ti_ohci));
 	if (!host) {
 		PRINT_G(KERN_ERR, "Out of memory trying to allocate host structure");
 		return -ENOMEM;
@@ -2054,8 +2048,6 @@ static int __devinit ohci1394_add_one(struct pci_dev *dev, const struct pci_devi
 	ohci->host = host;
 	pci_set_drvdata(dev, ohci);
 
-	PRINT(KERN_INFO, ohci->id, "OHCI (PCI) IEEE-1394 Controller");
-
 	/* We don't want hardware swapping */
 	pci_write_config_dword(dev, OHCI1394_PCI_HCI_Control, 0);
 
@@ -2173,14 +2165,10 @@ static int __devinit ohci1394_add_one(struct pci_dev *dev, const struct pci_devi
 	ohci->ISO_channel_usage = 0;
         spin_lock_init(&ohci->IR_channel_lock);
 
-	if (!request_irq(dev->irq, ohci_irq_handler, SA_SHIRQ,
+	if (request_irq(dev->irq, ohci_irq_handler, SA_SHIRQ,
 			 OHCI1394_DRIVER_NAME, ohci))
-		PRINT(KERN_DEBUG, ohci->id, "Allocated interrupt %d", dev->irq);
-	else
 		FAIL("Failed to allocate shared interrupt %d", dev->irq);
 
-	ohci_init_config_rom(ohci);
-
 	/* Tell the highlevel this host is ready */
 	highlevel_add_one_host (host);
 
@@ -2190,7 +2178,9 @@ static int __devinit ohci1394_add_one(struct pci_dev *dev, const struct pci_devi
 
 static void remove_card(struct ti_ohci *ohci)
 {
-	/* Reset the board properly before leaving */
+	quadlet_t buf;
+
+	/* Soft reset before we start */
 	ohci_soft_reset(ohci);
 
 	/* Free AR dma */
@@ -2207,6 +2197,10 @@ static void remove_card(struct ti_ohci *ohci)
         /* Free IT dma */
         free_dma_trm_ctx(&ohci->it_context);
 
+	/* Disable all interrupts */
+	reg_write(ohci, OHCI1394_IntMaskClear, 0x80000000);
+	free_irq(ohci->dev->irq, ohci);
+
 	/* Free self-id buffer */
 	if (ohci->selfid_buf_cpu) {
 		pci_free_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE, 
@@ -2222,9 +2216,15 @@ static void remove_card(struct ti_ohci *ohci)
 				    ohci->csr_config_rom_bus);
 		OHCI_DMA_FREE("consistent csr_config_rom");
 	}
-	
-	/* Free the IRQ */
-	free_irq(ohci->dev->irq, ohci);
+
+	/* Disable our bus options */
+	buf = reg_read(ohci, OHCI1394_BusOptions);
+	buf &= ~0xf8000000;
+	buf |=  0x00ff0000;
+	reg_write(ohci, OHCI1394_BusOptions, buf);
+
+	/* Clear LinkEnable and LPS */
+	reg_write(ohci, OHCI1394_HCControlClear, 0x000a0000);
 
 	if (ohci->registers)
 		iounmap(ohci->registers);
@@ -2398,7 +2398,7 @@ static void __devexit ohci1394_remove_one(struct pci_dev *pdev)
 }
 
 static struct pci_driver ohci1394_driver = {
-	name:		"ohci1394",
+	name:		OHCI1394_DRIVER_NAME,
 	id_table:	ohci1394_pci_tbl,
 	probe:		ohci1394_add_one,
 	remove:		ohci1394_remove_one,
@@ -2406,20 +2406,20 @@ static struct pci_driver ohci1394_driver = {
 
 static void __exit ohci1394_cleanup (void)
 {
-	hpsb_unregister_lowlevel(get_ohci_template());
+	hpsb_unregister_lowlevel(&ohci_template);
 	pci_unregister_driver(&ohci1394_driver);
 }
 
 static int __init ohci1394_init(void)
 {
 	int ret;
-	if (hpsb_register_lowlevel(get_ohci_template())) {
+	if (hpsb_register_lowlevel(&ohci_template)) {
 		PRINT_G(KERN_ERR, "Registering failed");
 		return -ENXIO;
 	}
 	if ((ret = pci_module_init(&ohci1394_driver))) {
 		PRINT_G(KERN_ERR, "PCI module init failed\n");
-		hpsb_unregister_lowlevel(get_ohci_template());
+		hpsb_unregister_lowlevel(&ohci_template);
 		return ret;
 	}
 	return ret;

drivers/ieee1394/pcilynx.c

@@ -58,6 +58,17 @@
 #define PRINTD(level, card, fmt, args...) do {} while (0)
 #endif
 
+static struct pci_device_id pcilynx_pci_tbl[] __devinitdata = {
+	{
+	  vendor: PCI_VENDOR_ID_TI,
+	  device: PCI_DEVICE_ID_TI_PCILYNX,
+	  subvendor: PCI_ANY_ID,
+	  subdevice: PCI_ANY_ID,
+	},
+	{ }			/* Terminating entry */
+};
+MODULE_DEVICE_TABLE(pci, pcilynx_pci_tbl);
+
 static struct ti_lynx cards[MAX_PCILYNX_CARDS];
 static int num_of_cards = 0;
 

drivers/ieee1394/video1394.c

@@ -807,7 +807,7 @@ static int video1394_ioctl(struct inode *inode, struct file *file,
 			   unsigned int cmd, unsigned long arg)
 {
 	struct video_card *video = NULL;
-	struct ti_ohci *ohci= video->ohci;
+	struct ti_ohci *ohci;
 	unsigned long flags;
 	struct list_head *lh;
 
@@ -818,6 +818,7 @@ static int video1394_ioctl(struct inode *inode, struct file *file,
 			p = list_entry(lh, struct video_card, list);
 			if (p->id == MINOR(inode->i_rdev)) {
 				video = p;
+				ohci = video->ohci;
 				break;
 			}
 		}
@@ -1602,7 +1603,7 @@ static struct hpsb_highlevel_ops hl_ops = {
 
 MODULE_AUTHOR("Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>");
 MODULE_DESCRIPTION("driver for digital video on OHCI board");
-MODULE_SUPPORTED_DEVICE("video1394");
+MODULE_SUPPORTED_DEVICE(VIDEO1394_DRIVER_NAME);
 
 static void __exit video1394_exit_module (void)
 {

drivers/net/starfire.c

@@ -87,8 +87,7 @@
 
 	LK1.3.3 (Ion Badulescu)
 	- Initialize the TxMode register properly
-	- Set the MII registers _after_ resetting it
-	- Don't dereference dev->priv after unregister_netdev() has freed it
+	- Don't dereference dev->priv after freeing it
 
 TODO:
 	- implement tx_timeout() properly
@@ -988,12 +987,12 @@ static void check_duplex(struct net_device *dev)
 	struct netdev_private *np = dev->priv;
 	u16 reg0;
 
+	mdio_write(dev, np->phys[0], MII_ADVERTISE, np->advertising);
 	mdio_write(dev, np->phys[0], MII_BMCR, BMCR_RESET);
 	udelay(500);
 	while (mdio_read(dev, np->phys[0], MII_BMCR) & BMCR_RESET);
 
 	reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
-	mdio_write(dev, np->phys[0], MII_ADVERTISE, np->advertising);
 
 	if (np->autoneg) {
 		reg0 |= BMCR_ANENABLE | BMCR_ANRESTART;
@@ -1940,12 +1939,12 @@ static void __devexit starfire_remove_one (struct pci_dev *pdev)
 		pci_free_consistent(pdev, PAGE_SIZE,
 				    np->rx_ring, np->rx_ring_dma);
 
-	unregister_netdev(dev);			/* Will also free np!! */
+	unregister_netdev(dev);
 	iounmap((char *)dev->base_addr);
 	pci_release_regions(pdev);
 
 	pci_set_drvdata(pdev, NULL);
-	kfree(dev);
+	kfree(dev);			/* Will also free np!! */
 }
 
 

drivers/usb/storage/Makefile

@@ -19,6 +19,9 @@ usb-storage-obj-$(CONFIG_USB_STORAGE_FREECOM)	+= freecom.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_SHUTTLE_SMARTMEDIA)   += shuttle_sm.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_SHUTTLE_COMPACTFLASH) += shuttle_cf.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_DPCM)	+= dpcm.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200)	+= isd200.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB)   += datafab.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT)  += jumpshot.o
 
 usb-storage-objs :=	scsiglue.o protocol.o transport.o usb.o \
 			initializers.o $(usb-storage-obj-y)

drivers/usb/storage/datafab.c

+/* Driver for Datafab USB Compact Flash reader
+ *
+ * datafab driver v0.1:
+ *
+ * First release
+ *
+ * Current development and maintenance by:
+ *   (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org)
+ *   many thanks to Robert Baruch for the SanDisk SmartMedia reader driver
+ *   which I used as a template for this driver.
+ *   Some bugfixes and scatter-gather code by Gregory P. Smith 
+ *   (greg-usb@electricrain.com)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * This driver attempts to support USB CompactFlash reader/writer devices
+ * based on Datafab USB-to-ATA chips.  It was specifically developed for the 
+ * Datafab MDCFE-B USB CompactFlash reader but has since been found to work 
+ * with a variety of Datafab-based devices from a number of manufacturers.
+ * I've received a report of this driver working with a Datafab-based
+ * SmartMedia device though please be aware that I'm personally unable to
+ * test SmartMedia support.
+ *
+ * This driver supports reading and writing.  If you're truly paranoid,
+ * however, you can force the driver into a write-protected state by setting
+ * the WP enable bits in datafab_handle_mode_sense().  Basically this means
+ * setting mode_param_header[3] = 0x80.
+ */
+
+#include "transport.h"
+#include "protocol.h"
+#include "usb.h"
+#include "debug.h"
+#include "datafab.h"
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/malloc.h>
+
+extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
+			     unsigned int len, unsigned int *act_len);
+
+static int datafab_determine_lun(struct us_data *us, struct datafab_info *info);
+
+
+static void datafab_dump_data(unsigned char *data, int len)
+{
+	unsigned char buf[80];
+	int sofar = 0;
+
+	if (!data)
+		return;
+
+	memset(buf, 0, sizeof(buf));
+
+	for (sofar = 0; sofar < len; sofar++) {
+		sprintf(buf + strlen(buf), "%02x ",
+			((unsigned int) data[sofar]) & 0xFF);
+
+		if (sofar % 16 == 15) {
+			US_DEBUGP("datafab:  %s\n", buf);
+			memset(buf, 0, sizeof(buf));
+		}
+	}
+
+	if (strlen(buf) != 0)
+		US_DEBUGP("datafab:  %s\n", buf);
+}
+
+
+static int datafab_raw_bulk(int direction,
+			    struct us_data *us,
+			    unsigned char *data, 
+		            unsigned int len)
+{
+	int result;
+	int act_len;
+	int pipe;
+
+	if (direction == SCSI_DATA_READ)
+		pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
+	else
+		pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
+
+	result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);
+
+	// if we stall, we need to clear it before we go on 
+	if (result == -EPIPE) {
+		US_DEBUGP("datafab_raw_bulk: EPIPE. clearing endpoint halt for"
+			  " pipe 0x%x, stalled at %d bytes\n", pipe, act_len);
+		usb_clear_halt(us->pusb_dev, pipe);
+	}
+
+	if (result) {
+		// NAK - that means we've retried a few times already 
+		if (result == -ETIMEDOUT) {
+			US_DEBUGP("datafab_raw_bulk:  device NAKed\n");
+			return US_BULK_TRANSFER_FAILED;
+		}
+
+		// -ENOENT -- we canceled this transfer
+		if (result == -ENOENT) {
+			US_DEBUGP("datafab_raw_bulk:  transfer aborted\n");
+			return US_BULK_TRANSFER_ABORTED;
+		}
+
+		if (result == -EPIPE) {
+			US_DEBUGP("datafab_raw_bulk:  output pipe stalled\n");
+			return USB_STOR_TRANSPORT_FAILED;
+		}
+
+		// the catch-all case
+		US_DEBUGP("datafab_raw_bulk:  unknown error\n");
+		return US_BULK_TRANSFER_FAILED;
+	}
+
+	if (act_len != len) {
+		US_DEBUGP("datafab_raw_bulk:  Warning. Transferred only %d bytes\n", act_len);
+		return US_BULK_TRANSFER_SHORT;
+	}
+
+	US_DEBUGP("datafab_raw_bulk:  Transfered %d of %d bytes\n", act_len, len);
+	return US_BULK_TRANSFER_GOOD;
+}
+
+static inline int datafab_bulk_read(struct us_data *us,
+			            unsigned char *data, 
+		                    unsigned int len)
+{
+	if (len == 0)
+		return USB_STOR_TRANSPORT_GOOD;
+
+	US_DEBUGP("datafab_bulk_read:  len = %d\n", len);
+	return datafab_raw_bulk(SCSI_DATA_READ, us, data, len);
+}
+
+
+static inline int datafab_bulk_write(struct us_data *us,
+			             unsigned char *data, 
+		                     unsigned int len)
+{
+	if (len == 0)
+		return USB_STOR_TRANSPORT_GOOD;
+
+	US_DEBUGP("datafab_bulk_write:  len = %d\n", len);
+	return datafab_raw_bulk(SCSI_DATA_WRITE, us, data, len);
+}
+
+
+static int datafab_read_data(struct us_data *us,
+		             struct datafab_info *info,
+		             u32 sector,
+		             u32 sectors, 
+		             unsigned char *dest, 
+		             int use_sg)
+{
+	unsigned char command[8] = { 0, 0, 0, 0, 0, 0xE0, 0x20, 0x01 };
+	unsigned char *buffer = NULL;
+	unsigned char *ptr;
+	unsigned char  thistime;
+	struct scatterlist *sg = NULL;
+	int totallen, len, result;
+	int sg_idx = 0, current_sg_offset = 0;
+	int transferred, rc;
+
+	// we're working in LBA mode.  according to the ATA spec, 
+	// we can support up to 28-bit addressing.  I don't know if Datafab
+	// supports beyond 24-bit addressing.  It's kind of hard to test 
+	// since it requires > 8GB CF card.
+	//
+	if (sectors > 0x0FFFFFFF)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	if (info->lun == -1) {
+		rc = datafab_determine_lun(us, info);
+		if (rc != USB_STOR_TRANSPORT_GOOD)
+			return rc;
+	}
+
+	command[5] += (info->lun << 4);
+
+	// If we're using scatter-gather, we have to create a new
+	// buffer to read all of the data in first, since a
+	// scatter-gather buffer could in theory start in the middle
+	// of a page, which would be bad. A developer who wants a
+	// challenge might want to write a limited-buffer
+	// version of this code.
+
+	totallen = sectors * info->ssize;
+
+	do {
+		// loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
+		len = min(totallen, 65536);
+
+		if (use_sg) {
+			sg = (struct scatterlist *) dest;
+			buffer = kmalloc(len, GFP_KERNEL);
+			if (buffer == NULL)
+				return USB_STOR_TRANSPORT_ERROR;
+			ptr = buffer;
+		} else {
+			ptr = dest;
+		}
+
+		thistime = (len / info->ssize) & 0xff;
+
+		command[0] = 0;
+		command[1] = thistime;
+		command[2] = sector & 0xFF;
+		command[3] = (sector >> 8) & 0xFF;
+		command[4] = (sector >> 16) & 0xFF;
+	
+		command[5] |= (sector >> 24) & 0x0F;
+
+		// send the command
+		US_DEBUGP("datafab_read_data:  sending following command\n");
+		datafab_dump_data(command, sizeof(command));
+
+		result = datafab_bulk_write(us, command, sizeof(command));
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		// read the result
+		result = datafab_bulk_read(us, ptr, len);
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		US_DEBUGP("datafab_read_data results:  %d bytes\n", len);
+		// datafab_dump_data(ptr, len);
+
+		sectors -= thistime;
+		sector  += thistime;
+
+		if (use_sg) {
+			transferred = 0;
+			while (sg_idx < use_sg && transferred < len) {
+				if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
+					US_DEBUGP("datafab_read_data:  adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
+					memcpy(sg[sg_idx].address + current_sg_offset,
+					       buffer + transferred,
+					       sg[sg_idx].length - current_sg_offset);
+					transferred += sg[sg_idx].length - current_sg_offset;
+					current_sg_offset = 0;
+					// on to the next sg buffer
+					++sg_idx;
+				} else {
+					US_DEBUGP("datafab_read_data:  adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
+					memcpy(sg[sg_idx].address + current_sg_offset,
+					       buffer + transferred,
+					       len - transferred);
+					current_sg_offset += len - transferred;
+					// this sg buffer is only partially full and we're out of data to copy in
+					break;
+				}
+			}
+			kfree(buffer);
+		} else {
+			dest += len;
+		}
+
+		totallen -= len;
+	} while (totallen > 0);
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+
+static int datafab_write_data(struct us_data *us,
+		              struct datafab_info *info,
+		              u32 sector,
+		              u32 sectors, 
+		              unsigned char *src, 
+		              int use_sg)
+{
+	unsigned char command[8] = { 0, 0, 0, 0, 0, 0xE0, 0x30, 0x02 };
+	unsigned char reply[2] = { 0, 0 };
+	unsigned char *buffer = NULL;
+	unsigned char *ptr;
+	unsigned char thistime;
+	struct scatterlist *sg = NULL;
+	int totallen, len, result;
+	int sg_idx = 0, current_sg_offset = 0;
+	int transferred, rc;
+
+	// we're working in LBA mode.  according to the ATA spec, 
+	// we can support up to 28-bit addressing.  I don't know if Datafab
+	// supports beyond 24-bit addressing.  It's kind of hard to test 
+	// since it requires > 8GB CF card.
+	//
+	if (sectors > 0x0FFFFFFF)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	if (info->lun == -1) {
+		rc = datafab_determine_lun(us, info);
+		if (rc != USB_STOR_TRANSPORT_GOOD)
+			return rc;
+	}
+
+	command[5] += (info->lun << 4);
+
+	// If we're using scatter-gather, we have to create a new
+	// buffer to read all of the data in first, since a
+	// scatter-gather buffer could in theory start in the middle
+	// of a page, which would be bad. A developer who wants a
+	// challenge might want to write a limited-buffer
+	// version of this code.
+
+	totallen = sectors * info->ssize;
+
+	do {
+		// loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
+		len = min(totallen, 65536);
+
+		if (use_sg) {
+			sg = (struct scatterlist *) src;
+			buffer = kmalloc(len, GFP_KERNEL);
+			if (buffer == NULL)
+				return USB_STOR_TRANSPORT_ERROR;
+			ptr = buffer;
+
+			memset(buffer, 0, len);
+
+			// copy the data from the sg bufs into the big contiguous buf
+			//
+			transferred = 0;
+			while (transferred < len) {
+				if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
+					US_DEBUGP("datafab_write_data:  getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
+					memcpy(ptr + transferred,
+					       sg[sg_idx].address + current_sg_offset,
+					       sg[sg_idx].length - current_sg_offset);
+					transferred += sg[sg_idx].length - current_sg_offset;
+					current_sg_offset = 0;
+					// on to the next sg buffer
+					++sg_idx;
+				} else {
+					US_DEBUGP("datafab_write_data:  getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
+					memcpy(ptr + transferred,
+					       sg[sg_idx].address + current_sg_offset,
+					       len - transferred);
+					current_sg_offset += len - transferred;
+					// we only copied part of this sg buffer
+					break;
+				}
+			}
+		} else {
+			ptr = src;
+		}
+
+		thistime = (len / info->ssize) & 0xff;
+
+		command[0] = 0;
+		command[1] = thistime;
+		command[2] = sector & 0xFF;
+		command[3] = (sector >> 8) & 0xFF;
+		command[4] = (sector >> 16) & 0xFF;
+
+		command[5] |= (sector >> 24) & 0x0F;
+
+		// send the command
+		US_DEBUGP("datafab_write_data:  sending following command\n");
+		datafab_dump_data(command, sizeof(command));
+
+		result = datafab_bulk_write(us, command, sizeof(command));
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		// send the data
+		result = datafab_bulk_write(us, ptr, len);
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		// read the result
+		result = datafab_bulk_read(us, reply, sizeof(reply));
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		if (reply[0] != 0x50 && reply[1] != 0) {
+			US_DEBUGP("datafab_write_data:  Gah! write return code: %02x %02x\n", reply[0], reply[1]);
+			if (use_sg)
+				kfree(buffer);
+			return USB_STOR_TRANSPORT_ERROR;
+		}
+
+		sectors -= thistime;
+		sector  += thistime;
+
+		if (use_sg) {
+			kfree(buffer);
+		} else {
+			src += len;
+		}
+
+		totallen -= len;
+	} while (totallen > 0);
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+
+static int datafab_determine_lun(struct us_data *us,
+				 struct datafab_info *info)
+{
+	// dual-slot readers can be thought of as dual-LUN devices.  we need to
+	// determine which card slot is being used.  we'll send an IDENTIFY DEVICE
+	// command and see which LUN responds...
+	//
+	// there might be a better way of doing this?
+	//
+	unsigned char command[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 };
+	unsigned char buf[512];
+	int count = 0, rc;
+
+	if (!us || !info)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	US_DEBUGP("datafab_determine_lun:  locating...\n");
+
+	// we'll try 10 times before giving up...
+	//
+	while (count++ < 10) {
+		command[5] = 0xa0;
+
+		rc = datafab_bulk_write(us, command, 8);
+		if (rc != USB_STOR_TRANSPORT_GOOD) 
+			return rc;
+
+		rc = datafab_bulk_read(us, buf, sizeof(buf));
+		if (rc == USB_STOR_TRANSPORT_GOOD) {
+			info->lun = 0;
+			return USB_STOR_TRANSPORT_GOOD;
+		}
+
+		command[5] = 0xb0;
+
+		rc = datafab_bulk_write(us, command, 8);
+		if (rc != USB_STOR_TRANSPORT_GOOD) 
+			return rc;
+
+		rc = datafab_bulk_read(us, buf, sizeof(buf));
+		if (rc == USB_STOR_TRANSPORT_GOOD) {
+			info->lun = 1;
+			return USB_STOR_TRANSPORT_GOOD;
+		}
+
+                wait_ms(20);
+	}
+
+	return USB_STOR_TRANSPORT_FAILED;
+}
+
+static int datafab_id_device(struct us_data *us,
+			     struct datafab_info *info)
+{
+	// this is a variation of the ATA "IDENTIFY DEVICE" command...according
+	// to the ATA spec, 'Sector Count' isn't used but the Windows driver
+	// sets this bit so we do too...
+	//
+	unsigned char command[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 };
+	unsigned char reply[512];
+	int rc;
+
+	if (!us || !info)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	if (info->lun == -1) {
+		rc = datafab_determine_lun(us, info);
+		if (rc != USB_STOR_TRANSPORT_GOOD)
+			return rc;
+	}
+
+	command[5] += (info->lun << 4);
+
+	rc = datafab_bulk_write(us, command, 8);
+	if (rc != USB_STOR_TRANSPORT_GOOD) 
+		return rc;
+
+	// we'll go ahead and extract the media capacity while we're here...
+	//
+	rc = datafab_bulk_read(us, reply, sizeof(reply));
+	if (rc == USB_STOR_TRANSPORT_GOOD) {
+		// capacity is at word offset 57-58
+		//
+		info->sectors = ((u32)(reply[117]) << 24) | 
+				((u32)(reply[116]) << 16) |
+				((u32)(reply[115]) <<  8) | 
+				((u32)(reply[114])      );
+	}
+		
+	return rc;
+}
+
+
+static int datafab_handle_mode_sense(struct us_data *us,
+				     Scsi_Cmnd * srb, 
+		                     unsigned char *ptr,
+				     int sense_6)
+{
+	unsigned char mode_param_header[8] = {
+		0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char rw_err_page[12] = {
+		0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
+	};
+	unsigned char cache_page[12] = {
+		0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char rbac_page[12] = {
+		0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char timer_page[8] = {
+		0x1C, 0x6, 0, 0, 0, 0
+	};
+	unsigned char pc, page_code;
+	unsigned short total_len = 0;
+	unsigned short param_len, i = 0;
+
+	// most of this stuff is just a hack to get things working.  the
+	// datafab reader doesn't present a SCSI interface so we
+	// fudge the SCSI commands...
+	//
+        
+	if (sense_6)
+		param_len = srb->cmnd[4];
+	else
+		param_len = ((u16) (srb->cmnd[7]) >> 8) | ((u16) (srb->cmnd[8]));
+
+	pc = srb->cmnd[2] >> 6;
+	page_code = srb->cmnd[2] & 0x3F;
+
+	switch (pc) {
+	   case 0x0:
+		US_DEBUGP("datafab_handle_mode_sense:  Current values\n");
+		break;
+	   case 0x1:
+		US_DEBUGP("datafab_handle_mode_sense:  Changeable values\n");
+		break;
+	   case 0x2:
+		US_DEBUGP("datafab_handle_mode_sense:  Default values\n");
+		break;
+	   case 0x3:
+		US_DEBUGP("datafab_handle_mode_sense:  Saves values\n");
+		break;
+	}
+
+	mode_param_header[3] = 0x80;	// write enable
+
+	switch (page_code) {
+	   case 0x0:
+		// vendor-specific mode
+		return USB_STOR_TRANSPORT_ERROR;
+
+	   case 0x1:
+		total_len = sizeof(rw_err_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
+		break;
+
+	   case 0x8:
+		total_len = sizeof(cache_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, cache_page, sizeof(cache_page));
+		break;
+
+	   case 0x1B:
+		total_len = sizeof(rbac_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
+		break;
+
+	   case 0x1C:
+		total_len = sizeof(timer_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, timer_page, sizeof(timer_page));
+		break;
+
+	   case 0x3F:		// retrieve all pages
+		total_len = sizeof(timer_page) + sizeof(rbac_page) +
+		    sizeof(cache_page) + sizeof(rw_err_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, timer_page, sizeof(timer_page));
+		i += sizeof(timer_page);
+		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
+		i += sizeof(rbac_page);
+		memcpy(ptr + i, cache_page, sizeof(cache_page));
+		i += sizeof(cache_page);
+		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
+		break;
+	}
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+void datafab_info_destructor(void *extra)
+{
+	// this routine is a placeholder...
+	// currently, we don't allocate any extra memory so we're okay
+}
+
+
+// Transport for the Datafab MDCFE-B
+//
+int datafab_transport(Scsi_Cmnd * srb, struct us_data *us)
+{
+	struct datafab_info *info;
+	int rc;
+	unsigned long block, blocks;
+	unsigned char *ptr = NULL;
+	unsigned char inquiry_reply[36] = {
+		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
+	};
+
+	if (!us->extra) {
+		us->extra = kmalloc(sizeof(struct datafab_info), GFP_KERNEL);
+		if (!us->extra) {
+			US_DEBUGP("datafab_transport:  Gah! Can't allocate storage for Datafab info struct!\n");
+			return USB_STOR_TRANSPORT_ERROR;
+		}
+		memset(us->extra, 0, sizeof(struct datafab_info));
+		us->extra_destructor = datafab_info_destructor;
+  		((struct datafab_info *)us->extra)->lun = -1;
+	}
+
+	info = (struct datafab_info *) (us->extra);
+	ptr = (unsigned char *) srb->request_buffer;
+
+	if (srb->cmnd[0] == INQUIRY) {
+		US_DEBUGP("datafab_transport:  INQUIRY.  Returning bogus response");
+		memset( inquiry_reply + 8, 0, 28 );
+		fill_inquiry_response(us, inquiry_reply, 36);
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	if (srb->cmnd[0] == READ_CAPACITY) {
+		info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec
+		rc = datafab_id_device(us, info);
+		if (rc != USB_STOR_TRANSPORT_GOOD)
+			return rc;
+
+		US_DEBUGP("datafab_transport:  READ_CAPACITY:  %ld sectors, %ld bytes per sector\n",
+			  info->sectors, info->ssize);
+
+		// build the reply
+		//
+		ptr[0] = (info->sectors >> 24) & 0xFF;
+		ptr[1] = (info->sectors >> 16) & 0xFF;
+		ptr[2] = (info->sectors >> 8) & 0xFF;
+		ptr[3] = (info->sectors) & 0xFF;
+
+		ptr[4] = (info->ssize >> 24) & 0xFF;
+		ptr[5] = (info->ssize >> 16) & 0xFF;
+		ptr[6] = (info->ssize >> 8) & 0xFF;
+		ptr[7] = (info->ssize) & 0xFF;
+
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	if (srb->cmnd[0] == MODE_SELECT_10) {
+		US_DEBUGP("datafab_transport:  Gah! MODE_SELECT_10.\n");
+		return USB_STOR_TRANSPORT_ERROR;
+	}
+
+	// don't bother implementing READ_6 or WRITE_6.  Just set MODE_XLATE and
+	// let the usb storage code convert to READ_10/WRITE_10
+	//
+	if (srb->cmnd[0] == READ_10) {
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
+
+		US_DEBUGP("datafab_transport:  READ_10: read block 0x%04lx  count %ld\n", block, blocks);
+		return datafab_read_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == READ_12) {
+		// we'll probably never see a READ_12 but we'll do it anyway...
+		//
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
+		         ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
+
+		US_DEBUGP("datafab_transport:  READ_12: read block 0x%04lx  count %ld\n", block, blocks);
+		return datafab_read_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == WRITE_10) {
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
+
+		US_DEBUGP("datafab_transport:  WRITE_10: write block 0x%04lx  count %ld\n", block, blocks);
+		return datafab_write_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == WRITE_12) {
+		// we'll probably never see a WRITE_12 but we'll do it anyway...
+		//
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
+		         ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
+
+		US_DEBUGP("datafab_transport:  WRITE_12: write block 0x%04lx  count %ld\n", block, blocks);
+		return datafab_write_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == TEST_UNIT_READY) {
+		US_DEBUGP("datafab_transport:  TEST_UNIT_READY.\n");
+		return datafab_id_device(us, info);
+	}
+
+	if (srb->cmnd[0] == REQUEST_SENSE) {
+		US_DEBUGP("datafab_transport:  REQUEST_SENSE.  Returning faked response\n");
+
+		// this response is pretty bogus right now.  eventually if necessary
+		// we can set the correct sense data.  so far though it hasn't been
+		// necessary
+		//
+		ptr[0] = 0xF0;
+		ptr[2] = info->sense_key;
+		ptr[7] = 11;
+		ptr[12] = info->sense_asc;
+		ptr[13] = info->sense_ascq;
+
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	if (srb->cmnd[0] == MODE_SENSE) {
+		US_DEBUGP("datafab_transport:  MODE_SENSE_6 detected\n");
+		return datafab_handle_mode_sense(us, srb, ptr, TRUE);
+	}
+
+	if (srb->cmnd[0] == MODE_SENSE_10) {
+		US_DEBUGP("datafab_transport:  MODE_SENSE_10 detected\n");
+		return datafab_handle_mode_sense(us, srb, ptr, FALSE);
+	}
+
+	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
+		// sure.  whatever.  not like we can stop the user from
+		// popping the media out of the device (no locking doors, etc)
+		//
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	US_DEBUGP("datafab_transport:  Gah! Unknown command: %d (0x%x)\n", srb->cmnd[0], srb->cmnd[0]);
+	return USB_STOR_TRANSPORT_ERROR;
+}

drivers/usb/storage/datafab.h

+/* Driver for Datafab MDCFE-B USB Compact Flash reader
+ * Header File
+ *
+ * Current development and maintenance by:
+ *   (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org)
+ *
+ * See datafab.c for more explanation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _USB_DATAFAB_MDCFE_B_H
+#define _USB_DATAFAB_MDCFE_B_H
+
+#define min(a,b) (((a)<(b))?(a):(b))  // this is defined in tons of header files, i wish it had a standard single definition...
+
+extern int datafab_transport(Scsi_Cmnd *srb, struct us_data *us);
+
+struct datafab_info {
+	unsigned long   sectors;     // total sector count
+	unsigned long   ssize;       // sector size in bytes
+	char            lun;         // used for dual-slot readers
+        
+        // the following aren't used yet
+	unsigned char   sense_key;
+	unsigned long   sense_asc;   // additional sense code
+	unsigned long   sense_ascq;  // additional sense code qualifier
+};
+
+#endif

drivers/usb/storage/debug.c

 /* Driver for USB Mass Storage compliant devices
  * Debugging Functions Source Code File
  *
- * $Id: debug.c,v 1.4 2000/09/04 02:12:47 groovyjava Exp $
+ * $Id: debug.c,v 1.5 2001/06/27 23:20:45 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -302,12 +302,10 @@ void usb_stor_show_sense(
 	case 0x1C00: what="defect list not found"; break;
 	case 0x2400: what="invalid field in CDB"; break;
 	case 0x2703: what="associated write protect"; break;
-	case 0x2800: what="not ready to ready transition (media change?)";
-		break;
+	case 0x2800: what="not ready to ready transition"; break;
 	case 0x2903: what="bus device reset function occurred"; break;
 	case 0x2904: what="device internal reset"; break;
-	case 0x2B00: what="copy can't execute since host can't disconnect"; 
-									break;
+	case 0x2B00: what="copy can't execute / host can't disconnect"; break;
 	case 0x2C00: what="command sequence error"; break;
 	case 0x2C03: what="current program area is not empty"; break;
 	case 0x2C04: what="current program area is empty"; break;

drivers/usb/storage/dpcm.c

 /* Driver for Microtech DPCM-USB CompactFlash/SmartMedia reader
  *
- * $Id: dpcm.c,v 1.3 2000/08/25 00:13:51 mdharm Exp $
+ * $Id: dpcm.c,v 1.4 2001/06/11 02:54:25 mdharm Exp $
  *
  * DPCM driver v0.1:
  *

drivers/usb/storage/freecom.c

 /* Driver for Freecom USB/IDE adaptor
  *
- * $Id: freecom.c,v 1.14 2000/11/13 22:27:57 mdharm Exp $
+ * $Id: freecom.c,v 1.15 2001/06/27 23:50:28 mdharm Exp $
  *
  * Freecom v0.1:
  *

drivers/usb/storage/isd200.c

+/* Transport & Protocol Driver for In-System Design, Inc. ISD200 ASIC
+ *
+ * First release
+ *
+ * Current development and maintenance by:
+ *   (c) 2000 In-System Design, Inc. (support@in-system.com)
+ *
+ * The ISD200 ASIC does not natively support ATA devices.  The chip
+ * does implement an interface, the ATA Command Block (ATACB) which provides
+ * a means of passing ATA commands and ATA register accesses to a device.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * History:
+ *
+ *  2001-02-24: Removed lots of duplicate code and simplified the structure.
+ *              (bjorn@haxx.se)
+ */
+
+
+/* Include files */
+
+#include "transport.h"
+#include "protocol.h"
+#include "usb.h"
+#include "debug.h"
+#include "scsiglue.h"
+#include "isd200.h"
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/malloc.h>
+#include <linux/hdreg.h>
+#include <linux/ide.h>
+
+/*
+ * Inquiry defines. Used to interpret data returned from target as result
+ * of inquiry command.
+ *
+ * DeviceType field
+ */
+
+#define DIRECT_ACCESS_DEVICE            0x00    /* disks */
+
+/* Timeout defines (in Seconds) */
+
+#define ISD200_ENUM_BSY_TIMEOUT         35
+#define ISD200_ENUM_DETECT_TIMEOUT      30
+#define ISD200_DEFAULT_TIMEOUT          30
+
+/* device flags */
+#define DF_ATA_DEVICE               0x0001
+#define DF_MEDIA_STATUS_ENABLED     0x0002
+#define DF_REMOVABLE_MEDIA          0x0004
+
+/* capability bit definitions */
+#define CAPABILITY_DMA		0x01
+#define CAPABILITY_LBA		0x02
+
+/* command_setX bit definitions */
+#define COMMANDSET_REMOVABLE	0x02
+#define COMMANDSET_MEDIA_STATUS 0x10
+
+/* ATA Vendor Specific defines */
+#define ATA_ADDRESS_DEVHEAD_STD      0xa0
+#define ATA_ADDRESS_DEVHEAD_LBA_MODE 0x40    
+#define ATA_ADDRESS_DEVHEAD_SLAVE    0x10
+
+/* Action Select bits */
+#define ACTION_SELECT_0             0x01
+#define ACTION_SELECT_1             0x02
+#define ACTION_SELECT_2             0x04
+#define ACTION_SELECT_3             0x08
+#define ACTION_SELECT_4             0x10
+#define ACTION_SELECT_5             0x20
+#define ACTION_SELECT_6             0x40
+#define ACTION_SELECT_7             0x80
+
+/* ATA error definitions not in <linux/hdreg.h> */
+#define ATA_ERROR_MEDIA_CHANGE       0x20
+
+/* ATA command definitions not in <linux/hdreg.h> */
+#define ATA_COMMAND_GET_MEDIA_STATUS        0xDA
+#define ATA_COMMAND_MEDIA_EJECT             0xED
+
+/* ATA drive control definitions */
+#define ATA_DC_DISABLE_INTERRUPTS    0x02
+#define ATA_DC_RESET_CONTROLLER      0x04
+#define ATA_DC_REENABLE_CONTROLLER   0x00
+
+/*
+ *  General purpose return codes
+ */ 
+
+#define ISD200_ERROR                -1
+#define ISD200_GOOD                 0
+
+/*
+ * Transport return codes
+ */
+
+#define ISD200_TRANSPORT_GOOD       0   /* Transport good, command good     */
+#define ISD200_TRANSPORT_FAILED     1   /* Transport good, command failed   */
+#define ISD200_TRANSPORT_ERROR      2   /* Transport bad (i.e. device dead) */
+#define ISD200_TRANSPORT_ABORTED    3   /* Transport aborted                */
+#define ISD200_TRANSPORT_SHORT      4   /* Transport short                  */
+
+/* driver action codes */
+#define	ACTION_READ_STATUS	0
+#define	ACTION_RESET		1
+#define	ACTION_REENABLE		2
+#define	ACTION_SOFT_RESET	3
+#define	ACTION_ENUM		4
+#define	ACTION_IDENTIFY		5
+
+
+/*
+ * ata_cdb struct
+ */
+
+
+union ata_cdb {
+	struct {
+		unsigned char SignatureByte0;
+		unsigned char SignatureByte1;
+		unsigned char ActionSelect;
+		unsigned char RegisterSelect;
+		unsigned char TransferBlockSize;
+		unsigned char WriteData3F6;
+		unsigned char WriteData1F1;
+		unsigned char WriteData1F2;
+		unsigned char WriteData1F3;
+		unsigned char WriteData1F4;
+		unsigned char WriteData1F5;
+		unsigned char WriteData1F6;
+		unsigned char WriteData1F7;
+		unsigned char Reserved[3];
+	} generic;
+        
+	struct {
+		unsigned char SignatureByte0;
+		unsigned char SignatureByte1;
+		unsigned char ReadRegisterAccessBit : 1;
+		unsigned char NoDeviceSelectionBit : 1;
+		unsigned char NoBSYPollBit : 1;
+		unsigned char IgnorePhaseErrorBit : 1;
+		unsigned char IgnoreDeviceErrorBit : 1;
+		unsigned char Reserved0Bit : 3;
+		unsigned char SelectAlternateStatus : 1;
+		unsigned char SelectError : 1;
+		unsigned char SelectSectorCount : 1;
+		unsigned char SelectSectorNumber : 1;
+		unsigned char SelectCylinderLow : 1;
+		unsigned char SelectCylinderHigh : 1;
+		unsigned char SelectDeviceHead : 1;
+		unsigned char SelectStatus : 1;
+		unsigned char TransferBlockSize;
+		unsigned char AlternateStatusByte;
+		unsigned char ErrorByte;
+		unsigned char SectorCountByte;
+		unsigned char SectorNumberByte;
+		unsigned char CylinderLowByte;
+		unsigned char CylinderHighByte;
+		unsigned char DeviceHeadByte;
+		unsigned char StatusByte;
+		unsigned char Reserved[3];
+	} read;
+
+        struct {
+		unsigned char SignatureByte0;
+		unsigned char SignatureByte1;
+		unsigned char ReadRegisterAccessBit : 1;
+		unsigned char NoDeviceSelectionBit : 1;
+		unsigned char NoBSYPollBit : 1;
+		unsigned char IgnorePhaseErrorBit : 1;
+		unsigned char IgnoreDeviceErrorBit : 1;
+		unsigned char Reserved0Bit : 3;
+		unsigned char SelectDeviceControl : 1;
+		unsigned char SelectFeatures : 1;
+		unsigned char SelectSectorCount : 1;
+		unsigned char SelectSectorNumber : 1;
+		unsigned char SelectCylinderLow : 1;
+		unsigned char SelectCylinderHigh : 1;
+		unsigned char SelectDeviceHead : 1;
+		unsigned char SelectCommand : 1;
+		unsigned char TransferBlockSize;
+		unsigned char DeviceControlByte;
+		unsigned char FeaturesByte;
+		unsigned char SectorCountByte;
+		unsigned char SectorNumberByte;
+		unsigned char CylinderLowByte;
+		unsigned char CylinderHighByte;
+		unsigned char DeviceHeadByte;
+		unsigned char CommandByte;
+		unsigned char Reserved[3];
+	} write;
+};
+
+
+/*
+ * Inquiry data structure. This is the data returned from the target
+ * after it receives an inquiry.
+ *
+ * This structure may be extended by the number of bytes specified
+ * in the field AdditionalLength. The defined size constant only
+ * includes fields through ProductRevisionLevel.
+ */
+
+struct inquiry_data {
+	unsigned char DeviceType : 5;
+	unsigned char DeviceTypeQualifier : 3;
+	unsigned char DeviceTypeModifier : 7;
+	unsigned char RemovableMedia : 1;
+	unsigned char Versions;
+	unsigned char ResponseDataFormat : 4;
+	unsigned char HiSupport : 1;
+	unsigned char NormACA : 1;
+	unsigned char ReservedBit : 1;
+	unsigned char AERC : 1;
+	unsigned char AdditionalLength;
+	unsigned char Reserved[2];
+	unsigned char SoftReset : 1;
+	unsigned char CommandQueue : 1;
+	unsigned char Reserved2 : 1;
+	unsigned char LinkedCommands : 1;
+	unsigned char Synchronous : 1;
+	unsigned char Wide16Bit : 1;
+	unsigned char Wide32Bit : 1;
+	unsigned char RelativeAddressing : 1;
+	unsigned char VendorId[8];
+	unsigned char ProductId[16];
+	unsigned char ProductRevisionLevel[4];
+	unsigned char VendorSpecific[20];
+	unsigned char Reserved3[40];
+} __attribute__ ((packed));
+
+/*
+ * INQUIRY data buffer size
+ */
+
+#define INQUIRYDATABUFFERSIZE 36
+
+
+/*
+ * ISD200 CONFIG data struct
+ */
+
+struct isd200_config {
+        unsigned char EventNotification;
+        unsigned char ExternalClock;
+        unsigned char ATAInitTimeout;
+        unsigned char ATATiming : 4;
+        unsigned char ATAPIReset : 1;
+        unsigned char MasterSlaveSelection : 1;
+        unsigned char ATAPICommandBlockSize : 2;
+        unsigned char ATAMajorCommand;
+        unsigned char ATAMinorCommand;
+        unsigned char LastLUNIdentifier : 3;
+        unsigned char DescriptOverride : 1;
+        unsigned char ATA3StateSuspend : 1;
+        unsigned char SkipDeviceBoot : 1;
+        unsigned char ConfigDescriptor2 : 1;
+        unsigned char InitStatus : 1;
+        unsigned char SRSTEnable : 1;
+        unsigned char Reserved0 : 7;
+};
+
+
+/*
+ * ISD200 driver information struct
+ */
+
+struct isd200_info {
+	struct inquiry_data InquiryData;
+	struct hd_driveid drive;
+	struct isd200_config ConfigData;
+	unsigned char ATARegs[8];
+	unsigned char DeviceHead;
+	unsigned char DeviceFlags;
+
+	/* maximum number of LUNs supported */
+	unsigned char MaxLUNs;
+};
+
+
+/*
+ * Read Capacity Data - returned in Big Endian format
+ */
+
+struct read_capacity_data {
+	unsigned long LogicalBlockAddress;
+	unsigned long BytesPerBlock;
+};
+
+/*
+ * Read Block Limits Data - returned in Big Endian format
+ * This structure returns the maximum and minimum block
+ * size for a TAPE device.
+ */
+
+struct read_block_limits {
+	unsigned char Reserved;
+	unsigned char BlockMaximumSize[3];
+	unsigned char BlockMinimumSize[2];
+};
+
+
+/*
+ * Sense Data Format
+ */
+
+struct sense_data {
+        unsigned char ErrorCode:7;
+        unsigned char Valid:1;
+        unsigned char SegmentNumber;
+        unsigned char SenseKey:4;
+        unsigned char Reserved:1;
+        unsigned char IncorrectLength:1;
+        unsigned char EndOfMedia:1;
+        unsigned char FileMark:1;
+        unsigned char Information[4];
+        unsigned char AdditionalSenseLength;
+        unsigned char CommandSpecificInformation[4];
+        unsigned char AdditionalSenseCode;
+        unsigned char AdditionalSenseCodeQualifier;
+        unsigned char FieldReplaceableUnitCode;
+        unsigned char SenseKeySpecific[3];
+} __attribute__ ((packed));
+
+/*
+ * Default request sense buffer size
+ */
+
+#define SENSE_BUFFER_SIZE 18
+
+/***********************************************************************
+ * Helper routines
+ ***********************************************************************/
+
+
+/**************************************************************************
+ * isd200_build_sense
+ *                                                                         
+ *  Builds an artificial sense buffer to report the results of a 
+ *  failed command.
+ *                                                                       
+ * RETURNS:
+ *    void
+ */                                                                        
+void isd200_build_sense(struct us_data *us, Scsi_Cmnd *srb)
+{
+        struct isd200_info *info = (struct isd200_info *)us->extra;
+        struct sense_data *buf = (struct sense_data *) &srb->sense_buffer[0];
+        unsigned char error = info->ATARegs[IDE_ERROR_OFFSET];
+
+	if(error & ATA_ERROR_MEDIA_CHANGE) {
+		buf->ErrorCode = 0x70;
+		buf->Valid     = 1;
+		buf->AdditionalSenseLength = 0xb;
+		buf->SenseKey =  UNIT_ATTENTION;
+		buf->AdditionalSenseCode = 0;
+		buf->AdditionalSenseCodeQualifier = 0;
+        } else if(error & MCR_ERR) {
+		buf->ErrorCode = 0x70;
+		buf->Valid     = 1;
+		buf->AdditionalSenseLength = 0xb;
+		buf->SenseKey =  UNIT_ATTENTION;
+		buf->AdditionalSenseCode = 0;
+		buf->AdditionalSenseCodeQualifier = 0;
+        } else if(error & TRK0_ERR) {
+		buf->ErrorCode = 0x70;
+		buf->Valid     = 1;
+		buf->AdditionalSenseLength = 0xb;
+		buf->SenseKey =  NOT_READY;
+		buf->AdditionalSenseCode = 0;
+		buf->AdditionalSenseCodeQualifier = 0;
+        } else if(error & ECC_ERR) {
+		buf->ErrorCode = 0x70;
+		buf->Valid     = 1;
+		buf->AdditionalSenseLength = 0xb;
+		buf->SenseKey =  DATA_PROTECT;
+		buf->AdditionalSenseCode = 0;
+		buf->AdditionalSenseCodeQualifier = 0;
+        } else {
+		buf->ErrorCode = 0;
+		buf->Valid     = 0;
+		buf->AdditionalSenseLength = 0;
+		buf->SenseKey =  0;
+		buf->AdditionalSenseCode = 0;
+		buf->AdditionalSenseCodeQualifier = 0;
+        }
+}
+
+/***********************************************************************
+ * Data transfer routines
+ ***********************************************************************/
+
+
+/**************************************************************************
+ * Transfer one SCSI scatter-gather buffer via bulk transfer
+ *
+ * Note that this function is necessary because we want the ability to
+ * use scatter-gather memory.  Good performance is achieved by a combination
+ * of scatter-gather and clustering (which makes each chunk bigger).
+ *
+ * Note that the lower layer will always retry when a NAK occurs, up to the
+ * timeout limit.  Thus we don't have to worry about it for individual
+ * packets.
+ */
+static int isd200_transfer_partial( struct us_data *us, 
+				    unsigned char dataDirection,
+				    char *buf, int length )
+{
+        int result;
+        int partial;
+        int pipe;
+
+        /* calculate the appropriate pipe information */
+	if (dataDirection == SCSI_DATA_READ)
+                pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
+        else
+                pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
+
+        /* transfer the data */
+        US_DEBUGP("isd200_transfer_partial(): xfer %d bytes\n", length);
+        result = usb_stor_bulk_msg(us, buf, pipe, length, &partial);
+        US_DEBUGP("usb_stor_bulk_msg() returned %d xferred %d/%d\n",
+                  result, partial, length);
+
+        /* if we stall, we need to clear it before we go on */
+        if (result == -EPIPE) {
+                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
+                usb_stor_clear_halt(us->pusb_dev, pipe);
+        }
+    
+        /* did we send all the data? */
+        if (partial == length) {
+                US_DEBUGP("isd200_transfer_partial(): transfer complete\n");
+                return ISD200_TRANSPORT_GOOD;
+        }
+
+        /* uh oh... we have an error code, so something went wrong. */
+        if (result) {
+                /* NAK - that means we've retried a few times already */
+                if (result == -ETIMEDOUT) {
+                        US_DEBUGP("isd200_transfer_partial(): device NAKed\n");
+                        return ISD200_TRANSPORT_FAILED;
+                }
+
+                /* -ENOENT -- we canceled this transfer */
+                if (result == -ENOENT) {
+                        US_DEBUGP("isd200_transfer_partial(): transfer aborted\n");
+                        return ISD200_TRANSPORT_ABORTED;
+                }
+
+                /* the catch-all case */
+                US_DEBUGP("isd200_transfer_partial(): unknown error\n");
+                return ISD200_TRANSPORT_FAILED;
+        }
+
+        /* no error code, so we must have transferred some data, 
+         * just not all of it */
+        return ISD200_TRANSPORT_SHORT;
+}
+
+
+/**************************************************************************
+ * Transfer an entire SCSI command's worth of data payload over the bulk
+ * pipe.
+ *
+ * Note that this uses us_transfer_partial to achieve it's goals -- this
+ * function simply determines if we're going to use scatter-gather or not,
+ * and acts appropriately.  For now, it also re-interprets the error codes.
+ */
+static void isd200_transfer( struct us_data *us, Scsi_Cmnd *srb )
+{
+        int i;
+        int result = -1;
+        struct scatterlist *sg;
+        unsigned int total_transferred = 0;
+        unsigned int transfer_amount;
+
+        /* calculate how much we want to transfer */
+	int dir = srb->sc_data_direction;
+	srb->sc_data_direction = SCSI_DATA_WRITE;
+        transfer_amount = usb_stor_transfer_length(srb);
+	srb->sc_data_direction = dir;
+
+        /* was someone foolish enough to request more data than available
+         * buffer space? */
+        if (transfer_amount > srb->request_bufflen)
+                transfer_amount = srb->request_bufflen;
+
+        /* are we scatter-gathering? */
+        if (srb->use_sg) {
+
+                /* loop over all the scatter gather structures and 
+                 * make the appropriate requests for each, until done
+                 */
+                sg = (struct scatterlist *) srb->request_buffer;
+                for (i = 0; i < srb->use_sg; i++) {
+
+                        /* transfer the lesser of the next buffer or the
+                         * remaining data */
+                        if (transfer_amount - total_transferred >= 
+                            sg[i].length) {
+                                result = isd200_transfer_partial(us, 
+                                                                 srb->sc_data_direction,
+                                                                 sg[i].address, 
+                                                                 sg[i].length);
+                                total_transferred += sg[i].length;
+                        } else
+                                result = isd200_transfer_partial(us, 
+                                                                 srb->sc_data_direction,                            
+                                                                 sg[i].address,
+                                                                 transfer_amount - total_transferred);
+
+                        /* if we get an error, end the loop here */
+                        if (result)
+                                break;
+                }
+        }
+        else
+                /* no scatter-gather, just make the request */
+                result = isd200_transfer_partial(us, 
+                                                 srb->sc_data_direction,
+                                                 srb->request_buffer, 
+                                                 transfer_amount);
+
+        /* return the result in the data structure itself */
+        srb->result = result;
+}
+
+
+/***********************************************************************
+ * Transport routines
+ ***********************************************************************/
+
+
+/**************************************************************************
+ *  ISD200 Bulk Transport
+ *
+ * Note:  This routine was copied from the usb_stor_Bulk_transport routine
+ * located in the transport.c source file.  The scsi command is limited to
+ * only 12 bytes while the CDB for the ISD200 must be 16 bytes.
+ */
+int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb, 
+                           union ata_cdb *AtaCdb, unsigned char AtaCdbLength )
+{
+        struct bulk_cb_wrap bcb;
+        struct bulk_cs_wrap bcs;
+        int result;
+        int pipe;
+        int partial;
+        unsigned int transfer_amount;
+
+	int dir = srb->sc_data_direction;
+	srb->sc_data_direction = SCSI_DATA_WRITE;
+        transfer_amount = usb_stor_transfer_length(srb);
+	srb->sc_data_direction = dir;
+    
+        /* set up the command wrapper */
+        bcb.Signature = cpu_to_le32(US_BULK_CB_SIGN);
+        bcb.DataTransferLength = cpu_to_le32(transfer_amount);
+        bcb.Flags = srb->sc_data_direction == SCSI_DATA_READ ? 1 << 7 : 0;
+        bcb.Tag = srb->serial_number;
+        bcb.Lun = srb->cmnd[1] >> 5;
+        if (us->flags & US_FL_SCM_MULT_TARG)
+                bcb.Lun |= srb->target << 4;
+
+        bcb.Length = AtaCdbLength;
+    
+        /* construct the pipe handle */
+        pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
+    
+        /* copy the command payload */
+        memset(bcb.CDB, 0, sizeof(bcb.CDB));
+        memcpy(bcb.CDB, AtaCdb, bcb.Length);
+    
+        /* send it to out endpoint */
+        US_DEBUGP("Bulk command S 0x%x T 0x%x Trg %d LUN %d L %d F %d CL %d\n",
+                  le32_to_cpu(bcb.Signature), bcb.Tag,
+                  (bcb.Lun >> 4), (bcb.Lun & 0xFF), 
+                  bcb.DataTransferLength, bcb.Flags, bcb.Length);
+        result = usb_stor_bulk_msg(us, &bcb, pipe, US_BULK_CB_WRAP_LEN, 
+				   &partial);
+        US_DEBUGP("Bulk command transfer result=%d\n", result);
+    
+	if (result == -ENOENT)
+		return ISD200_TRANSPORT_ABORTED;
+	else if (result == -EPIPE) {
+		/* if we stall, we need to clear it before we go on */
+                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
+                usb_stor_clear_halt(us->pusb_dev, pipe);
+	} else if (result)  
+                return ISD200_TRANSPORT_ERROR;
+    
+        /* if the command transfered well, then we go to the data stage */
+        if (!result && bcb.DataTransferLength) {
+		isd200_transfer(us, srb);
+		US_DEBUGP("Bulk data transfer result 0x%x\n", srb->result);
+		
+		if (srb->result == ISD200_TRANSPORT_ABORTED)
+			return ISD200_TRANSPORT_ABORTED;
+        }
+    
+        /* See flow chart on pg 15 of the Bulk Only Transport spec for
+         * an explanation of how this code works.
+         */
+    
+        /* construct the pipe handle */
+        pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
+    
+        /* get CSW for device status */
+        US_DEBUGP("Attempting to get CSW...\n");
+        result = usb_stor_bulk_msg(us, &bcs, pipe, US_BULK_CS_WRAP_LEN, 
+				   &partial);
+        if (result == -ENOENT)
+                return ISD200_TRANSPORT_ABORTED;
+
+        /* did the attempt to read the CSW fail? */
+        if (result == -EPIPE) {
+                US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
+                usb_stor_clear_halt(us->pusb_dev, pipe);
+           
+                /* get the status again */
+                US_DEBUGP("Attempting to get CSW (2nd try)...\n");
+                result = usb_stor_bulk_msg(us, &bcs, pipe,
+                                           US_BULK_CS_WRAP_LEN, &partial);
+
+                /* if the command was aborted, indicate that */
+                if (result == -ENOENT)
+                        return ISD200_TRANSPORT_ABORTED;
+        
+                /* if it fails again, we need a reset and return an error*/
+                if (result == -EPIPE) {
+                        US_DEBUGP("clearing halt for pipe 0x%x\n", pipe);
+                        usb_stor_clear_halt(us->pusb_dev, pipe);
+                        return ISD200_TRANSPORT_ERROR;
+                }
+        }
+    
+        /* if we still have a failure at this point, we're in trouble */
+        US_DEBUGP("Bulk status result = %d\n", result);
+        if (result)
+                return ISD200_TRANSPORT_ERROR;
+    
+        /* check bulk status */
+        US_DEBUGP("Bulk status Sig 0x%x T 0x%x R %d Stat 0x%x\n",
+                  le32_to_cpu(bcs.Signature), bcs.Tag, 
+                  bcs.Residue, bcs.Status);
+        if (bcs.Signature != cpu_to_le32(US_BULK_CS_SIGN) || 
+            bcs.Tag != bcb.Tag || 
+            bcs.Status > US_BULK_STAT_PHASE || partial != 13) {
+                US_DEBUGP("Bulk logical error\n");
+                return ISD200_TRANSPORT_ERROR;
+        }
+    
+        /* based on the status code, we report good or bad */
+        switch (bcs.Status) {
+        case US_BULK_STAT_OK:
+                /* command good -- note that we could be short on data */
+                return ISD200_TRANSPORT_GOOD;
+
+        case US_BULK_STAT_FAIL:
+                /* command failed */
+                return ISD200_TRANSPORT_FAILED;
+        
+        case US_BULK_STAT_PHASE:
+                /* phase error */
+                usb_stor_Bulk_reset(us);
+                return ISD200_TRANSPORT_ERROR;
+        }
+    
+        /* we should never get here, but if we do, we're in trouble */
+        return ISD200_TRANSPORT_ERROR;
+}
+
+
+/**************************************************************************
+ *  isd200_action
+ *
+ * Routine for sending commands to the isd200
+ *
+ * RETURNS:
+ *    ISD status code
+ */
+static int isd200_action( struct us_data *us, int action, 
+			  void* pointer, int value )
+{
+	union ata_cdb ata;
+	struct scsi_cmnd srb;
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int status;
+
+	memset(&ata, 0, sizeof(ata));
+	memset(&srb, 0, sizeof(srb));
+
+	ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+	ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+	ata.generic.TransferBlockSize = 1;
+
+	switch ( action ) {
+	case ACTION_READ_STATUS:
+		US_DEBUGP("   isd200_action(READ_STATUS)\n");
+		ata.generic.ActionSelect = ACTION_SELECT_0|ACTION_SELECT_2;
+		ata.read.SelectStatus = 1;
+		ata.read.SelectError = 1;
+		ata.read.SelectCylinderHigh = 1;
+		ata.read.SelectCylinderLow = 1;
+		srb.sc_data_direction = SCSI_DATA_READ;
+		srb.request_buffer = pointer;
+		srb.request_bufflen = value;
+		break;
+
+	case ACTION_ENUM:
+		US_DEBUGP("   isd200_action(ENUM,0x%02x)\n",value);
+		ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
+			                   ACTION_SELECT_3|ACTION_SELECT_4|
+		                           ACTION_SELECT_5;
+		ata.write.SelectDeviceHead = 1;
+		ata.write.DeviceHeadByte = value;
+		srb.sc_data_direction = SCSI_DATA_NONE;
+		break;
+
+	case ACTION_RESET:
+		US_DEBUGP("   isd200_action(RESET)\n");
+		ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
+			                   ACTION_SELECT_3|ACTION_SELECT_4;
+		ata.write.SelectDeviceControl = 1;
+		ata.write.DeviceControlByte = ATA_DC_RESET_CONTROLLER;
+		srb.sc_data_direction = SCSI_DATA_NONE;
+		break;
+
+	case ACTION_REENABLE:
+		US_DEBUGP("   isd200_action(REENABLE)\n");
+		ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
+			                   ACTION_SELECT_3|ACTION_SELECT_4;
+		ata.write.SelectDeviceControl = 1;
+		ata.write.DeviceControlByte = ATA_DC_REENABLE_CONTROLLER;
+		srb.sc_data_direction = SCSI_DATA_NONE;
+		break;
+
+	case ACTION_SOFT_RESET:
+		US_DEBUGP("   isd200_action(SOFT_RESET)\n");
+		ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_5;
+		ata.write.SelectDeviceHead = 1;
+		ata.write.DeviceHeadByte = info->DeviceHead;
+		ata.write.SelectCommand = 1;
+		ata.write.CommandByte = WIN_SRST;
+		srb.sc_data_direction = SCSI_DATA_NONE;
+		break;
+
+	case ACTION_IDENTIFY:
+		US_DEBUGP("   isd200_action(IDENTIFY)\n");
+		ata.write.SelectCommand = 1;
+		ata.write.CommandByte = WIN_IDENTIFY;
+		srb.sc_data_direction = SCSI_DATA_READ;
+		srb.request_buffer = (void *)&info->drive;
+		srb.request_bufflen = sizeof(struct hd_driveid);
+		break;
+
+	default:
+		US_DEBUGP("Error: Undefined action %d\n",action);
+		break;
+	}
+
+	status = isd200_Bulk_transport(us, &srb, &ata, sizeof(ata.generic));
+	if (status != ISD200_TRANSPORT_GOOD) {
+		US_DEBUGP("   isd200_action(0x%02x) error: %d\n",action,status);
+		status = ISD200_ERROR;
+		/* need to reset device here */
+	}
+
+	return status;
+}
+
+/**************************************************************************
+ * isd200_read_regs
+ *                                                                         
+ * Read ATA Registers
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+int isd200_read_regs( struct us_data *us )
+{
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int retStatus = ISD200_GOOD;
+	int transferStatus;
+
+	US_DEBUGP("Entering isd200_IssueATAReadRegs\n");
+
+	transferStatus = isd200_action( us, ACTION_READ_STATUS,
+				    info->ATARegs, sizeof(info->ATARegs) );
+	if (transferStatus != ISD200_TRANSPORT_GOOD) {
+		US_DEBUGP("   Error reading ATA registers\n");
+		retStatus = ISD200_ERROR;
+        } else {
+		US_DEBUGP("   Got ATA Register[IDE_ERROR_OFFSET] = 0x%x\n", 
+			  info->ATARegs[IDE_ERROR_OFFSET]);
+        }
+
+	return retStatus;
+}
+
+
+/**************************************************************************
+ * Invoke the transport and basic error-handling/recovery methods
+ *
+ * This is used by the protocol layers to actually send the message to
+ * the device and recieve the response.
+ */
+void isd200_invoke_transport( struct us_data *us, 
+			      Scsi_Cmnd *srb, 
+			      union ata_cdb *ataCdb )
+{
+	int need_auto_sense = 0;
+	int transferStatus;
+
+	/* send the command to the transport layer */
+	transferStatus = isd200_Bulk_transport(us, srb, ataCdb,
+					       sizeof(ataCdb->generic));
+	switch (transferStatus) {
+
+	case ISD200_TRANSPORT_GOOD:
+		/* Indicate a good result */
+		srb->result = GOOD;
+		break;
+
+	case ISD200_TRANSPORT_ABORTED:
+		/* if the command gets aborted by the higher layers, we need to
+		 * short-circuit all other processing
+		 */
+		US_DEBUGP("-- transport indicates command was aborted\n");
+		srb->result = DID_ABORT << 16;
+		break;
+
+	case ISD200_TRANSPORT_FAILED:
+		US_DEBUGP("-- transport indicates command failure\n");
+		need_auto_sense = 1;
+		break;
+
+	case ISD200_TRANSPORT_ERROR:
+		US_DEBUGP("-- transport indicates transport failure\n");
+		srb->result = DID_ERROR << 16;
+		break;
+
+	case ISD200_TRANSPORT_SHORT:
+		if (!((srb->cmnd[0] == REQUEST_SENSE) ||
+		      (srb->cmnd[0] == INQUIRY) ||
+		      (srb->cmnd[0] == MODE_SENSE) ||
+		      (srb->cmnd[0] == LOG_SENSE) ||
+		      (srb->cmnd[0] == MODE_SENSE_10))) {
+			US_DEBUGP("-- unexpectedly short transfer\n");
+			need_auto_sense = 1;
+		}
+		break;
+    
+	default:
+		US_DEBUGP("-- transport indicates unknown failure\n");   
+		srb->result = DID_ERROR << 16;
+       
+	}
+
+	if (need_auto_sense)
+		if (isd200_read_regs(us) == ISD200_GOOD)
+			isd200_build_sense(us, srb);
+
+	/* Regardless of auto-sense, if we _know_ we have an error
+	 * condition, show that in the result code
+	 */
+	if (transferStatus == ISD200_TRANSPORT_FAILED)
+		srb->result = CHECK_CONDITION;
+}
+
+
+/**************************************************************************
+ * isd200_write_config
+ *                                                                         
+ * Write the ISD200 Configuraton data
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+int isd200_write_config( struct us_data *us ) 
+{
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int retStatus = ISD200_GOOD;
+	int result;
+
+
+	US_DEBUGP("Entering isd200_write_config\n");
+
+	US_DEBUGP("   Writing the following ISD200 Config Data:\n");
+	US_DEBUGP("      Event Notification: 0x%x\n", info->ConfigData.EventNotification);
+	US_DEBUGP("      External Clock: 0x%x\n", info->ConfigData.ExternalClock);
+	US_DEBUGP("      ATA Init Timeout: 0x%x\n", info->ConfigData.ATAInitTimeout);
+	US_DEBUGP("      ATAPI Command Block Size: 0x%x\n", info->ConfigData.ATAPICommandBlockSize);
+	US_DEBUGP("      Master/Slave Selection: 0x%x\n", info->ConfigData.MasterSlaveSelection);
+	US_DEBUGP("      ATAPI Reset: 0x%x\n", info->ConfigData.ATAPIReset);
+	US_DEBUGP("      ATA Timing: 0x%x\n", info->ConfigData.ATATiming);
+	US_DEBUGP("      ATA Major Command: 0x%x\n", info->ConfigData.ATAMajorCommand);
+	US_DEBUGP("      ATA Minor Command: 0x%x\n", info->ConfigData.ATAMinorCommand);
+	US_DEBUGP("      Init Status: 0x%x\n", info->ConfigData.InitStatus);
+	US_DEBUGP("      Config Descriptor 2: 0x%x\n", info->ConfigData.ConfigDescriptor2);
+	US_DEBUGP("      Skip Device Boot: 0x%x\n", info->ConfigData.SkipDeviceBoot);
+	US_DEBUGP("      ATA 3 State Supsend: 0x%x\n", info->ConfigData.ATA3StateSuspend);
+	US_DEBUGP("      Descriptor Override: 0x%x\n", info->ConfigData.DescriptOverride);
+	US_DEBUGP("      Last LUN Identifier: 0x%x\n", info->ConfigData.LastLUNIdentifier);
+	US_DEBUGP("      SRST Enable: 0x%x\n", info->ConfigData.SRSTEnable);
+
+	/* let's send the command via the control pipe */
+	result = usb_stor_control_msg(
+                us, 
+                usb_sndctrlpipe(us->pusb_dev,0),
+                0x01, 
+                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
+                0x0000, 
+                0x0002, 
+                (void *) &info->ConfigData, 
+                sizeof(info->ConfigData));
+
+	if (result >= 0) {
+		US_DEBUGP("   ISD200 Config Data was written successfully\n");
+        } else {
+		US_DEBUGP("   Request to write ISD200 Config Data failed!\n");
+
+		/* STALL must be cleared when they are detected */
+		if (result == -EPIPE) {
+			US_DEBUGP("-- Stall on control pipe. Clearing\n");
+			result = usb_stor_clear_halt(us->pusb_dev,
+						     usb_sndctrlpipe(us->pusb_dev, 0));
+			US_DEBUGP("-- usb_stor_clear_halt() returns %d\n", result);
+
+		}
+		retStatus = ISD200_ERROR;
+        }
+
+	US_DEBUGP("Leaving isd200_write_config %08X\n", retStatus);
+	return retStatus;
+}
+
+
+/**************************************************************************
+ * isd200_read_config
+ *                                                                         
+ * Reads the ISD200 Configuraton data
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+int isd200_read_config( struct us_data *us ) 
+{
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int retStatus = ISD200_GOOD;
+	int result;
+
+	US_DEBUGP("Entering isd200_read_config\n");
+
+	/* read the configuration information from ISD200.  Use this to */
+	/* determine what the special ATA CDB bytes are.                */
+
+	result = usb_stor_control_msg(
+                us, 
+                usb_rcvctrlpipe(us->pusb_dev,0),
+                0x02, 
+                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                0x0000, 
+                0x0002, 
+                (void *) &info->ConfigData, 
+                sizeof(info->ConfigData));
+
+
+	if (result >= 0) {
+		US_DEBUGP("   Retrieved the following ISD200 Config Data:\n");
+		US_DEBUGP("      Event Notification: 0x%x\n", info->ConfigData.EventNotification);
+		US_DEBUGP("      External Clock: 0x%x\n", info->ConfigData.ExternalClock);
+		US_DEBUGP("      ATA Init Timeout: 0x%x\n", info->ConfigData.ATAInitTimeout);
+		US_DEBUGP("      ATAPI Command Block Size: 0x%x\n", info->ConfigData.ATAPICommandBlockSize);
+		US_DEBUGP("      Master/Slave Selection: 0x%x\n", info->ConfigData.MasterSlaveSelection);
+		US_DEBUGP("      ATAPI Reset: 0x%x\n", info->ConfigData.ATAPIReset);
+		US_DEBUGP("      ATA Timing: 0x%x\n", info->ConfigData.ATATiming);
+		US_DEBUGP("      ATA Major Command: 0x%x\n", info->ConfigData.ATAMajorCommand);
+		US_DEBUGP("      ATA Minor Command: 0x%x\n", info->ConfigData.ATAMinorCommand);
+		US_DEBUGP("      Init Status: 0x%x\n", info->ConfigData.InitStatus);
+		US_DEBUGP("      Config Descriptor 2: 0x%x\n", info->ConfigData.ConfigDescriptor2);
+		US_DEBUGP("      Skip Device Boot: 0x%x\n", info->ConfigData.SkipDeviceBoot);
+		US_DEBUGP("      ATA 3 State Supsend: 0x%x\n", info->ConfigData.ATA3StateSuspend);
+		US_DEBUGP("      Descriptor Override: 0x%x\n", info->ConfigData.DescriptOverride);
+		US_DEBUGP("      Last LUN Identifier: 0x%x\n", info->ConfigData.LastLUNIdentifier);
+		US_DEBUGP("      SRST Enable: 0x%x\n", info->ConfigData.SRSTEnable);
+        } else {
+		US_DEBUGP("   Request to get ISD200 Config Data failed!\n");
+
+		/* STALL must be cleared when they are detected */
+		if (result == -EPIPE) {
+			US_DEBUGP("-- Stall on control pipe. Clearing\n");
+			result = usb_stor_clear_halt(us->pusb_dev,   
+						     usb_sndctrlpipe(us->pusb_dev, 0));
+			US_DEBUGP("-- usb_stor_clear_halt() returns %d\n", result);
+
+		}
+		retStatus = ISD200_ERROR;
+        }
+
+	US_DEBUGP("Leaving isd200_read_config %08X\n", retStatus);
+	return retStatus;
+}
+
+
+/**************************************************************************
+ * isd200_atapi_soft_reset
+ *                                                                         
+ * Perform an Atapi Soft Reset on the device
+ *
+ * RETURNS:
+ *    NT status code
+ */                                                                        
+int isd200_atapi_soft_reset( struct us_data *us ) 
+{
+	int retStatus = ISD200_GOOD;
+	int transferStatus;
+
+	US_DEBUGP("Entering isd200_atapi_soft_reset\n");
+
+	transferStatus = isd200_action( us, ACTION_SOFT_RESET, NULL, 0 );
+	if (transferStatus != ISD200_TRANSPORT_GOOD) {
+		US_DEBUGP("   Error issuing Atapi Soft Reset\n");
+		retStatus = ISD200_ERROR;
+        }
+
+	US_DEBUGP("Leaving isd200_atapi_soft_reset %08X\n", retStatus);
+	return retStatus;
+}
+
+
+/**************************************************************************
+ * isd200_srst
+ *                                                                         
+ * Perform an SRST on the device
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+int isd200_srst( struct us_data *us ) 
+{
+	int retStatus = ISD200_GOOD;
+	int transferStatus;
+
+	US_DEBUGP("Entering isd200_SRST\n");
+
+	transferStatus = isd200_action( us, ACTION_RESET, NULL, 0 );
+
+	/* check to see if this request failed */
+	if (transferStatus != ISD200_TRANSPORT_GOOD) {
+		US_DEBUGP("   Error issuing SRST\n");
+		retStatus = ISD200_ERROR;
+        } else {
+		/* delay 10ms to give the drive a chance to see it */
+		wait_ms(10);
+
+		transferStatus = isd200_action( us, ACTION_REENABLE, NULL, 0 );
+		if (transferStatus != ISD200_TRANSPORT_GOOD) {
+			US_DEBUGP("   Error taking drive out of reset\n");
+			retStatus = ISD200_ERROR;
+		} else {
+			/* delay 50ms to give the drive a chance to recover after SRST */
+			wait_ms(50);
+		}
+        }
+
+	US_DEBUGP("Leaving isd200_srst %08X\n", retStatus);
+	return retStatus;
+}
+
+
+/**************************************************************************
+ * isd200_try_enum
+ *                                                                         
+ * Helper function for isd200_manual_enum(). Does ENUM and READ_STATUS
+ * and tries to analyze the status registers
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+static int isd200_try_enum(struct us_data *us, unsigned char master_slave,
+			   int detect )
+{
+	int status = ISD200_GOOD;
+	unsigned char regs[8];
+	unsigned long endTime;
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int recheckAsMaster = FALSE;
+
+	if ( detect )
+		endTime = jiffies + ISD200_ENUM_DETECT_TIMEOUT * HZ;
+	else
+		endTime = jiffies + ISD200_ENUM_BSY_TIMEOUT * HZ;
+
+	/* loop until we detect !BSY or timeout */
+	while(TRUE) {
+		char* mstr = master_slave == ATA_ADDRESS_DEVHEAD_STD ?
+			"Master" : "Slave";
+
+		status = isd200_action( us, ACTION_ENUM, NULL, master_slave );
+		if ( status != ISD200_GOOD )
+			break;
+
+		status = isd200_action( us, ACTION_READ_STATUS, 
+					regs, sizeof(regs) );
+		if ( status != ISD200_GOOD )
+			break;
+
+		if (!detect) {
+			if (regs[IDE_STATUS_OFFSET] & BUSY_STAT ) {
+				US_DEBUGP("   %s status is still BSY, try again...\n",mstr);
+			} else {
+				US_DEBUGP("   %s status !BSY, continue with next operation\n",mstr);
+				break;
+			}
+		}
+		/* check for BUSY_STAT and */
+		/* WRERR_STAT (workaround ATA Zip drive) and */ 
+		/* ERR_STAT (workaround for Archos CD-ROM) */
+		else if (regs[IDE_STATUS_OFFSET] & 
+			 (BUSY_STAT | WRERR_STAT | ERR_STAT )) {
+			US_DEBUGP("   Status indicates it is not ready, try again...\n");
+		}
+		/* check for DRDY, ATA devices set DRDY after SRST */
+		else if (regs[IDE_STATUS_OFFSET] & READY_STAT) {
+			US_DEBUGP("   Identified ATA device\n");
+			info->DeviceFlags |= DF_ATA_DEVICE;
+			info->DeviceHead = master_slave;
+			break;
+		} 
+		/* check Cylinder High/Low to
+		   determine if it is an ATAPI device
+		*/
+		else if ((regs[IDE_HCYL_OFFSET] == 0xEB) &&
+			 (regs[IDE_LCYL_OFFSET] == 0x14)) {
+			/* It seems that the RICOH 
+			   MP6200A CD/RW drive will 
+			   report itself okay as a
+			   slave when it is really a
+			   master. So this check again
+			   as a master device just to
+			   make sure it doesn't report
+			   itself okay as a master also
+			*/
+			if ((master_slave & ATA_ADDRESS_DEVHEAD_SLAVE) &&
+			    (recheckAsMaster == FALSE)) {
+				US_DEBUGP("   Identified ATAPI device as slave.  Rechecking again as master\n");
+				recheckAsMaster = TRUE;
+				master_slave = ATA_ADDRESS_DEVHEAD_STD;
+			} else {
+				US_DEBUGP("   Identified ATAPI device\n");
+				info->DeviceHead = master_slave;
+			      
+				status = isd200_atapi_soft_reset(us);
+				break;
+			}
+		} else {
+			US_DEBUGP("   Not ATA, not ATAPI. Weird.\n");
+		}
+
+		/* check for timeout on this request */
+		if (jiffies >= endTime) {
+			if (!detect)
+				US_DEBUGP("   BSY check timeout, just continue with next operation...\n");
+			else
+				US_DEBUGP("   Device detect timeout!\n");
+			break;
+		}
+	}
+
+	return status;
+}
+
+/**************************************************************************
+ * isd200_manual_enum
+ *                                                                         
+ * Determines if the drive attached is an ATA or ATAPI and if it is a
+ * master or slave.
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+int isd200_manual_enum(struct us_data *us)
+{
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int retStatus = ISD200_GOOD;
+
+	US_DEBUGP("Entering isd200_manual_enum\n");
+
+	retStatus = isd200_read_config(us);
+	if (retStatus == ISD200_GOOD) {
+		int isslave;
+		/* master or slave? */
+		retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, FALSE );
+		if (retStatus == ISD200_GOOD)
+			retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_SLAVE, FALSE );
+
+		if (retStatus == ISD200_GOOD) {
+			retStatus = isd200_srst(us);
+			if (retStatus == ISD200_GOOD)
+				/* ata or atapi? */
+				retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, TRUE );
+		}
+
+		isslave = (info->DeviceHead & ATA_ADDRESS_DEVHEAD_SLAVE) ? 1 : 0;
+		if (info->ConfigData.MasterSlaveSelection != isslave) {
+			US_DEBUGP("   Setting Master/Slave selection to %d\n", isslave);
+			info->ConfigData.MasterSlaveSelection = isslave;
+			retStatus = isd200_write_config(us);
+		}
+	}
+
+	US_DEBUGP("Leaving isd200_manual_enum %08X\n", retStatus);
+	return(retStatus);
+}
+
+
+/**************************************************************************
+ * isd200_get_inquiry_data
+ *
+ * Get inquiry data
+ *
+ * RETURNS:
+ *    ISD status code
+ */
+int isd200_get_inquiry_data( struct us_data *us )
+{
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int retStatus = ISD200_GOOD;
+
+	US_DEBUGP("Entering isd200_get_inquiry_data\n");
+
+	/* set default to Master */
+	info->DeviceHead = ATA_ADDRESS_DEVHEAD_STD;
+
+	/* attempt to manually enumerate this device */
+	retStatus = isd200_manual_enum(us);
+	if (retStatus == ISD200_GOOD) {
+		int transferStatus;
+
+		/* check for an ATA device */
+		if (info->DeviceFlags & DF_ATA_DEVICE) {
+			/* this must be an ATA device */
+			/* perform an ATA Commmand Identify */
+			transferStatus = isd200_action( us, ACTION_IDENTIFY,
+							&info->drive, 
+							sizeof(struct hd_driveid) );
+			if (transferStatus != ISD200_TRANSPORT_GOOD) {
+				/* Error issuing ATA Command Identify */
+				US_DEBUGP("   Error issuing ATA Command Identify\n");
+				retStatus = ISD200_ERROR;
+			} else {
+				/* ATA Command Identify successful */
+				int i;
+
+				US_DEBUGP("   Identify Data Structure:\n");
+				US_DEBUGP("      config = 0x%x\n", info->drive.config);
+				US_DEBUGP("      cyls = 0x%x\n", info->drive.cyls);
+				US_DEBUGP("      heads = 0x%x\n", info->drive.heads);
+				US_DEBUGP("      track_bytes = 0x%x\n", info->drive.track_bytes);
+				US_DEBUGP("      sector_bytes = 0x%x\n", info->drive.sector_bytes);
+				US_DEBUGP("      sectors = 0x%x\n", info->drive.sectors);
+				US_DEBUGP("      serial_no[0] = 0x%x\n", info->drive.serial_no[0]);
+				US_DEBUGP("      buf_type = 0x%x\n", info->drive.buf_type);
+				US_DEBUGP("      buf_size = 0x%x\n", info->drive.buf_size);
+				US_DEBUGP("      ecc_bytes = 0x%x\n", info->drive.ecc_bytes);
+				US_DEBUGP("      fw_rev[0] = 0x%x\n", info->drive.fw_rev[0]);
+				US_DEBUGP("      model[0] = 0x%x\n", info->drive.model[0]);
+				US_DEBUGP("      max_multsect = 0x%x\n", info->drive.max_multsect);
+				US_DEBUGP("      dword_io = 0x%x\n", info->drive.dword_io);
+				US_DEBUGP("      capability = 0x%x\n", info->drive.capability);
+				US_DEBUGP("      tPIO = 0x%x\n", info->drive.tPIO);
+				US_DEBUGP("      tDMA = 0x%x\n", info->drive.tDMA);
+				US_DEBUGP("      field_valid = 0x%x\n", info->drive.field_valid);
+				US_DEBUGP("      cur_cyls = 0x%x\n", info->drive.cur_cyls);
+				US_DEBUGP("      cur_heads = 0x%x\n", info->drive.cur_heads);
+				US_DEBUGP("      cur_sectors = 0x%x\n", info->drive.cur_sectors);
+				US_DEBUGP("      cur_capacity = 0x%x\n", (info->drive.cur_capacity1 << 16) + info->drive.cur_capacity0 );
+				US_DEBUGP("      multsect = 0x%x\n", info->drive.multsect);
+				US_DEBUGP("      lba_capacity = 0x%x\n", info->drive.lba_capacity);
+				US_DEBUGP("      command_set_1 = 0x%x\n", info->drive.command_set_1);
+				US_DEBUGP("      command_set_2 = 0x%x\n", info->drive.command_set_2);
+
+				memset(&info->InquiryData, 0, sizeof(info->InquiryData));
+
+				/* Standard IDE interface only supports disks */
+				info->InquiryData.DeviceType = DIRECT_ACCESS_DEVICE;
+
+				/* Fix-up the return data from an INQUIRY command to show 
+				 * ANSI SCSI rev 2 so we don't confuse the SCSI layers above us
+				 * in Linux.
+				 */
+				info->InquiryData.Versions = 0x2;
+
+				/* The length must be at least 36 (5 + 31) */
+				info->InquiryData.AdditionalLength = 0x1F;
+
+				if (info->drive.command_set_1 & COMMANDSET_MEDIA_STATUS) {
+					/* set the removable bit */
+					info->InquiryData.RemovableMedia = 1;
+					info->DeviceFlags |= DF_REMOVABLE_MEDIA;
+				}
+
+				/* Fill in vendor identification fields */
+				for (i = 0; i < 20; i += 2) {
+					info->InquiryData.VendorId[i] = 
+						info->drive.model[i + 1];
+					info->InquiryData.VendorId[i+1] = 
+						info->drive.model[i];
+				}
+
+				/* Initialize unused portion of product id */
+				for (i = 0; i < 4; i++) {
+					info->InquiryData.ProductId[12+i] = ' ';
+				}
+
+				/* Move firmware revision from IDENTIFY data to */
+				/* product revision in INQUIRY data             */
+				for (i = 0; i < 4; i += 2) {
+					info->InquiryData.ProductRevisionLevel[i] =
+						info->drive.fw_rev[i+1];
+					info->InquiryData.ProductRevisionLevel[i+1] =
+						info->drive.fw_rev[i];
+				}
+
+				/* determine if it supports Media Status Notification */
+				if (info->drive.command_set_2 & COMMANDSET_MEDIA_STATUS) {
+					US_DEBUGP("   Device supports Media Status Notification\n");
+
+					/* Indicate that it is enabled, even though it is not
+					 * This allows the lock/unlock of the media to work
+					 * correctly.
+					 */
+					info->DeviceFlags |= DF_MEDIA_STATUS_ENABLED;
+				}
+				else
+					info->DeviceFlags &= ~DF_MEDIA_STATUS_ENABLED;
+
+			}
+		} else {
+			/* 
+			 * this must be an ATAPI device 
+			 * use an ATAPI protocol (Transparent SCSI)
+			 */
+			us->protocol_name = "Transparent SCSI";
+			us->proto_handler = usb_stor_transparent_scsi_command;
+
+			US_DEBUGP("Protocol changed to: %s\n", us->protocol_name);
+            
+			/* Free driver structure */            
+			if (us->extra != NULL) {
+				kfree(us->extra);
+				us->extra = NULL;
+				us->extra_destructor = NULL;
+			}
+		}
+        }
+
+	US_DEBUGP("Leaving isd200_get_inquiry_data %08X\n", retStatus);
+
+	return(retStatus);
+}
+
+
+/**************************************************************************
+ * isd200_data_copy
+ *                                                                         
+ * Copy data into the srb request buffer.  Use scatter gather if required.
+ *
+ * RETURNS:
+ *    void
+ */                                                                        
+void isd200_data_copy(Scsi_Cmnd *srb, char * src, int length)
+{
+	unsigned int len = length;
+	struct scatterlist *sg;
+
+	if (srb->use_sg) {
+		int i;
+		unsigned int total = 0;
+
+		/* Add up the sizes of all the sg segments */
+		sg = (struct scatterlist *) srb->request_buffer;
+		for (i = 0; i < srb->use_sg; i++)
+			total += sg[i].length;
+
+		if (length > total)
+			len = total;
+
+		total = 0;
+
+		/* Copy data into sg buffer(s) */
+		for (i = 0; i < srb->use_sg; i++) {
+			if ((len > total) && (len > 0)) {
+				/* transfer the lesser of the next buffer or the
+				 * remaining data */
+				if (len - total >= sg[i].length) {
+					memcpy(sg[i].address, src + total, sg[i].length);
+					total += sg[i].length;
+				} else {
+					memcpy(sg[i].address, src + total, len - total);
+					total = len;
+				}
+			} 
+			else
+				break;
+		}
+	} else	{
+		/* Make sure length does not exceed buffer length */
+		if (length > srb->request_bufflen)
+			len = srb->request_bufflen;
+
+		if (len > 0)
+			memcpy(srb->request_buffer, src, len);
+	}
+}
+
+
+/**************************************************************************
+ * isd200_scsi_to_ata
+ *                                                                         
+ * Translate SCSI commands to ATA commands.
+ *
+ * RETURNS:
+ *    TRUE if the command needs to be sent to the transport layer
+ *    FALSE otherwise
+ */                                                                        
+int isd200_scsi_to_ata(Scsi_Cmnd *srb, struct us_data *us, 
+		       union ata_cdb * ataCdb)
+{
+	struct isd200_info *info = (struct isd200_info *)us->extra;
+	int sendToTransport = TRUE;
+	unsigned char sectnum, head;
+	unsigned short cylinder;
+	unsigned long lba;
+	unsigned long blockCount;
+	unsigned char senseData[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+	memset(ataCdb, 0, sizeof(union ata_cdb));
+
+	/* SCSI Command */
+	switch (srb->cmnd[0]) {
+	case INQUIRY:
+		US_DEBUGP("   ATA OUT - INQUIRY\n");
+
+		if (srb->request_bufflen > sizeof(struct inquiry_data))
+			srb->request_bufflen = sizeof(struct inquiry_data);
+
+		/* copy InquiryData */
+		isd200_data_copy(srb, (char *) &info->InquiryData, srb->request_bufflen);
+		srb->result = GOOD;
+		sendToTransport = FALSE;
+		break;
+
+	case MODE_SENSE:
+		US_DEBUGP("   ATA OUT - SCSIOP_MODE_SENSE\n");
+
+		/* Initialize the return buffer */
+		isd200_data_copy(srb, (char *) &senseData, 8);
+
+		if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED)
+		{
+			ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+			ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+			ataCdb->generic.TransferBlockSize = 1;
+			ataCdb->write.SelectCommand = 1;
+			ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
+			srb->request_bufflen = 0;
+		} else {
+			US_DEBUGP("   Media Status not supported, just report okay\n");
+			srb->result = GOOD;
+			sendToTransport = FALSE;
+		}
+		break;
+
+	case TEST_UNIT_READY:
+		US_DEBUGP("   ATA OUT - SCSIOP_TEST_UNIT_READY\n");
+
+		/* Initialize the return buffer */
+		isd200_data_copy(srb, (char *) &senseData, 8);
+
+		if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED)
+		{
+			ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+			ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+			ataCdb->generic.TransferBlockSize = 1;
+			ataCdb->write.SelectCommand = 1;
+			ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
+			srb->request_bufflen = 0;
+		} else {
+			US_DEBUGP("   Media Status not supported, just report okay\n");
+			srb->result = GOOD;
+			sendToTransport = FALSE;
+		}
+		break;
+
+	case READ_CAPACITY:
+	{
+		unsigned long capacity;
+		struct read_capacity_data readCapacityData;
+
+		US_DEBUGP("   ATA OUT - SCSIOP_READ_CAPACITY\n");
+
+		if (info->drive.capability & CAPABILITY_LBA ) {
+			capacity = info->drive.lba_capacity - 1;
+		} else {
+			capacity = (info->drive.heads *
+				    info->drive.cyls *
+				    info->drive.sectors) - 1;
+		}
+		readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity);
+		readCapacityData.BytesPerBlock = cpu_to_be32(0x200);
+
+		if (srb->request_bufflen > sizeof(struct read_capacity_data))
+			srb->request_bufflen = sizeof(struct read_capacity_data);
+
+		isd200_data_copy(srb, (char *) &readCapacityData, srb->request_bufflen);
+		srb->result = GOOD;
+		sendToTransport = FALSE;
+	}
+	break;
+
+	case READ_10:
+		US_DEBUGP("   ATA OUT - SCSIOP_READ\n");
+
+		lba = *(unsigned long *)&srb->cmnd[2]; 
+		lba = cpu_to_be32(lba);
+		blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
+
+		if (info->drive.capability & CAPABILITY_LBA) {
+			sectnum = (unsigned char)(lba);
+			cylinder = (unsigned short)(lba>>8);
+			head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
+		} else {
+			sectnum = (unsigned char)((lba % info->drive.sectors) + 1);
+			cylinder = (unsigned short)(lba / (info->drive.sectors *
+							   info->drive.heads));
+			head = (unsigned char)((lba / info->drive.sectors) %
+					       info->drive.heads);
+		}
+		ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+		ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+		ataCdb->generic.TransferBlockSize = 1;
+		ataCdb->write.SelectSectorCount = 1;
+		ataCdb->write.SectorCountByte = (unsigned char)blockCount;
+		ataCdb->write.SelectSectorNumber = 1;
+		ataCdb->write.SectorNumberByte = sectnum;
+		ataCdb->write.SelectCylinderHigh = 1;
+		ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
+		ataCdb->write.SelectCylinderLow = 1;
+		ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
+		ataCdb->write.SelectDeviceHead = 1;
+		ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
+		ataCdb->write.SelectCommand = 1;
+		ataCdb->write.CommandByte = WIN_READ;
+		break;
+
+	case WRITE_10:
+		US_DEBUGP("   ATA OUT - SCSIOP_WRITE\n");
+
+		lba = *(unsigned long *)&srb->cmnd[2]; 
+		lba = cpu_to_be32(lba);
+		blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
+
+		if (info->drive.capability & CAPABILITY_LBA) {
+			sectnum = (unsigned char)(lba);
+			cylinder = (unsigned short)(lba>>8);
+			head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
+		} else {
+			sectnum = (unsigned char)((lba % info->drive.sectors) + 1);
+			cylinder = (unsigned short)(lba / (info->drive.sectors * info->drive.heads));
+			head = (unsigned char)((lba / info->drive.sectors) % info->drive.heads);
+		}
+		ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+		ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+		ataCdb->generic.TransferBlockSize = 1;
+		ataCdb->write.SelectSectorCount = 1;
+		ataCdb->write.SectorCountByte = (unsigned char)blockCount;
+		ataCdb->write.SelectSectorNumber = 1;
+		ataCdb->write.SectorNumberByte = sectnum;
+		ataCdb->write.SelectCylinderHigh = 1;
+		ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
+		ataCdb->write.SelectCylinderLow = 1;
+		ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
+		ataCdb->write.SelectDeviceHead = 1;
+		ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
+		ataCdb->write.SelectCommand = 1;
+		ataCdb->write.CommandByte = WIN_WRITE;
+		break;
+
+	case ALLOW_MEDIUM_REMOVAL:
+		US_DEBUGP("   ATA OUT - SCSIOP_MEDIUM_REMOVAL\n");
+
+		if (info->DeviceFlags & DF_REMOVABLE_MEDIA) {
+			US_DEBUGP("   srb->cmnd[4] = 0x%X\n", srb->cmnd[4]);
+            
+			ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+			ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+			ataCdb->generic.TransferBlockSize = 1;
+			ataCdb->write.SelectCommand = 1;
+			ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ?
+				WIN_DOORLOCK : WIN_DOORUNLOCK;
+			srb->request_bufflen = 0;
+		} else {
+			US_DEBUGP("   Not removeable media, just report okay\n");
+			srb->result = GOOD;
+			sendToTransport = FALSE;
+		}
+		break;
+
+	case START_STOP:    
+		US_DEBUGP("   ATA OUT - SCSIOP_START_STOP_UNIT\n");
+		US_DEBUGP("   srb->cmnd[4] = 0x%X\n", srb->cmnd[4]);
+
+		/* Initialize the return buffer */
+		isd200_data_copy(srb, (char *) &senseData, 8);
+
+		if ((srb->cmnd[4] & 0x3) == 0x2) {
+			US_DEBUGP("   Media Eject\n");
+			ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+			ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+			ataCdb->generic.TransferBlockSize = 0;
+			ataCdb->write.SelectCommand = 1;
+			ataCdb->write.CommandByte = ATA_COMMAND_MEDIA_EJECT;
+		} else if ((srb->cmnd[4] & 0x3) == 0x1) {
+			US_DEBUGP("   Get Media Status\n");
+			ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
+			ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
+			ataCdb->generic.TransferBlockSize = 1;
+			ataCdb->write.SelectCommand = 1;
+			ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
+			srb->request_bufflen = 0;
+		} else {
+			US_DEBUGP("   Nothing to do, just report okay\n");
+			srb->result = GOOD;
+			sendToTransport = FALSE;
+		}
+		break;
+
+	default:
+		US_DEBUGP("Unsupported SCSI command - 0x%X\n", srb->cmnd[0]);
+		srb->result = DID_ERROR << 16;
+		sendToTransport = FALSE;
+		break;
+	}
+
+	return(sendToTransport);
+}
+
+
+/**************************************************************************
+ * isd200_init_info
+ *                                                                         
+ * Allocates (if necessary) and initializes the driver structure.
+ *
+ * RETURNS:
+ *    ISD status code
+ */                                                                        
+int isd200_init_info(struct us_data *us)
+{
+	int retStatus = ISD200_GOOD;
+
+	if (!us->extra) {
+		us->extra = (void *) kmalloc(sizeof(struct isd200_info), GFP_KERNEL);
+		if (!us->extra) {
+			US_DEBUGP("ERROR - kmalloc failure\n");
+			retStatus = ISD200_ERROR;
+		}
+        }
+
+	if (retStatus == ISD200_GOOD) {
+		memset(us->extra, 0, sizeof(struct isd200_info));
+        }
+
+	return(retStatus);
+}
+
+/**************************************************************************
+ * Initialization for the ISD200 
+ */
+
+int isd200_Initialization(struct us_data *us)
+{
+	US_DEBUGP("ISD200 Initialization...\n");
+
+	/* Initialize ISD200 info struct */
+
+	if (isd200_init_info(us) == ISD200_ERROR) {
+		US_DEBUGP("ERROR Initializing ISD200 Info struct\n");
+        } else {
+		/* Get device specific data */
+
+		if (isd200_get_inquiry_data(us) != ISD200_GOOD)
+			US_DEBUGP("ISD200 Initialization Failure\n");
+		else
+			US_DEBUGP("ISD200 Initialization complete\n");
+        }
+
+	return 0;
+}
+
+
+/**************************************************************************
+ * Protocol and Transport for the ISD200 ASIC
+ *
+ * This protocol and transport are for ATA devices connected to an ISD200
+ * ASIC.  An ATAPI device that is conected as a slave device will be
+ * detected in the driver initialization function and the protocol will
+ * be changed to an ATAPI protocol (Transparent SCSI).
+ *
+ */
+
+void isd200_ata_command(Scsi_Cmnd *srb, struct us_data *us)
+{
+	int sendToTransport = TRUE;
+	union ata_cdb ataCdb;
+
+	/* Make sure driver was initialized */
+
+	if (us->extra == NULL)
+		US_DEBUGP("ERROR Driver not initialized\n");
+
+	/* Convert command */
+	sendToTransport = isd200_scsi_to_ata(srb, us, &ataCdb);
+
+	/* send the command to the transport layer */
+	if (sendToTransport)
+		isd200_invoke_transport(us, srb, &ataCdb);
+}

drivers/usb/storage/isd200.h

+/* Header File for In-System Design, Inc. ISD200 ASIC
+ *
+ * First release
+ *
+ * Current development and maintenance by:
+ *   (c) 2000 In-System Design, Inc. (support@in-system.com)
+ *
+ * See isd200.c for more information.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _USB_ISD200_H
+#define _USB_ISD200_H
+
+extern void isd200_ata_command(Scsi_Cmnd *srb, struct us_data *us);
+extern int isd200_Initialization(struct us_data *us);
+
+#endif

drivers/usb/storage/jumpshot.c

+/* Driver for Lexar "Jumpshot" Compact Flash reader
+ *
+ * jumpshot driver v0.1:
+ *
+ * First release
+ *
+ * Current development and maintenance by:
+ *   (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org)
+ *   many thanks to Robert Baruch for the SanDisk SmartMedia reader driver
+ *   which I used as a template for this driver.
+ *   Some bugfixes and scatter-gather code by Gregory P. Smith 
+ *   (greg-usb@electricrain.com)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+ /*
+  * This driver attempts to support the Lexar Jumpshot USB CompactFlash 
+  * reader.  Like many other USB CompactFlash readers, the Jumpshot contains
+  * a USB-to-ATA chip. 
+  *
+  * This driver supports reading and writing.  If you're truly paranoid,
+  * however, you can force the driver into a write-protected state by setting
+  * the WP enable bits in jumpshot_handle_mode_sense.  Basically this means
+  * setting mode_param_header[3] = 0x80.  
+  */
+
+#include "transport.h"
+#include "protocol.h"
+#include "usb.h"
+#include "debug.h"
+#include "jumpshot.h"
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/malloc.h>
+
+extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
+				u8 request, u8 requesttype, u16 value,
+				u16 index, void *data, u16 size);
+extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
+			     unsigned int len, unsigned int *act_len);
+
+#if 0
+static void jumpshot_dump_data(unsigned char *data, int len)
+{
+	unsigned char buf[80];
+	int sofar = 0;
+
+	if (!data)
+		return;
+
+	memset(buf, 0, sizeof(buf));
+
+	for (sofar = 0; sofar < len; sofar++) {
+		sprintf(buf + strlen(buf), "%02x ",
+			((unsigned int) data[sofar]) & 0xFF);
+
+		if (sofar % 16 == 15) {
+			US_DEBUGP("jumpshot:  %s\n", buf);
+			memset(buf, 0, sizeof(buf));
+		}
+	}
+
+	if (strlen(buf) != 0)
+		US_DEBUGP("jumpshot:  %s\n", buf);
+}
+#endif
+
+/*
+ * Send a control message and wait for the response.
+ *
+ * us - the pointer to the us_data structure for the device to use
+ *
+ * request - the URB Setup Packet's first 6 bytes. The first byte always
+ *  corresponds to the request type, and the second byte always corresponds
+ *  to the request.  The other 4 bytes do not correspond to value and index,
+ *  since they are used in a custom way by the SCM protocol.
+ *
+ * xfer_data - a buffer from which to get, or to which to store, any data
+ *  that gets send or received, respectively, with the URB. Even though
+ *  it looks like we allocate a buffer in this code for the data, xfer_data
+ *  must contain enough allocated space.
+ *
+ * xfer_len - the number of bytes to send or receive with the URB.
+ *
+ * This routine snarfed from the SanDisk SDDR-09 driver
+ *
+ */
+static int jumpshot_send_control(struct us_data  *us,
+				 int pipe,
+				 unsigned char request,
+				 unsigned char requesttype,
+				 unsigned short value,
+				 unsigned short index,
+				 unsigned char *xfer_data,
+				 unsigned int xfer_len)
+{
+	int result;
+
+	// Send the URB to the device and wait for a response.
+
+	/* Why are request and request type reversed in this call? */
+
+	result = usb_stor_control_msg(us, pipe,
+				      request, requesttype,
+				      value, index, xfer_data, xfer_len);
+
+	// Check the return code for the command.
+
+	if (result < 0) {
+		/* if the command was aborted, indicate that */
+		if (result == -ENOENT)
+			return USB_STOR_TRANSPORT_ABORTED;
+
+		/* a stall is a fatal condition from the device */
+		if (result == -EPIPE) {
+			US_DEBUGP("jumpshot_send_control:  -- Stall on control pipe. Clearing\n");
+			result = usb_clear_halt(us->pusb_dev, pipe);
+			US_DEBUGP("jumpshot_send_control:  -- usb_clear_halt() returns %d\n", result);
+			return USB_STOR_TRANSPORT_FAILED;
+		}
+
+		/* Uh oh... serious problem here */
+		return USB_STOR_TRANSPORT_ERROR;
+	}
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+
+static int jumpshot_raw_bulk(int direction,
+			     struct us_data *us,
+			     unsigned char *data, 
+		             unsigned int len)
+{
+	int result;
+	int act_len;
+	int pipe;
+
+	if (direction == SCSI_DATA_READ)
+		pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
+	else
+		pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
+
+	result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);
+
+	// if we stall, we need to clear it before we go on
+	if (result == -EPIPE) {
+		US_DEBUGP("jumpshot_raw_bulk:  EPIPE. clearing endpoint halt for"
+			  " pipe 0x%x, stalled at %d bytes\n", pipe, act_len);
+		usb_clear_halt(us->pusb_dev, pipe);
+	}
+
+	if (result) {
+		// NAK - that means we've retried a few times already
+		if (result == -ETIMEDOUT) {
+			US_DEBUGP("jumpshot_raw_bulk:  device NAKed\n");
+			return US_BULK_TRANSFER_FAILED;
+		}
+
+		// -ENOENT -- we canceled this transfer
+		if (result == -ENOENT) {
+			US_DEBUGP("jumpshot_raw_bulk:  transfer aborted\n");
+			return US_BULK_TRANSFER_ABORTED;
+		}
+
+		if (result == -EPIPE) {
+			US_DEBUGP("jumpshot_raw_bulk:  output pipe stalled\n");
+			return USB_STOR_TRANSPORT_FAILED;
+		}
+
+		// the catch-all case
+		US_DEBUGP("jumpshot_raw_bulk:  unknown error\n");
+		return US_BULK_TRANSFER_FAILED;
+	}
+
+	if (act_len != len) {
+		US_DEBUGP("jumpshot_raw_bulk:  Warning. Transferred only %d bytes\n", act_len);
+		return US_BULK_TRANSFER_SHORT;
+	}
+
+	US_DEBUGP("jumpshot_raw_bulk:  Transfered %d of %d bytes\n", act_len, len);
+	return US_BULK_TRANSFER_GOOD;
+}
+
+static inline int jumpshot_bulk_read(struct us_data *us,
+			             unsigned char *data, 
+		                     unsigned int len)
+{
+	if (len == 0)
+		return USB_STOR_TRANSPORT_GOOD;
+
+	US_DEBUGP("jumpshot_bulk_read:  len = %d\n", len);
+	return jumpshot_raw_bulk(SCSI_DATA_READ, us, data, len);
+}
+
+
+static inline int jumpshot_bulk_write(struct us_data *us,
+			              unsigned char *data, 
+		                      unsigned int len)
+{
+	if (len == 0)
+		return USB_STOR_TRANSPORT_GOOD;
+
+	US_DEBUGP("jumpshot_bulk_write:  len = %d\n", len);
+	return jumpshot_raw_bulk(SCSI_DATA_WRITE, us, data, len);
+}
+
+
+static int jumpshot_get_status(struct us_data  *us)
+{
+	unsigned char reply;
+	int rc;
+
+	if (!us)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	// send the setup
+	rc = jumpshot_send_control(us,
+				   usb_rcvctrlpipe(us->pusb_dev, 0),
+				   0, 0xA0, 0, 7, &reply, 1);
+
+	if (rc != USB_STOR_TRANSPORT_GOOD)
+		return rc;
+
+	if (reply != 0x50) {
+		US_DEBUGP("jumpshot_get_status:  0x%2x\n",
+			  (unsigned short) (reply));
+		return USB_STOR_TRANSPORT_ERROR;
+	}
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int jumpshot_read_data(struct us_data *us,
+		              struct jumpshot_info *info,
+		              u32 sector,
+		              u32 sectors, 
+		              unsigned char *dest, 
+		              int use_sg)
+{
+	unsigned char command[] = { 0, 0, 0, 0, 0, 0xe0, 0x20 };
+	unsigned char *buffer = NULL;
+	unsigned char *ptr;
+	unsigned char  thistime;
+	struct scatterlist *sg = NULL;
+        int totallen, len, result;
+        int sg_idx = 0, current_sg_offset = 0;
+        int transferred;
+
+        // we're working in LBA mode.  according to the ATA spec, 
+        // we can support up to 28-bit addressing.  I don't know if Jumpshot
+        // supports beyond 24-bit addressing.  It's kind of hard to test 
+        // since it requires > 8GB CF card.
+	//
+	if (sector > 0x0FFFFFFF)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	// If we're using scatter-gather, we have to create a new
+	// buffer to read all of the data in first, since a
+	// scatter-gather buffer could in theory start in the middle
+	// of a page, which would be bad. A developer who wants a
+	// challenge might want to write a limited-buffer
+	// version of this code.
+
+	totallen = sectors * info->ssize;
+
+	do {
+               // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
+                len = min(totallen, 65536);
+
+                if (use_sg) {
+                        sg = (struct scatterlist *) dest;
+                        buffer = kmalloc(len, GFP_KERNEL);
+                        if (buffer == NULL)
+                                return USB_STOR_TRANSPORT_ERROR;
+                        ptr = buffer;
+                } else {
+                        ptr = dest;
+                }
+
+                thistime = (len / info->ssize) & 0xff;
+
+		command[0] = 0;
+		command[1] = thistime;
+		command[2] = sector & 0xFF;
+		command[3] = (sector >>  8) & 0xFF;
+		command[4] = (sector >> 16) & 0xFF;
+
+		command[5] |= (sector >> 24) & 0x0F;
+
+		// send the setup + command
+		result = jumpshot_send_control(us,
+					       usb_sndctrlpipe(us->pusb_dev, 0),
+					       0, 0x20, 0, 1, command, 7);
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		// read the result
+		result = jumpshot_bulk_read(us, ptr, len);
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		US_DEBUGP("jumpshot_read_data:  %d bytes\n", len);
+		//jumpshot_dump_data(ptr, len);
+	
+		sectors -= thistime;
+		sector  += thistime;
+
+                if (use_sg) {
+                        transferred = 0;
+                        while (sg_idx < use_sg && transferred < len) {
+                                if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
+                                        US_DEBUGP("jumpshot_read_data:  adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
+                                        memcpy(sg[sg_idx].address + current_sg_offset,
+                                               buffer + transferred,
+                                               sg[sg_idx].length - current_sg_offset);
+                                        transferred += sg[sg_idx].length - current_sg_offset;
+                                        current_sg_offset = 0;
+                                        // on to the next sg buffer
+                                        ++sg_idx;
+                                } else {
+                                        US_DEBUGP("jumpshot_read_data:  adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
+                                        memcpy(sg[sg_idx].address + current_sg_offset,
+                                               buffer + transferred,
+                                               len - transferred);
+                                        current_sg_offset += len - transferred;
+                                        // this sg buffer is only partially full and we're out of data to copy in
+                                        break;
+                                }
+                        }
+                        kfree(buffer);
+                } else {
+                        dest += len;
+                }
+
+                totallen -= len;
+        } while (totallen > 0);
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+
+static int jumpshot_write_data(struct us_data *us,
+		               struct jumpshot_info *info,
+			       u32 sector,
+			       u32 sectors, 
+		               unsigned char *src, 
+		               int use_sg)
+{
+	unsigned char command[7] = { 0, 0, 0, 0, 0, 0xE0, 0x30 };
+	unsigned char *buffer = NULL;
+	unsigned char *ptr;
+	unsigned char  thistime;
+	struct scatterlist *sg = NULL;
+        int totallen, len, result, waitcount;
+        int sg_idx = 0, current_sg_offset = 0;
+        int transferred;
+
+        // we're working in LBA mode.  according to the ATA spec, 
+        // we can support up to 28-bit addressing.  I don't know if Jumpshot
+        // supports beyond 24-bit addressing.  It's kind of hard to test 
+        // since it requires > 8GB CF card.
+        //
+	if (sector > 0x0FFFFFFF)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	// If we're using scatter-gather, we have to create a new
+	// buffer to read all of the data in first, since a
+	// scatter-gather buffer could in theory start in the middle
+	// of a page, which would be bad. A developer who wants a
+	// challenge might want to write a limited-buffer
+	// version of this code.
+
+	totallen = sectors * info->ssize;
+
+	do {
+                // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
+                len = min(totallen, 65536);
+
+                if (use_sg) {
+                        sg = (struct scatterlist *) src;
+                        buffer = kmalloc(len, GFP_KERNEL);
+                        if (buffer == NULL)
+                                return USB_STOR_TRANSPORT_ERROR;
+                        ptr = buffer;
+
+                        memset(buffer, 0, len);
+
+                        // copy the data from the sg bufs into the big contiguous buf
+                        //
+                        transferred = 0;
+                        while (transferred < len) {
+                                if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
+                                        US_DEBUGP("jumpshot_write_data:  getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
+                                        memcpy(ptr + transferred,
+                                               sg[sg_idx].address + current_sg_offset,
+                                               sg[sg_idx].length - current_sg_offset);
+                                        transferred += sg[sg_idx].length - current_sg_offset;
+                                        current_sg_offset = 0;
+                                        // on to the next sg buffer
+                                        ++sg_idx;
+                                } else {
+                                        US_DEBUGP("jumpshot_write_data:  getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
+                                        memcpy(ptr + transferred,
+                                               sg[sg_idx].address + current_sg_offset,
+                                               len - transferred);
+                                        current_sg_offset += len - transferred;
+                                        // we only copied part of this sg buffer
+                                        break;
+                                }
+                        }
+                } else {
+                        ptr = src;
+                }
+
+                thistime = (len / info->ssize) & 0xff;
+
+		command[0] = 0;
+		command[1] = thistime;
+		command[2] = sector & 0xFF;
+		command[3] = (sector >>  8) & 0xFF;
+		command[4] = (sector >> 16) & 0xFF;
+
+		command[5] |= (sector >> 24) & 0x0F;
+
+		// send the setup + command
+		result = jumpshot_send_control(us,
+					       usb_sndctrlpipe(us->pusb_dev, 0),
+					       0, 0x20, 0, 1, command, 7);
+
+		// send the data
+		result = jumpshot_bulk_write(us, ptr, len);
+		if (result != USB_STOR_TRANSPORT_GOOD) {
+			if (use_sg)
+				kfree(buffer);
+			return result;
+		}
+
+		// read the result.  apparently the bulk write can complete before the
+		// jumpshot drive is finished writing.  so we loop here until we
+		// get a good return code
+		waitcount = 0;
+		do {
+			result = jumpshot_get_status(us);
+			if (result != USB_STOR_TRANSPORT_GOOD) {
+				// I have not experimented to find the smallest value.
+				//
+				wait_ms(50); 
+			}
+		} while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10));
+
+		if (result != USB_STOR_TRANSPORT_GOOD)
+			US_DEBUGP("jumpshot_write_data:  Gah!  Waitcount = 10.  Bad write!?\n");
+		
+		sectors -= thistime;
+		sector  += thistime;
+
+                if (use_sg) {
+                        kfree(buffer);
+                } else {
+                        src += len;
+                }
+
+                totallen -= len;
+        } while (totallen > 0);
+
+	return result;
+}
+
+static int jumpshot_id_device(struct us_data *us,
+		              struct jumpshot_info *info)
+{
+	unsigned char command[2] = { 0xe0, 0xec };
+	unsigned char reply[512];
+	int 	 rc;
+
+	if (!us || !info)
+		return USB_STOR_TRANSPORT_ERROR;
+
+	// send the setup
+	rc = jumpshot_send_control(us,
+				   usb_sndctrlpipe(us->pusb_dev, 0),
+				   0, 0x20, 0, 6, command, 2);
+
+	if (rc != USB_STOR_TRANSPORT_GOOD) {
+		US_DEBUGP("jumpshot_id_device:  Gah! send_control for read_capacity failed\n");
+		return rc;
+	}
+
+	// read the reply
+	rc = jumpshot_bulk_read(us, reply, sizeof(reply));
+	if (rc != USB_STOR_TRANSPORT_GOOD)
+		return rc;
+
+	info->sectors = ((u32)(reply[117]) << 24) |
+			((u32)(reply[116]) << 16) |
+			((u32)(reply[115]) <<  8) |
+			((u32)(reply[114])      );
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+static int jumpshot_handle_mode_sense(struct us_data *us,
+				      Scsi_Cmnd * srb, 
+			              unsigned char *ptr,
+			              int sense_6)
+{
+	unsigned char mode_param_header[8] = {
+		0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char rw_err_page[12] = {
+		0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
+	};
+	unsigned char cache_page[12] = {
+		0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char rbac_page[12] = {
+		0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char timer_page[8] = {
+		0x1C, 0x6, 0, 0, 0, 0
+	};
+	unsigned char pc, page_code;
+	unsigned short total_len = 0;
+	unsigned short param_len, i = 0;
+
+
+	if (sense_6)
+		param_len = srb->cmnd[4];
+	else
+		param_len = ((u32) (srb->cmnd[7]) >> 8) | ((u32) (srb->cmnd[8]));
+
+
+	pc = srb->cmnd[2] >> 6;
+	page_code = srb->cmnd[2] & 0x3F;
+
+	switch (pc) {
+	   case 0x0:
+		US_DEBUGP("jumpshot_handle_mode_sense:  Current values\n");
+		break;
+	   case 0x1:
+		US_DEBUGP("jumpshot_handle_mode_sense:  Changeable values\n");
+		break;
+	   case 0x2:
+		US_DEBUGP("jumpshot_handle_mode_sense:  Default values\n");
+		break;
+	   case 0x3:
+		US_DEBUGP("jumpshot_handle_mode_sense:  Saves values\n");
+		break;
+	}
+
+	mode_param_header[3] = 0x80;	// write enable
+
+	switch (page_code) {
+	   case 0x0:
+		// vendor-specific mode
+		return USB_STOR_TRANSPORT_ERROR;
+
+	   case 0x1:
+		total_len = sizeof(rw_err_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
+		break;
+
+	   case 0x8:
+		total_len = sizeof(cache_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, cache_page, sizeof(cache_page));
+		break;
+
+	   case 0x1B:
+		total_len = sizeof(rbac_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
+		break;
+
+	   case 0x1C:
+		total_len = sizeof(timer_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, timer_page, sizeof(timer_page));
+		break;
+
+	   case 0x3F:
+		total_len = sizeof(timer_page) + sizeof(rbac_page) +
+		    sizeof(cache_page) + sizeof(rw_err_page);
+		mode_param_header[0] = total_len >> 8;
+		mode_param_header[1] = total_len & 0xFF;
+		mode_param_header[3] = 0x00;	// WP enable: 0x80
+
+		memcpy(ptr, mode_param_header, sizeof(mode_param_header));
+		i += sizeof(mode_param_header);
+		memcpy(ptr + i, timer_page, sizeof(timer_page));
+		i += sizeof(timer_page);
+		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
+		i += sizeof(rbac_page);
+		memcpy(ptr + i, cache_page, sizeof(cache_page));
+		i += sizeof(cache_page);
+		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
+		break;
+	}
+
+	return USB_STOR_TRANSPORT_GOOD;
+}
+
+
+void jumpshot_info_destructor(void *extra)
+{
+	// this routine is a placeholder...
+	// currently, we don't allocate any extra blocks so we're okay
+}
+
+
+
+// Transport for the Lexar 'Jumpshot'
+//
+int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us)
+{
+	struct jumpshot_info *info;
+	int rc;
+	unsigned long block, blocks;
+	unsigned char *ptr = NULL;
+	unsigned char inquiry_response[36] = {
+		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
+	};
+
+
+	if (!us->extra) {
+		us->extra = kmalloc(sizeof(struct jumpshot_info), GFP_KERNEL);
+		if (!us->extra) {
+			US_DEBUGP("jumpshot_transport:  Gah! Can't allocate storage for jumpshot info struct!\n");
+			return USB_STOR_TRANSPORT_ERROR;
+		}
+		memset(us->extra, 0, sizeof(struct jumpshot_info));
+		us->extra_destructor = jumpshot_info_destructor;
+	}
+
+	info = (struct jumpshot_info *) (us->extra);
+	ptr = (unsigned char *) srb->request_buffer;
+
+	if (srb->cmnd[0] == INQUIRY) {
+		US_DEBUGP("jumpshot_transport:  INQUIRY.  Returning bogus response.\n");
+		memset(inquiry_response + 8, 0, 28);
+		fill_inquiry_response(us, inquiry_response, 36);
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	if (srb->cmnd[0] == READ_CAPACITY) {
+		info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec
+
+		rc = jumpshot_get_status(us);
+		if (rc != USB_STOR_TRANSPORT_GOOD)
+			return rc;
+
+		rc = jumpshot_id_device(us, info);
+		if (rc != USB_STOR_TRANSPORT_GOOD)
+			return rc;
+
+		US_DEBUGP("jumpshot_transport:  READ_CAPACITY:  %ld sectors, %ld bytes per sector\n",
+			  info->sectors, info->ssize);
+
+		// build the reply
+		//
+		ptr[0] = (info->sectors >> 24) & 0xFF;
+		ptr[1] = (info->sectors >> 16) & 0xFF;
+		ptr[2] = (info->sectors >> 8) & 0xFF;
+		ptr[3] = (info->sectors) & 0xFF;
+
+		ptr[4] = (info->ssize >> 24) & 0xFF;
+		ptr[5] = (info->ssize >> 16) & 0xFF;
+		ptr[6] = (info->ssize >> 8) & 0xFF;
+		ptr[7] = (info->ssize) & 0xFF;
+
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	if (srb->cmnd[0] == MODE_SELECT_10) {
+		US_DEBUGP("jumpshot_transport:  Gah! MODE_SELECT_10.\n");
+		return USB_STOR_TRANSPORT_ERROR;
+	}
+
+	if (srb->cmnd[0] == READ_10) {
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
+
+		US_DEBUGP("jumpshot_transport:  READ_10: read block 0x%04lx  count %ld\n", block, blocks);
+		return jumpshot_read_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == READ_12) {
+		// I don't think we'll ever see a READ_12 but support it anyway...
+		//
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
+		         ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
+
+		US_DEBUGP("jumpshot_transport:  READ_12: read block 0x%04lx  count %ld\n", block, blocks);
+		return jumpshot_read_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == WRITE_10) {
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
+
+		US_DEBUGP("jumpshot_transport:  WRITE_10: write block 0x%04lx  count %ld\n", block, blocks);
+		return jumpshot_write_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+	if (srb->cmnd[0] == WRITE_12) {
+		// I don't think we'll ever see a WRITE_12 but support it anyway...
+		//
+		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
+		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
+
+		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
+		         ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
+
+		US_DEBUGP("jumpshot_transport:  WRITE_12: write block 0x%04lx  count %ld\n", block, blocks);
+		return jumpshot_write_data(us, info, block, blocks, ptr, srb->use_sg);
+	}
+
+
+	if (srb->cmnd[0] == TEST_UNIT_READY) {
+		US_DEBUGP("jumpshot_transport:  TEST_UNIT_READY.\n");
+		return jumpshot_get_status(us);
+	}
+
+	if (srb->cmnd[0] == REQUEST_SENSE) {
+		US_DEBUGP("jumpshot_transport:  REQUEST_SENSE.  Returning NO SENSE for now\n");
+
+		ptr[0] = 0xF0;
+		ptr[2] = info->sense_key;
+		ptr[7] = 11;
+		ptr[12] = info->sense_asc;
+		ptr[13] = info->sense_ascq;
+
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	if (srb->cmnd[0] == MODE_SENSE) {
+		US_DEBUGP("jumpshot_transport:  MODE_SENSE_6 detected\n");
+		return jumpshot_handle_mode_sense(us, srb, ptr, TRUE);
+	}
+
+	if (srb->cmnd[0] == MODE_SENSE_10) {
+		US_DEBUGP("jumpshot_transport:  MODE_SENSE_10 detected\n");
+		return jumpshot_handle_mode_sense(us, srb, ptr, FALSE);
+	}
+	
+	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
+		// sure.  whatever.  not like we can stop the user from popping
+		// the media out of the device (no locking doors, etc)
+		//
+		return USB_STOR_TRANSPORT_GOOD;
+	}
+
+	US_DEBUGP("jumpshot_transport:  Gah! Unknown command: %d (0x%x)\n", srb->cmnd[0], srb->cmnd[0]);
+	return USB_STOR_TRANSPORT_ERROR;
+}

drivers/usb/storage/jumpshot.h

+/* Driver for Lexar "Jumpshot" USB Compact Flash reader
+ * Header File
+ *
+ * Current development and maintenance by:
+ *   (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org)
+ *
+ * See jumpshot.c for more explanation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _USB_JUMPSHOT_H
+#define _USB_JUMPSHOT_H
+
+#define min(a,b) (((a)<(b))?(a):(b))  // this is defined in tons of header files, i wish it had a standar single definition...
+
+extern int jumpshot_transport(Scsi_Cmnd *srb, struct us_data *us);
+
+struct jumpshot_info {
+   unsigned long   sectors;     // total sector count
+   unsigned long   ssize;       // sector size in bytes
+ 
+   // the following aren't used yet
+   unsigned char   sense_key;
+   unsigned long   sense_asc;   // additional sense code
+   unsigned long   sense_ascq;  // additional sense code qualifier
+};
+
+#endif

drivers/usb/storage/protocol.c

 /* Driver for USB Mass Storage compliant devices
  *
- * $Id: protocol.c,v 1.7 2000/11/13 22:28:33 mdharm Exp $
+ * $Id: protocol.c,v 1.10 2001/07/30 00:27:59 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -274,72 +274,68 @@ void usb_stor_ufi_command(Scsi_Cmnd *srb, struct us_data *us)
 
 void usb_stor_transparent_scsi_command(Scsi_Cmnd *srb, struct us_data *us)
 {
+	int old_cmnd = 0;
+
 	/* This code supports devices which do not support {READ|WRITE}_6
 	 * Apparently, neither Windows or MacOS will use these commands,
 	 * so some devices do not support them
 	 */
 	if (us->flags & US_FL_MODE_XLATE) {
+		US_DEBUGP("Invoking Mode Translation\n");
+		/* save the old command for later */
+		old_cmnd = srb->cmnd[0];
 
-		/* translate READ_6 to READ_10 */
-		if (srb->cmnd[0] == 0x08) {
-
-			/* get the control */
-			srb->cmnd[9] = us->srb->cmnd[5];
-
-			/* get the length */
-			srb->cmnd[8] = us->srb->cmnd[6];
+		switch (srb->cmnd[0]) {
+		/* change READ_6/WRITE_6 to READ_10/WRITE_10 */
+		case WRITE_6:
+		case READ_6:
+			srb->cmd_len = 12;
+			srb->cmnd[11] = 0;
+			srb->cmnd[10] = 0;
+			srb->cmnd[9] = 0;
+			srb->cmnd[8] = srb->cmnd[4];
 			srb->cmnd[7] = 0;
-
-			/* set the reserved area to 0 */
-			srb->cmnd[6] = 0;	    
-
-			/* get LBA */
-			srb->cmnd[5] = us->srb->cmnd[3];
-			srb->cmnd[4] = us->srb->cmnd[2];
-			srb->cmnd[3] = 0;
+			srb->cmnd[6] = 0;
+			srb->cmnd[5] = srb->cmnd[3];
+			srb->cmnd[4] = srb->cmnd[2];
+			srb->cmnd[3] = srb->cmnd[1] & 0x1F;
 			srb->cmnd[2] = 0;
-
-			/* LUN and other info in cmnd[1] can stay */
-
-			/* fix command code */
-			srb->cmnd[0] = 0x28;
-
-			US_DEBUGP("Changing READ_6 to READ_10\n");
-			US_DEBUG(usb_stor_show_command(srb));
-		}
-
-		/* translate WRITE_6 to WRITE_10 */
-		if (srb->cmnd[0] == 0x0A) {
-
-			/* get the control */
-			srb->cmnd[9] = us->srb->cmnd[5];
-
-			/* get the length */
-			srb->cmnd[8] = us->srb->cmnd[4];
+			srb->cmnd[1] = srb->cmnd[1] & 0xE0;
+			srb->cmnd[0] = srb->cmnd[0] | 0x20;
+			break;
+
+		/* convert MODE_SELECT data here */
+		case MODE_SENSE:
+		case MODE_SELECT:
+			srb->cmd_len = 12;
+			srb->cmnd[11] = 0;
+			srb->cmnd[10] = 0;
+			srb->cmnd[9] = 0;
+			srb->cmnd[8] = srb->cmnd[4];
 			srb->cmnd[7] = 0;
-
-			/* set the reserved area to 0 */
-			srb->cmnd[6] = 0;	    
-
-			/* get LBA */
-			srb->cmnd[5] = us->srb->cmnd[3];
-			srb->cmnd[4] = us->srb->cmnd[2];
+			srb->cmnd[6] = 0;
+			srb->cmnd[5] = 0;
+			srb->cmnd[4] = 0;
 			srb->cmnd[3] = 0;
-			srb->cmnd[2] = 0;
-	    
-			/* LUN and other info in cmnd[1] can stay */
-
-			/* fix command code */
-			srb->cmnd[0] = 0x2A;
-
-			US_DEBUGP("Changing WRITE_6 to WRITE_10\n");
-			US_DEBUG(usb_stor_show_command(us->srb));
-		}
+			srb->cmnd[2] = srb->cmnd[2];
+			srb->cmnd[1] = srb->cmnd[1];
+			srb->cmnd[0] = srb->cmnd[0] | 0x40;
+			break;
+		} /* switch (srb->cmnd[0]) */
 	} /* if (us->flags & US_FL_MODE_XLATE) */
 
+	/* convert MODE_SELECT data here */
+	if ((us->flags & US_FL_MODE_XLATE) && (old_cmnd == MODE_SELECT))
+		usb_stor_scsiSense6to10(srb);
+
 	/* send the command to the transport layer */
 	usb_stor_invoke_transport(srb, us);
 
+	/* Fix the MODE_SENSE data if we translated the command */
+	if ((us->flags & US_FL_MODE_XLATE) && (old_cmnd == MODE_SENSE)
+			&& (status_byte(srb->result) == GOOD))
+		usb_stor_scsiSense10to6(srb);
+
 	/* fix the INQUIRY data if necessary */
 	fix_inquiry_data(srb);
 }

drivers/usb/storage/protocol.h

 /* Driver for USB Mass Storage compliant devices
  * Protocol Functions Header File
  *
- * $Id: protocol.h,v 1.3 2000/08/25 00:13:51 mdharm Exp $
+ * $Id: protocol.h,v 1.4 2001/02/13 07:10:03 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -53,8 +53,9 @@
 #define US_SC_UFI	0x04		/* Floppy */
 #define US_SC_8070	0x05		/* Removable media */
 #define US_SC_SCSI	0x06		/* Transparent */
+#define US_SC_ISD200    0x07            /* ISD200 ATA */
 #define US_SC_MIN	US_SC_RBC
-#define US_SC_MAX	US_SC_SCSI
+#define US_SC_MAX	US_SC_ISD200
 
 extern void usb_stor_ATAPI_command(Scsi_Cmnd*, struct us_data*);
 extern void usb_stor_qic157_command(Scsi_Cmnd*, struct us_data*);

drivers/usb/storage/scsiglue.c

 /* Driver for USB Mass Storage compliant devices
  * SCSI layer glue code
  *
- * $Id: scsiglue.c,v 1.19 2000/11/13 22:28:55 mdharm Exp $
+ * $Id: scsiglue.c,v 1.21 2001/07/29 23:41:52 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -49,7 +49,7 @@
 #include "debug.h"
 #include "transport.h"
 
-#include <linux/slab.h>
+#include <linux/malloc.h>
 
 /*
  * kernel thread actions
@@ -122,8 +122,9 @@ static int release(struct Scsi_Host *psh)
 	 */
 	US_DEBUGP("-- sending US_ACT_EXIT command to thread\n");
 	us->action = US_ACT_EXIT;
-	wake_up(&(us->wqh));
-	down(&(us->notify));
+	
+	up(&(us->sema));
+	wait_for_completion(&(us->notify));
 
 	/* remove the pointer to the data structure we were using */
 	(struct us_data*)psh->hostdata[0] = NULL;
@@ -160,7 +161,7 @@ static int queuecommand( Scsi_Cmnd *srb , void (*done)(Scsi_Cmnd *))
 	up(&(us->queue_exclusion));
 
 	/* wake up the process task */
-	wake_up(&(us->wqh));
+	up(&(us->sema));
 
 	return 0;
 }
@@ -194,7 +195,7 @@ static int command_abort( Scsi_Cmnd *srb )
 		usb_unlink_urb(us->current_urb);
 
 		/* wait for us to be done */
-		down(&(us->notify));
+		wait_for_completion(&(us->notify));
 		return SUCCESS;
 	}
 
@@ -248,7 +249,7 @@ static int bus_reset( Scsi_Cmnd *srb )
         for (i = 0; i < us->pusb_dev->actconfig->bNumInterfaces; i++) {
  		struct usb_interface *intf =
 			&us->pusb_dev->actconfig->interface[i];
-		const struct usb_device_id *id;
+		struct usb_device_id *id;
 
 		/* if this is an unclaimed interface, skip it */
 		if (!intf->driver) {
@@ -331,7 +332,7 @@ static int proc_info (char *buffer, char **start, off_t offset, int length,
 		return -ESRCH;
 	}
 
-	/* print the controler name */
+	/* print the controller name */
 	SPRINTF("   Host scsi%d: usb-storage\n", hostno);
 
 	/* print product, vendor, and serial number strings */

drivers/usb/storage/sddr09.c

 /* Driver for SanDisk SDDR-09 SmartMedia reader
  *
- * $Id: sddr09.c,v 1.14 2000/11/21 02:58:26 mdharm Exp $
+ * $Id: sddr09.c,v 1.18 2001/06/11 02:54:25 mdharm Exp $
  *
  * SDDR09 driver v0.1:
  *
  * First release
  *
  * Current development and maintenance by:
- *   (c) 2000 Robert Baruch (autophile@dol.net)
+ *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
  *
  * The SanDisk SDDR-09 SmartMedia reader uses the Shuttle EUSB-01 chip.
  * This chip is a programmable USB controller. In the SDDR-09, it has
@@ -583,6 +583,10 @@ unsigned long sddr09_get_capacity(struct us_data *us,
 		*blocksize = 32;
 		return 0x04000000;
 
+	case 0x79: // 128MB
+		*blocksize = 32;
+		return 0x08000000;
+
 	default: // unknown
 		return 0;
 
@@ -691,10 +695,17 @@ int sddr09_read_map(struct us_data *us) {
 	for (i=0; i<numblocks; i++) {
 		ptr = sg[i>>11].address+(i<<6);
 		if (ptr[0]!=0xFF || ptr[1]!=0xFF || ptr[2]!=0xFF ||
-		    ptr[3]!=0xFF || ptr[4]!=0xFF || ptr[5]!=0xFF)
+		    ptr[3]!=0xFF || ptr[4]!=0xFF || ptr[5]!=0xFF) {
+			US_DEBUGP("PBA %04X has no logical mapping: reserved area = "
+			  "%02X%02X%02X%02X data status %02X block status %02X\n",
+			  i, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
 			continue;
-		if ((ptr[6]>>4)!=0x01)
+		}
+		if ((ptr[6]>>4)!=0x01) {
+			US_DEBUGP("PBA %04X has invalid address field %02X%02X/%02X%02X\n",
+			  i, ptr[6], ptr[7], ptr[11], ptr[12]);
 			continue;
+		}
 
 		/* ensure even parity */
 
@@ -711,21 +722,23 @@ int sddr09_read_map(struct us_data *us) {
 
 		lba = (lba&0x07FF)>>1;
 
-			/* Every 1024 physical blocks, the LBA numbers
+			/* Every 1024 physical blocks ("zone"), the LBA numbers
 			 * go back to zero, but are within a higher
-			 * block of LBA's. In other words, in blocks
-			 * 1024-2047 you will find LBA 0-1023 which are
-			 * really LBA 1024-2047.
+			 * block of LBA's. Also, there is a maximum of
+			 * 1000 LBA's per zone. In other words, in PBA
+			 * 1024-2047 you will find LBA 0-999 which are
+			 * really LBA 1000-1999. Yes, this wastes 24
+			 * physical blocks per zone. Go figure.
 			 */
 
-		lba += (i&~0x3FF);
+		lba += 1000*(i/0x400);
 
 		if (lba>=numblocks) {
 			US_DEBUGP("Bad LBA %04X for block %04X\n", lba, i);
 			continue;
 		}
 
-		if (lba<0x10)
+		if (lba<0x10 || (lba>=0x3E0 && lba<0x3EF))
 			US_DEBUGP("LBA %04X <-> PBA %04X\n", lba, i);
 
 		info->pba_to_lba[i] = lba;
@@ -812,8 +825,10 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 	unsigned char inquiry_response[36] = {
 		0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00
 	};
-	unsigned char mode_page_01[4] = { // write-protected for now
-		0x03, 0x00, 0x80, 0x00
+	unsigned char mode_page_01[16] = { // write-protected for now
+		0x03, 0x00, 0x80, 0x00,
+		0x01, 0x0A,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 	};
 	unsigned char *ptr;
 	unsigned long capacity;
@@ -890,10 +905,29 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 			// be a check for write-protect here
 
 		if ( (srb->cmnd[2] & 0x3F) == 0x01 ) {
-			if (ptr==NULL || srb->request_bufflen<4)
+
+			US_DEBUGP(
+			  "SDDR09: Dummy up request for mode page 1\n");
+
+			if (ptr==NULL || 
+			  srb->request_bufflen<sizeof(mode_page_01))
 				return USB_STOR_TRANSPORT_ERROR;
+
 			memcpy(ptr, mode_page_01, sizeof(mode_page_01));
 			return USB_STOR_TRANSPORT_GOOD;
+
+		} else if ( (srb->cmnd[2] & 0x3F) == 0x3F ) {
+
+			US_DEBUGP(
+			  "SDDR09: Dummy up request for all mode pages\n");
+
+			if (ptr==NULL || 
+			  srb->request_bufflen<sizeof(mode_page_01))
+				return USB_STOR_TRANSPORT_ERROR;
+
+			memcpy(ptr, mode_page_01, sizeof(mode_page_01));
+			return USB_STOR_TRANSPORT_GOOD;
+
 		}
 
 		// FIXME: sense buffer?
@@ -901,6 +935,17 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 		return USB_STOR_TRANSPORT_ERROR;
 	}
 
+	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
+
+		US_DEBUGP(
+		  "SDDR09: %s medium removal. Not that I can do"
+		  " anything about it...\n",
+		  (srb->cmnd[4]&0x03) ? "Prevent" : "Allow");
+
+		return USB_STOR_TRANSPORT_GOOD;
+
+	}
+
 	if (srb->cmnd[0] == READ_10) {
 
 		page = short_pack(srb->cmnd[3], srb->cmnd[2]);
@@ -919,6 +964,10 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 			(info->capacity >> 
 				(info->pageshift + info->blockshift) ) ) {
 
+			US_DEBUGP("Error: Requested LBA %04X exceeds maximum "
+			  "block %04X\n", lba,
+			  (info->capacity >> (info->pageshift + info->blockshift))-1);
+
 			// FIXME: sense buffer?
 
 			return USB_STOR_TRANSPORT_ERROR;
@@ -934,6 +983,9 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us)
 
 			// FIXME: sense buffer?
 
+			US_DEBUGP("Error: Requested LBA %04X has no physical block "
+			  "mapping.\n", lba);
+
 			return USB_STOR_TRANSPORT_ERROR;
 		}
 

drivers/usb/storage/shuttle_usbat.c

 /* Driver for SCM Microsystems USB-ATAPI cable
  *
- * $Id: shuttle_usbat.c,v 1.11 2000/11/13 22:29:36 mdharm Exp $
+ * $Id: shuttle_usbat.c,v 1.14 2001/03/28 01:02:06 groovyjava Exp $
  *
  * Current development and maintenance by:
- *   (c) 2000 Robert Baruch (autophile@dol.net)
+ *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
  *
  * Many originally ATAPI devices were slightly modified to meet the USB
  * market by using some kind of translation from ATAPI to USB on the host,
@@ -18,8 +18,8 @@
  * as well. This driver is only guaranteed to work with the ATAPI
  * translation.
  *
- * The only peripheral that I know of (as of 8 Sep 2000) that uses this
- * device is the Hewlett-Packard 8200e/8210e CD-Writer Plus.
+ * The only peripheral that I know of (as of 27 Mar 2001) that uses this
+ * device is the Hewlett-Packard 8200e/8210e/8230e CD-Writer Plus.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -344,12 +344,14 @@ int usbat_wait_not_busy(struct us_data *us, int minutes) {
 
 		if (result!=USB_STOR_TRANSPORT_GOOD)
 			return result;
-		if (status&0x01) // check condition
+		if (status&0x01) { // check condition
+			result = usbat_read(us, USBAT_ATA, 0x10, &status);
 			return USB_STOR_TRANSPORT_FAILED;
+		}
 		if (status&0x20) // device fault
 			return USB_STOR_TRANSPORT_FAILED;
 
-		if ((status&0x80)!=0x80) { // not busy
+		if ((status&0x80)==0x00) { // not busy
 			US_DEBUGP("Waited not busy for %d steps\n", i);
 			return USB_STOR_TRANSPORT_GOOD;
 		}
@@ -972,6 +974,9 @@ int hp8200e_transport(Scsi_Cmnd *srb, struct us_data *us)
 		data[i] = (i-7 >= srb->cmd_len) ? 0 : srb->cmnd[i-7];
 	}
 
+	result = usbat_read(us, USBAT_ATA, 0x17, &status);
+	US_DEBUGP("Status = %02X\n", status);
+
 	if (srb->cmnd[0] == TEST_UNIT_READY)
 		transferred = 0;
 

drivers/usb/storage/transport.c

 /* Driver for USB Mass Storage compliant devices
  *
- * $Id: transport.c,v 1.38 2000/11/21 00:52:10 mdharm Exp $
+ * $Id: transport.c,v 1.39 2001/03/10 16:46:28 zagor Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -52,7 +52,7 @@
 
 #include <linux/sched.h>
 #include <linux/errno.h>
-#include <linux/slab.h>
+#include <linux/malloc.h>
 
 /***********************************************************************
  * Helper routines
@@ -342,7 +342,7 @@ return len;
  * the device -- this is because some devices crash their internal firmware
  * when the status is requested after a halt
  */
-static int clear_halt(struct usb_device *dev, int pipe)
+int usb_stor_clear_halt(struct usb_device *dev, int pipe)
 {
 	int result;
 	int endp = usb_pipeendpoint(pipe) | (usb_pipein(pipe) << 7);
@@ -536,7 +536,7 @@ int usb_stor_transfer_partial(struct us_data *us, char *buf, int length)
 	/* if we stall, we need to clear it before we go on */
 	if (result == -EPIPE) {
 		US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
-		clear_halt(us->pusb_dev, pipe);
+		usb_stor_clear_halt(us->pusb_dev, pipe);
 	}
 
 	/* did we send all the data? */
@@ -577,7 +577,7 @@ int usb_stor_transfer_partial(struct us_data *us, char *buf, int length)
  * function simply determines if we're going to use scatter-gather or not,
  * and acts appropriately.  For now, it also re-interprets the error codes.
  */
-static void us_transfer(Scsi_Cmnd *srb, struct us_data* us)
+void usb_stor_transfer(Scsi_Cmnd *srb, struct us_data* us)
 {
 	int i;
 	int result = -1;
@@ -635,7 +635,7 @@ static void us_transfer(Scsi_Cmnd *srb, struct us_data* us)
 /* Invoke the transport and basic error-handling/recovery methods
  *
  * This is used by the protocol layers to actually send the message to
- * the device and receive the response.
+ * the device and recieve the response.
  */
 void usb_stor_invoke_transport(Scsi_Cmnd *srb, struct us_data *us)
 {
@@ -821,7 +821,7 @@ void usb_stor_CBI_irq(struct urb *urb)
 {
 	struct us_data *us = (struct us_data *)urb->context;
 
-	US_DEBUGP("USB IRQ received for device on host %d\n", us->host_no);
+	US_DEBUGP("USB IRQ recieved for device on host %d\n", us->host_no);
 	US_DEBUGP("-- IRQ data length is %d\n", urb->actual_length);
 	US_DEBUGP("-- IRQ state is %d\n", urb->status);
 	US_DEBUGP("-- Interrupt Status (0x%x, 0x%x)\n",
@@ -895,10 +895,10 @@ int usb_stor_CBI_transport(Scsi_Cmnd *srb, struct us_data *us)
 		/* STALL must be cleared when they are detected */
 		if (result == -EPIPE) {
 			US_DEBUGP("-- Stall on control pipe. Clearing\n");
-			result = clear_halt(us->pusb_dev,	
+			result = usb_stor_clear_halt(us->pusb_dev,	
 					    usb_sndctrlpipe(us->pusb_dev,
 							    0));
-			US_DEBUGP("-- clear_halt() returns %d\n", result);
+			US_DEBUGP("-- usb_stor_clear_halt() returns %d\n", result);
 			return USB_STOR_TRANSPORT_FAILED;
 		}
 
@@ -909,7 +909,7 @@ int usb_stor_CBI_transport(Scsi_Cmnd *srb, struct us_data *us)
 	/* DATA STAGE */
 	/* transfer the data payload for this command, if one exists*/
 	if (usb_stor_transfer_length(srb)) {
-		us_transfer(srb, us);
+		usb_stor_transfer(srb, us);
 		US_DEBUGP("CBI data stage result is 0x%x\n", srb->result);
 
 		/* if it was aborted, we need to indicate that */
@@ -999,10 +999,10 @@ int usb_stor_CB_transport(Scsi_Cmnd *srb, struct us_data *us)
 		/* a stall is a fatal condition from the device */
 		if (result == -EPIPE) {
 			US_DEBUGP("-- Stall on control pipe. Clearing\n");
-			result = clear_halt(us->pusb_dev, 
+			result = usb_stor_clear_halt(us->pusb_dev, 
 					    usb_sndctrlpipe(us->pusb_dev,
 							    0));
-			US_DEBUGP("-- clear_halt() returns %d\n", result);
+			US_DEBUGP("-- usb_stor_clear_halt() returns %d\n", result);
 			return USB_STOR_TRANSPORT_FAILED;
 		}
 
@@ -1013,7 +1013,7 @@ int usb_stor_CB_transport(Scsi_Cmnd *srb, struct us_data *us)
 	/* DATA STAGE */
 	/* transfer the data payload for this command, if one exists*/
 	if (usb_stor_transfer_length(srb)) {
-		us_transfer(srb, us);
+		usb_stor_transfer(srb, us);
 		US_DEBUGP("CB data stage result is 0x%x\n", srb->result);
 
 		/* if it was aborted, we need to indicate that */
@@ -1057,7 +1057,7 @@ int usb_stor_Bulk_max_lun(struct us_data *us)
 	/* if we get a STALL, clear the stall */
 	if (result == -EPIPE) {
 		US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
-		clear_halt(us->pusb_dev, pipe);
+		usb_stor_clear_halt(us->pusb_dev, pipe);
 	}
 
 	/* return the default -- no LUNs */
@@ -1111,17 +1111,17 @@ int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
 	/* if we stall, we need to clear it before we go on */
 	if (result == -EPIPE) {
 		US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
-		clear_halt(us->pusb_dev, pipe);
+		usb_stor_clear_halt(us->pusb_dev, pipe);
 	} else if (result) {
 		/* unknown error -- we've got a problem */
 		return USB_STOR_TRANSPORT_ERROR;
 	}
 
-	/* if the command transferred well, then we go to the data stage */
+	/* if the command transfered well, then we go to the data stage */
 	if (result == 0) {
 		/* send/receive data payload, if there is any */
 		if (bcb.DataTransferLength) {
-			us_transfer(srb, us);
+			usb_stor_transfer(srb, us);
 			US_DEBUGP("Bulk data transfer result 0x%x\n", 
 				  srb->result);
 
@@ -1150,7 +1150,7 @@ int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
 	/* did the attempt to read the CSW fail? */
 	if (result == -EPIPE) {
 		US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
-		clear_halt(us->pusb_dev, pipe);
+		usb_stor_clear_halt(us->pusb_dev, pipe);
 	       
 		/* get the status again */
 		US_DEBUGP("Attempting to get CSW (2nd try)...\n");
@@ -1164,7 +1164,7 @@ int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
 		/* if it fails again, we need a reset and return an error*/
 		if (result == -EPIPE) {
 			US_DEBUGP("clearing halt for pipe 0x%x\n", pipe);
-			clear_halt(us->pusb_dev, pipe);
+			usb_stor_clear_halt(us->pusb_dev, pipe);
 			return USB_STOR_TRANSPORT_ERROR;
 		}
 	}
@@ -1243,10 +1243,10 @@ int usb_stor_CB_reset(struct us_data *us)
 	set_current_state(TASK_RUNNING);
 
 	US_DEBUGP("CB_reset: clearing endpoint halt\n");
-	clear_halt(us->pusb_dev, 
-		   usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
-	clear_halt(us->pusb_dev, 
-		   usb_rcvbulkpipe(us->pusb_dev, us->ep_out));
+	usb_stor_clear_halt(us->pusb_dev, 
+			    usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
+	usb_stor_clear_halt(us->pusb_dev, 
+			    usb_rcvbulkpipe(us->pusb_dev, us->ep_out));
 
 	US_DEBUGP("CB_reset done\n");
 	/* return a result code based on the result of the control message */
@@ -1282,10 +1282,10 @@ int usb_stor_Bulk_reset(struct us_data *us)
 	schedule_timeout(HZ*6);
 	set_current_state(TASK_RUNNING);
 
-	clear_halt(us->pusb_dev, 
-		   usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
-	clear_halt(us->pusb_dev, 
-		   usb_sndbulkpipe(us->pusb_dev, us->ep_out));
+	usb_stor_clear_halt(us->pusb_dev, 
+			    usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
+	usb_stor_clear_halt(us->pusb_dev, 
+			    usb_sndbulkpipe(us->pusb_dev, us->ep_out));
 	US_DEBUGP("Bulk soft reset completed\n");
 	return SUCCESS;
 }

drivers/usb/storage/transport.h

 /* Driver for USB Mass Storage compliant devices
  * Transport Functions Header File
  *
- * $Id: transport.h,v 1.13 2000/10/03 01:06:07 mdharm Exp $
+ * $Id: transport.h,v 1.15 2001/03/17 20:06:23 jrmayfield Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -64,6 +64,14 @@
 #define US_PR_FREECOM   0xf1            /* Freecom */
 #endif
 
+#ifdef CONFIG_USB_STORAGE_DATAFAB
+#define US_PR_DATAFAB   0xf2            /* Datafab chipsets */
+#endif
+
+#ifdef CONFIG_USB_STORAGE_JUMPSHOT
+#define US_PR_JUMPSHOT  0xf3            /* Lexar Jumpshot */
+#endif
+
 /*
  * Bulk only data structures
  */
@@ -107,7 +115,7 @@ struct bulk_cs_wrap {
  * us_bulk_transfer() return codes
  */
 #define US_BULK_TRANSFER_GOOD		0  /* good transfer                 */
-#define US_BULK_TRANSFER_SHORT		1  /* transferred less than expected */
+#define US_BULK_TRANSFER_SHORT		1  /* transfered less than expected */
 #define US_BULK_TRANSFER_FAILED		2  /* transfer died in the middle   */
 #define US_BULK_TRANSFER_ABORTED	3  /* transfer canceled             */
 
@@ -143,4 +151,6 @@ extern int usb_stor_bulk_msg(struct us_data*, void*, int, unsigned int,
 		unsigned int*);
 extern int usb_stor_control_msg(struct us_data*, unsigned int, u8, u8,
 		u16, u16, void*, u16);
+extern void usb_stor_transfer(Scsi_Cmnd*, struct us_data*);
+extern int usb_stor_clear_halt(struct usb_device*, int );
 #endif

drivers/usb/storage/unusual_devs.h

 /* Driver for USB Mass Storage compliant devices
  * Ununsual Devices File
  *
- * $Id: unusual_devs.h,v 1.1 2000/12/05 05:38:31 mdharm Exp $
+ * $Id: unusual_devs.h,v 1.16 2001/07/30 00:27:59 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -42,6 +42,12 @@ UNUSUAL_DEV(  0x03ee, 0x0000, 0x0000, 0x0245,
 		"CD-R/RW Drive",
 		US_SC_8020, US_PR_CBI, NULL, 0), 
 
+UNUSUAL_DEV(  0x03ee, 0x6901, 0x0000, 0x0100,
+		"Mitsumi",
+		"USB FDD",
+		US_SC_UFI, US_PR_CBI, NULL,
+		US_FL_SINGLE_LUN ),
+
 UNUSUAL_DEV(  0x03f0, 0x0107, 0x0200, 0x0200, 
 		"HP",
 		"CD-Writer+",
@@ -54,6 +60,22 @@ UNUSUAL_DEV(  0x03f0, 0x0207, 0x0001, 0x0001,
 		US_SC_8070, US_PR_SCM_ATAPI, init_8200e, 0), 
 #endif
 
+#ifdef CONFIG_USB_STORAGE_DPCM
+UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
+		"Microtech",
+		"CameraMate (DPCM_USB)",
+ 		US_SC_SCSI, US_PR_DPCM_USB, NULL,
+		US_FL_START_STOP ),
+#endif
+
+UNUSUAL_DEV(  0x04cb, 0x0100, 0x0000, 0x2210,
+		"Fujifilm",
+		"FinePix 1400Zoom",
+		US_SC_8070, US_PR_CBI, NULL, US_FL_FIX_INQUIRY),
+
+/* Most of the following entries were developed with the help of
+ * Shuttle/SCM directly.
+ */
 UNUSUAL_DEV(  0x04e6, 0x0001, 0x0200, 0x0200, 
 		"Matshita",
 		"LS-120",
@@ -73,21 +95,14 @@ UNUSUAL_DEV(  0x04e6, 0x0003, 0x0000, 0x9999,
 		US_FL_SINGLE_LUN | US_FL_START_STOP ),
 #endif
 
-#ifdef CONFIG_USB_STORAGE_DPCM
-UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
-		"Microtech",
-		"CameraMate (DPCM_USB)",
- 		US_SC_SCSI, US_PR_DPCM_USB, NULL,
-		US_FL_START_STOP ),
-
-UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
-		"SCM Microsystems Inc",
+/* This entry is from Andries.Brouwer@cwi.nl */
+UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0205, 
+		"SCM Microsystems",
 		"eUSB SmartMedia / CompactFlash Adapter",
-		US_SC_SCSI, US_PR_DPCM_USB, NULL,
-		US_FL_START_STOP ),
-#endif
+		US_SC_SCSI, US_PR_DPCM_USB, NULL, 
+		US_FL_START_STOP), 
 
-UNUSUAL_DEV(  0x04e6, 0x0006, 0x0100, 0x0200, 
+UNUSUAL_DEV(  0x04e6, 0x0006, 0x0100, 0x0205, 
 		"Shuttle",
 		"eUSB MMC Adapter",
 		US_SC_SCSI, US_PR_CB, NULL, 
@@ -126,9 +141,17 @@ UNUSUAL_DEV(  0x04e6, 0x0101, 0x0200, 0x0200,
 		"CD-RW Device",
 		US_SC_8020, US_PR_CB, NULL, 0),
 
-UNUSUAL_DEV(  0x054c, 0x0010, 0x0106, 0x0210, 
+/* Reported by Bob Sass <rls@vectordb.com> -- only rev 1.33 tested */
+UNUSUAL_DEV(  0x050d, 0x0115, 0x0133, 0x0133,
+		"Belkin",
+		"USB SCSI Adaptor",
+		US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
+		US_FL_SCM_MULT_TARG ),
+
+/* This entry is needed because the device reports Sub=ff */
+UNUSUAL_DEV(  0x054c, 0x0010, 0x0106, 0x0322, 
 		"Sony",
-		"DSC-S30/S70/505V/F505", 
+		"DSC-S30/S70/S75/505V/F505", 
 		US_SC_SCSI, US_PR_CB, NULL,
 		US_FL_SINGLE_LUN | US_FL_START_STOP | US_FL_MODE_XLATE ),
 
@@ -138,6 +161,19 @@ UNUSUAL_DEV(  0x054c, 0x002d, 0x0100, 0x0100,
 		US_SC_UFI, US_PR_CB, NULL,
 		US_FL_SINGLE_LUN | US_FL_START_STOP ),
 
+/* Submitted by Klaus Mueller <k.mueller@intership.de> */
+UNUSUAL_DEV(  0x054c, 0x002e, 0x0106, 0x0310, 
+		"Sony",
+		"Handycam",
+		US_SC_SCSI, US_PR_CB, NULL,
+		US_FL_SINGLE_LUN | US_FL_START_STOP | US_FL_MODE_XLATE),
+
+UNUSUAL_DEV(  0x054c, 0x0032, 0x0000, 0x9999,
+                "Sony",
+		"Memorystick MSC-U01N",
+		US_SC_UFI, US_PR_CB, NULL,
+		US_FL_SINGLE_LUN | US_FL_START_STOP ),
+		
 UNUSUAL_DEV(  0x057b, 0x0000, 0x0000, 0x0299, 
 		"Y-E Data",
 		"Flashbuster-U",
@@ -155,10 +191,51 @@ UNUSUAL_DEV(  0x059f, 0xa601, 0x0200, 0x0200,
 		"USB Hard Disk",
 		US_SC_RBC, US_PR_CB, NULL, 0 ), 
 
-UNUSUAL_DEV(  0x05ab, 0x0031, 0x0100, 0x0100, 
-		"In-System",
-		"USB/IDE Bridge (ATAPI ONLY!)",
-		US_SC_8070, US_PR_BULK, NULL, 0 ), 
+#ifdef CONFIG_USB_STORAGE_ISD200
+UNUSUAL_DEV(  0x05ab, 0x0031, 0x0100, 0x0110,
+                "In-System",
+                "USB/IDE Bridge (ATA/ATAPI)",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+
+UNUSUAL_DEV(  0x05ab, 0x0060, 0x0100, 0x0110,
+                "In-System",
+                "USB 2.0/IDE Bridge (ATA/ATAPI)",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+
+UNUSUAL_DEV(  0x05ab, 0x0301, 0x0100, 0x0110,
+                "In-System",
+                "Portable USB Harddrive V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+
+UNUSUAL_DEV(  0x05ab, 0x0351, 0x0100, 0x0110,
+                "In-System",
+                "Portable USB Harddrive V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+
+UNUSUAL_DEV(  0x05ab, 0x5701, 0x0100, 0x0110,
+                "In-System",
+                "USB Storage Adapter V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+
+UNUSUAL_DEV(  0x054c, 0x002b, 0x0100, 0x0110,
+                "Sony",
+                "Portable USB Harddrive V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+#endif
+
+#ifdef CONFIG_USB_STORAGE_JUMPSHOT
+UNUSUAL_DEV(  0x05dc, 0x0001, 0x0000, 0x0001,
+		"Lexar",
+		"Jumpshot USB CF Reader",
+		US_SC_SCSI, US_PR_JUMPSHOT, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+#endif
 
 UNUSUAL_DEV(  0x0644, 0x0000, 0x0100, 0x0100, 
 		"TEAC",
@@ -189,25 +266,32 @@ UNUSUAL_DEV(  0x0781, 0x0001, 0x0200, 0x0200,
 		US_SC_SCSI, US_PR_CB, NULL,
 		US_FL_SINGLE_LUN | US_FL_START_STOP),
 
-UNUSUAL_DEV( 0x0781, 0x0100, 0x0100, 0x0100,
+UNUSUAL_DEV(  0x0781, 0x0002, 0x0009, 0x0009, 
+		"Sandisk",
+		"ImageMate SDDR-31",
+		US_SC_SCSI, US_PR_BULK, NULL,
+		US_FL_IGNORE_SER),
+
+UNUSUAL_DEV(  0x0781, 0x0100, 0x0100, 0x0100,
                 "Sandisk",
                 "ImageMate SDDR-12",
                 US_SC_SCSI, US_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 
 #ifdef CONFIG_USB_STORAGE_SDDR09
-UNUSUAL_DEV(  0x0781, 0x0200, 0x0100, 0x0100, 
+UNUSUAL_DEV(  0x0781, 0x0200, 0x0000, 0x9999, 
 		"Sandisk",
 		"ImageMate SDDR-09",
 		US_SC_SCSI, US_PR_EUSB_SDDR09, NULL,
 		US_FL_SINGLE_LUN | US_FL_START_STOP ),
 #endif
 
-UNUSUAL_DEV(  0x0781, 0x0002, 0x0009, 0x0009, 
-		"Sandisk",
-		"ImageMate SDDR-31",
-		US_SC_SCSI, US_PR_BULK, NULL,
-		US_FL_IGNORE_SER),
+#ifdef CONFIG_USB_STORAGE_FREECOM
+UNUSUAL_DEV(  0x07ab, 0xfc01, 0x0000, 0x9999,
+                "Freecom",
+                "USB-IDE",
+                US_SC_QIC, US_PR_FREECOM, freecom_init, 0),
+#endif
 
 UNUSUAL_DEV(  0x07af, 0x0004, 0x0100, 0x0100, 
 		"Microtech",
@@ -215,13 +299,6 @@ UNUSUAL_DEV(  0x07af, 0x0004, 0x0100, 0x0100,
 		US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
 		US_FL_SCM_MULT_TARG ), 
 
-#ifdef CONFIG_USB_STORAGE_FREECOM
-UNUSUAL_DEV( 0x07ab, 0xfc01, 0x0000, 0x9999,
-                "Freecom",
-                "USB-IDE",
-                US_SC_QIC, US_PR_FREECOM, freecom_init, 0),
-#endif
-
 UNUSUAL_DEV(  0x07af, 0x0005, 0x0100, 0x0100, 
 		"Microtech",
 		"USB-SCSI-HD50",
@@ -236,3 +313,78 @@ UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
 		US_FL_START_STOP ),
 #endif
 
+#ifdef CONFIG_USB_STORAGE_DATAFAB
+UNUSUAL_DEV(  0x07c4, 0xa000, 0x0000, 0x0015,
+		"Datafab",
+		"MDCFE-B USB CF Reader",
+		US_SC_SCSI, US_PR_DATAFAB, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+
+	/*
+	 * The following Datafab-based devices may or may not work
+	 * using the current driver...the 0xffff is arbitrary since I
+	 * don't know what device versions exist for these guys.
+	 *
+	 * The 0xa003 and 0xa004 devices in particular I'm curious about.
+	 * I'm told they exist but so far nobody has come forward to say that
+	 * they work with this driver.  Given the success we've had getting
+	 * other Datafab-based cards operational with this driver, I've decided
+	 * to leave these two devices in the list.
+	 */
+UNUSUAL_DEV( 0x07c4, 0xa001, 0x0000, 0xffff,
+		"SIIG/Datafab",
+		"SIIG/Datafab Memory Stick+CF Reader/Writer",
+		US_SC_SCSI, US_PR_DATAFAB, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+
+UNUSUAL_DEV( 0x07c4, 0xa003, 0x0000, 0xffff,
+		"Datafab/Unknown",
+		"Datafab-based Reader",
+		US_SC_SCSI, US_PR_DATAFAB, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+
+UNUSUAL_DEV( 0x07c4, 0xa004, 0x0000, 0xffff,
+		"Datafab/Unknown",
+		"Datafab-based Reader",
+		US_SC_SCSI, US_PR_DATAFAB, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+
+UNUSUAL_DEV( 0x07c4, 0xa005, 0x0000, 0xffff,
+		"PNY/Datafab",
+		"PNY/Datafab CF+SM Reader",
+		US_SC_SCSI, US_PR_DATAFAB, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+
+UNUSUAL_DEV( 0x07c4, 0xa006, 0x0000, 0xffff,
+		"Simple Tech/Datafab",
+		"Simple Tech/Datafab CF+SM Reader",
+		US_SC_SCSI, US_PR_DATAFAB, NULL,
+		US_FL_MODE_XLATE | US_FL_START_STOP ),
+#endif
+
+/* Casio QV 2x00/3x00/8000 digital still cameras are not conformant
+ * to the USB storage specification in two ways:
+ * - They tell us they are using transport protocol CBI. In reality they
+ *   are using transport protocol CB.
+ * - They don't like the INQUIRY command. So we must handle this command
+ *   of the SCSI layer ourselves.
+ */
+UNUSUAL_DEV( 0x07cf, 0x1001, 0x9009, 0x9009,
+                "Casio",
+                "QV DigitalCamera",
+                US_SC_8070, US_PR_CB, NULL,
+                US_FL_FIX_INQUIRY ),
+
+UNUSUAL_DEV(  0x097a, 0x0001, 0x0000, 0x0001,
+		"Minds@Work",
+		"Digital Wallet",
+ 		US_SC_SCSI, US_PR_CB, NULL,
+		US_FL_MODE_XLATE ),
+
+#ifdef CONFIG_USB_STORAGE_ISD200
+UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
+                "ATI",
+                "USB Cable 205",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0 ),
+#endif

drivers/usb/storage/usb.c

 /* Driver for USB Mass Storage compliant devices
  *
- * $Id: usb.c,v 1.61 2001/01/13 00:10:59 mdharm Exp $
+ * $Id: usb.c,v 1.67 2001/07/29 23:41:52 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -53,6 +53,7 @@
 #include "protocol.h"
 #include "debug.h"
 #include "initializers.h"
+
 #ifdef CONFIG_USB_STORAGE_HP8200e
 #include "shuttle_usbat.h"
 #endif
@@ -65,12 +66,22 @@
 #ifdef CONFIG_USB_STORAGE_FREECOM
 #include "freecom.h"
 #endif
+#ifdef CONFIG_USB_STORAGE_ISD200
+#include "isd200.h"
+#endif
+#ifdef CONFIG_USB_STORAGE_DATAFAB
+#include "datafab.h"
+#endif
+#ifdef CONFIG_USB_STORAGE_JUMPSHOT
+#include "jumpshot.h"
+#endif
+
 
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/init.h>
-#include <linux/slab.h>
+#include <linux/malloc.h>
 
 /* Some informational data */
 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
@@ -151,7 +162,7 @@ MODULE_DEVICE_TABLE (usb, storage_usb_ids);
 
 /* The vendor name should be kept at eight characters or less, and
  * the product name should be kept at 16 characters or less. If a device
- * has the US_FL_DUMMY_INQUIRY flag, then the vendor and product names
+ * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
  * normally generated by a device thorugh the INQUIRY response will be
  * taken from this list, and this is the reason for the above size
  * restriction. However, if the flag is not present, then you
@@ -281,7 +292,6 @@ void fill_inquiry_response(struct us_data *us, unsigned char *data,
 
 static int usb_stor_control_thread(void * __us)
 {
-	wait_queue_t wait;
 	struct us_data *us = (struct us_data *)__us;
 	int action;
 
@@ -302,17 +312,17 @@ static int usb_stor_control_thread(void * __us)
 	unlock_kernel();
 
 	/* set up for wakeups by new commands */
-	init_waitqueue_entry(&wait, current);
-	init_waitqueue_head(&(us->wqh));
-	add_wait_queue(&(us->wqh), &wait);
+	init_MUTEX_LOCKED(&us->sema);
 
 	/* signal that we've started the thread */
-	up(&(us->notify));
+	complete(&(us->notify));
 	set_current_state(TASK_INTERRUPTIBLE);
 
 	for(;;) {
 		US_DEBUGP("*** thread sleeping.\n");
-		schedule();
+		if(down_interruptible(&us->sema))
+			break;
+			
 		US_DEBUGP("*** thread awakened.\n");
 
 		/* lock access to the queue element */
@@ -378,6 +388,24 @@ static int usb_stor_control_thread(void * __us)
 				break;
 			}
 
+			/* Handle those devices which need us to fake their
+			 * inquiry data */
+			if ((us->srb->cmnd[0] == INQUIRY) &&
+			    (us->flags & US_FL_FIX_INQUIRY)) {
+			    	unsigned char data_ptr[36] = {
+				    0x00, 0x80, 0x02, 0x02,
+				    0x1F, 0x00, 0x00, 0x00};
+
+			    	US_DEBUGP("Faking INQUIRY command\n");
+				fill_inquiry_response(us, data_ptr, 36);
+				us->srb->result = GOOD << 1;
+
+				set_current_state(TASK_INTERRUPTIBLE);
+				us->srb->scsi_done(us->srb);
+				us->srb = NULL;
+				break;
+			}
+
 			/* lock the device pointers */
 			down(&(us->dev_semaphore));
 
@@ -417,7 +445,7 @@ static int usb_stor_control_thread(void * __us)
 			} else {
 				US_DEBUGP("scsi command aborted\n");
 				set_current_state(TASK_INTERRUPTIBLE);
-				up(&(us->notify));
+				complete(&(us->notify));
 			}
 			us->srb = NULL;
 			break;
@@ -435,17 +463,16 @@ static int usb_stor_control_thread(void * __us)
 
 		/* exit if we get a signal to exit */
 		if (action == US_ACT_EXIT) {
-			US_DEBUGP("-- US_ACT_EXIT command recieved\n");
+			US_DEBUGP("-- US_ACT_EXIT command received\n");
 			break;
 		}
 	} /* for (;;) */
 
 	/* clean up after ourselves */
 	set_current_state(TASK_INTERRUPTIBLE);
-	remove_wait_queue(&(us->wqh), &wait);
 
 	/* notify the exit routine that we're actually exiting now */
-	up(&(us->notify));
+	complete(&(us->notify));
 
 	return 0;
 }	
@@ -717,7 +744,7 @@ static void * storage_probe(struct usb_device *dev, unsigned int ifnum,
 		}
 
 		/* Initialize the mutexes only when the struct is new */
-		init_MUTEX_LOCKED(&(ss->notify));
+		init_completion(&(ss->notify));
 		init_MUTEX_LOCKED(&(ss->ip_waitq));
 		init_MUTEX(&(ss->queue_exclusion));
 		init_MUTEX(&(ss->irq_urb_sem));
@@ -831,6 +858,24 @@ static void * storage_probe(struct usb_device *dev, unsigned int ifnum,
                         break;
 #endif
 
+#ifdef CONFIG_USB_STORAGE_DATAFAB
+                case US_PR_DATAFAB:
+                        ss->transport_name  = "Datafab Bulk-Only";
+                        ss->transport = datafab_transport;
+                        ss->transport_reset = usb_stor_Bulk_reset;
+                        ss->max_lun = 1;
+                        break;
+#endif
+
+#ifdef CONFIG_USB_STORAGE_JUMPSHOT
+                case US_PR_JUMPSHOT:
+                        ss->transport_name  = "Lexar Jumpshot Control/Bulk";
+                        ss->transport = jumpshot_transport;
+                        ss->transport_reset = usb_stor_Bulk_reset;
+                        ss->max_lun = 1;
+                        break;
+#endif
+
 		default:
 			ss->transport_name = "Unknown";
 			kfree(ss->current_urb);
@@ -879,6 +924,13 @@ static void * storage_probe(struct usb_device *dev, unsigned int ifnum,
 			ss->proto_handler = usb_stor_ufi_command;
 			break;
 
+#ifdef CONFIG_USB_STORAGE_ISD200
+                case US_SC_ISD200:
+                        ss->protocol_name = "ISD200 ATA/ATAPI";
+                        ss->proto_handler = isd200_ata_command;
+                        break;
+#endif
+
 		default:
 			ss->protocol_name = "Unknown";
 			kfree(ss->current_urb);
@@ -907,7 +959,7 @@ static void * storage_probe(struct usb_device *dev, unsigned int ifnum,
 		ss->host_number = my_host_number++;
 
 		/* We abuse this pointer so we can pass the ss pointer to 
-		 * the host controler thread in us_detect.  But how else are
+		 * the host controller thread in us_detect.  But how else are
 		 * we to do it?
 		 */
 		(struct us_data *)ss->htmplt.proc_dir = ss; 
@@ -930,7 +982,7 @@ static void * storage_probe(struct usb_device *dev, unsigned int ifnum,
 		}
 
 		/* wait for the thread to start */
-		down(&(ss->notify));
+		wait_for_completion(&(ss->notify));
 
 		/* now register	 - our detect function will be called */
 		ss->htmplt.module = THIS_MODULE;

drivers/usb/storage/usb.h

 /* Driver for USB Mass Storage compliant devices
  * Main Header File
  *
- * $Id: usb.h,v 1.12 2000/12/05 03:33:49 mdharm Exp $
+ * $Id: usb.h,v 1.18 2001/07/30 00:27:59 mdharm Exp $
  *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
@@ -47,6 +47,7 @@
 #include <linux/usb.h>
 #include <linux/blk.h>
 #include <linux/smp_lock.h>
+#include <linux/completion.h>
 #include "scsi.h"
 #include "hosts.h"
 
@@ -94,11 +95,12 @@ struct us_unusual_dev {
 
 /* Flag definitions */
 #define US_FL_SINGLE_LUN      0x00000001 /* allow access to only LUN 0	    */
-#define US_FL_MODE_XLATE      0x00000002 /* translate _6 to _10 comands for
+#define US_FL_MODE_XLATE      0x00000002 /* translate _6 to _10 commands for
 						    Win/MacOS compatibility */
 #define US_FL_START_STOP      0x00000004 /* ignore START_STOP commands	    */
 #define US_FL_IGNORE_SER      0x00000010 /* Ignore the serial number given  */
 #define US_FL_SCM_MULT_TARG   0x00000020 /* supports multiple targets */
+#define US_FL_FIX_INQUIRY     0x00000040 /* INQUIRY response needs fixing */
 
 #define USB_STOR_STRING_LEN 32
 
@@ -165,11 +167,11 @@ struct us_data {
 	struct semaphore	current_urb_sem; /* to protect irq_urb	 */
 	struct urb		*current_urb;	 /* non-int USB requests */
 
-	/* the waitqueue for sleeping the control thread */
-	wait_queue_head_t	wqh;		 /* to sleep thread on   */
+	/* the semaphore for sleeping the control thread */
+	struct semaphore	sema;		 /* to sleep thread on   */
 
 	/* mutual exclusion structures */
-	struct semaphore	notify;		 /* thread begin/end	    */
+	struct completion	notify;		 /* thread begin/end	    */
 	struct semaphore	queue_exclusion; /* to protect data structs */
 	struct us_unusual_dev   *unusual_dev;	 /* If unusual device       */
 	void			*extra;		 /* Any extra data          */

include/asm-i386/softirq.h

@@ -28,8 +28,6 @@ do {									\
 	unsigned long flags;						\
 									\
 	__save_flags(flags);						\
-	if (!(flags & (1 << 9)))					\
-		BUG();							\
 	barrier();							\
 	if (!--*ptr)							\
 		__asm__ __volatile__ (					\

include/linux/swap.h

@@ -100,8 +100,6 @@ struct zone_t;
 
 /* linux/mm/swap.c */
 extern int memory_pressure;
-extern void age_page_up(struct page *);
-extern void age_page_up_nolock(struct page *);
 extern void age_page_down(struct page *);
 extern void age_page_down_nolock(struct page *);
 extern void age_page_down_ageonly(struct page *);

mm/memory.c

@@ -619,9 +619,9 @@ int lock_kiovec(int nr, struct kiobuf *iovec[], int wait)
 			
 			if (TryLockPage(page)) {
 				while (j--) {
-					page = *(--ppage);
-					if (page)
-						UnlockPage(page);
+					struct page *tmp = *--ppage;
+					if (tmp)
+						UnlockPage(tmp);
 				}
 				goto retry;
 			}
@@ -862,7 +862,7 @@ static inline void establish_pte(struct vm_area_struct * vma, unsigned long addr
 /*
  * We hold the mm semaphore for reading and vma->vm_mm->page_table_lock
  */
-static inline void break_cow(struct vm_area_struct * vma, struct page *	old_page, struct page * new_page, unsigned long address, 
+static inline void break_cow(struct vm_area_struct * vma, struct page * new_page, unsigned long address, 
 		pte_t *page_table)
 {
 	flush_page_to_ram(new_page);
@@ -935,12 +935,14 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
 	/*
 	 * Ok, we need to copy. Oh, well..
 	 */
+	page_cache_get(old_page);
 	spin_unlock(&mm->page_table_lock);
 
 	new_page = alloc_page(GFP_HIGHUSER);
 	if (!new_page)
 		goto no_mem;
 	copy_cow_page(old_page,new_page,address);
+	page_cache_release(old_page);
 
 	/*
 	 * Re-check the pte - we dropped the lock
@@ -949,7 +951,7 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
 	if (pte_same(*page_table, pte)) {
 		if (PageReserved(old_page))
 			++mm->rss;
-		break_cow(vma, old_page, new_page, address, page_table);
+		break_cow(vma, new_page, address, page_table);
 
 		/* Free the old page.. */
 		new_page = old_page;
@@ -961,6 +963,7 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
 	printk("do_wp_page: bogus page at address %08lx (page 0x%lx)\n",address,(unsigned long)old_page);
 	return -1;
 no_mem:
+	page_cache_release(old_page);
 	spin_lock(&mm->page_table_lock);
 	return -1;
 }

mm/swap.c

@@ -74,31 +74,6 @@ pager_daemon_t pager_daemon = {
 	8,	/* do swap I/O in clusters of this size */
 };
 
-/**
- * age_page_{up,down} -	page aging helper functions
- * @page - the page we want to age
- * @nolock - are we already holding the pagelist_lru_lock?
- *
- * If the page is on one of the lists (active, inactive_dirty or
- * inactive_clean), we will grab the pagelist_lru_lock as needed.
- * If you're already holding the lock, call this function with the
- * nolock argument non-zero.
- */
-void age_page_up_nolock(struct page * page)
-{
-	/*
-	 * We're dealing with an inactive page, move the page
-	 * to the active list.
-	 */
-	if (!page->age)
-		activate_page_nolock(page);
-
-	/* The actual page aging bit */
-	page->age += PAGE_AGE_ADV;
-	if (page->age > PAGE_AGE_MAX)
-		page->age = PAGE_AGE_MAX;
-}
-
 /*
  * We use this (minimal) function in the case where we
  * know we can't deactivate the page (yet).
@@ -121,21 +96,6 @@ void age_page_down_nolock(struct page * page)
 	       deactivate_page_nolock(page);
 }
 
-void age_page_up(struct page * page)
-{
-	/*
-	 * We're dealing with an inactive page, move the page
-	 * to the active list.
-	 */
-	if (!page->age)
-		activate_page(page);
-
-	/* The actual page aging bit */
-	page->age += PAGE_AGE_ADV;
-	if (page->age > PAGE_AGE_MAX)
-		page->age = PAGE_AGE_MAX;
-}
-
 void age_page_down(struct page * page)
 {
 	/* The actual page aging bit */

mm/vmscan.c

@@ -678,6 +678,13 @@ int page_launder(int gfp_mask, int sync)
 	return ret;
 }
 
+static inline void age_page_up(struct page *page)
+{
+	unsigned age = page->age + PAGE_AGE_ADV;
+	if (age > PAGE_AGE_MAX)
+		age = PAGE_AGE_MAX;
+	page->age = age;
+}
 
 
 /**
@@ -728,7 +735,7 @@ int refill_inactive_scan(zone_t *zone, unsigned int priority, int target)
 
 		/* Do aging on the pages. */
 		if (PageTestandClearReferenced(page)) {
-			age_page_up_nolock(page);
+			age_page_up(page);
 			page_active = 1;
 		} else {
 			age_page_down_ageonly(page);