Merge bk://linux-scsi.bkbits.net/scsi-dledford

into home.transmeta.com:/home/torvalds/v2.5/linux

drivers/scsi/aic7xxx_old.c

@@ -6736,12 +6736,12 @@ aic7xxx_device_queue_depth(struct aic7xxx_host *p, Scsi_Device *device)
  *   prepare for this device to go away
  *-F*************************************************************************/
 static void
-aic7xxx_slave_destroy(Scsi_Device *sdpnt)
+aic7xxx_slave_destroy(Scsi_Device *SDptr)
 {
-  struct aic_dev_data *aic_dev = sdpnt->hostdata;
+  struct aic_dev_data *aic_dev = SDptr->hostdata;
 
   list_del(&aic_dev->list);
-  sdpnt->hostdata = NULL;
+  SDptr->hostdata = NULL;
   kfree(aic_dev);
   return;
 }
@@ -6756,16 +6756,16 @@ aic7xxx_slave_destroy(Scsi_Device *sdpnt)
  *   depths, allocate command structs, etc.
  *-F*************************************************************************/
 static int
-aic7xxx_slave_configure(Scsi_Device *sdpnt)
+aic7xxx_slave_configure(Scsi_Device *SDptr)
 {
-  struct aic7xxx_host *p = (struct aic7xxx_host *) sdpnt->host->hostdata;
+  struct aic7xxx_host *p = (struct aic7xxx_host *) SDptr->host->hostdata;
   struct aic_dev_data *aic_dev;
   int scbnum;
 
-  aic_dev = (struct aic_dev_data *)sdpnt->hostdata;
+  aic_dev = (struct aic_dev_data *)SDptr->hostdata;
 
   aic7xxx_init_transinfo(p, aic_dev);
-  aic7xxx_device_queue_depth(p, sdpnt);
+  aic7xxx_device_queue_depth(p, SDptr);
   if(list_empty(&aic_dev->list))
     list_add_tail(&aic_dev->list, &p->aic_devs);
 
@@ -9024,7 +9024,6 @@ aic7xxx_detect(Scsi_Host_Template *template)
 
   template->proc_name = "aic7xxx";
   template->sg_tablesize = AIC7XXX_MAX_SG;
-  template->max_sectors = 2048;
 
 
 #ifdef CONFIG_PCI
@@ -9246,12 +9245,22 @@ aic7xxx_detect(Scsi_Host_Template *template)
 	    {
               /* duplicate PCI entry, skip it */
 	      kfree(temp_p);
-	      temp_p = NULL;
+              continue;
 	    }
 	    current_p = current_p->next;
 	  }
-	  if ( temp_p == NULL )
+          if(pci_request_regions(temp_p->pdev, "aic7xxx"))
+          {
+            printk("aic7xxx: <%s> at PCI %d/%d/%d\n", 
+              board_names[aic_pdevs[i].board_name_index],
+              temp_p->pci_bus,
+              PCI_SLOT(temp_p->pci_device_fn),
+              PCI_FUNC(temp_p->pci_device_fn));
+            printk("aic7xxx: I/O ports already in use, ignoring.\n");
+            kfree(temp_p);
             continue;
+          }
+
           if (aic7xxx_verbose & VERBOSE_PROBE2)
             printk("aic7xxx: <%s> at PCI %d/%d\n", 
               board_names[aic_pdevs[i].board_name_index],
@@ -9283,20 +9292,6 @@ aic7xxx_detect(Scsi_Host_Template *template)
           pci_write_config_dword(pdev, DEVCONFIG, devconfig);
 #endif /* AIC7XXX_STRICT_PCI_SETUP */
 
-          if(temp_p->base && !request_region(temp_p->base, MAXREG - MINREG,
-				  "aic7xxx"))
-          {
-            printk("aic7xxx: <%s> at PCI %d/%d/%d\n", 
-              board_names[aic_pdevs[i].board_name_index],
-              temp_p->pci_bus,
-              PCI_SLOT(temp_p->pci_device_fn),
-              PCI_FUNC(temp_p->pci_device_fn));
-            printk("aic7xxx: I/O ports already in use, ignoring.\n");
-            kfree(temp_p);
-            temp_p = NULL;
-            continue;
-          }
-
           temp_p->unpause = INTEN;
           temp_p->pause = temp_p->unpause | PAUSE;
           if ( ((temp_p->base == 0) &&
@@ -9309,9 +9304,7 @@ aic7xxx_detect(Scsi_Host_Template *template)
               PCI_SLOT(temp_p->pci_device_fn),
               PCI_FUNC(temp_p->pci_device_fn));
             printk("aic7xxx: Controller disabled by BIOS, ignoring.\n");
-            kfree(temp_p);
-            temp_p = NULL;
-            continue;
+            goto skip_pci_controller;
           }
 
 #ifdef MMAPIO
@@ -9353,9 +9346,7 @@ aic7xxx_detect(Scsi_Host_Template *template)
                     PCI_SLOT(temp_p->pci_device_fn),
                     PCI_FUNC(temp_p->pci_device_fn));
                   printk("aic7xxx: Controller disabled by BIOS, ignoring.\n");
-                  kfree(temp_p);
-                  temp_p = NULL;
-                  continue;
+                  goto skip_pci_controller;
                 }
               }
             }
@@ -9398,10 +9389,7 @@ aic7xxx_detect(Scsi_Host_Template *template)
 
           if (aic7xxx_chip_reset(temp_p) == -1)
           {
-            release_region(temp_p->base, MAXREG - MINREG);
-            kfree(temp_p);
-            temp_p = NULL;
-            continue;
+            goto skip_pci_controller;
           }
           /*
            * Very quickly put the term setting back into the register since
@@ -9687,6 +9675,10 @@ aic7xxx_detect(Scsi_Host_Template *template)
           }
           temp_p->next = NULL;
           found++;
+	  continue;
+skip_pci_controller:
+	  pci_release_regions(temp_p->pdev);
+	  kfree(temp_p);
         }  /* Found an Adaptec PCI device. */
         else /* Well, we found one, but we couldn't get any memory */
         {
@@ -10969,14 +10961,16 @@ aic7xxx_release(struct Scsi_Host *host)
 
   if(p->irq)
     free_irq(p->irq, p);
-  if(p->base)
-    release_region(p->base, MAXREG - MINREG);
 #ifdef MMAPIO
   if(p->maddr)
   {
     iounmap((void *) (((unsigned long) p->maddr) & PAGE_MASK));
   }
 #endif /* MMAPIO */
+  if(!p->pdev)
+    release_region(p->base, MAXREG - MINREG);
+  else
+    pci_release_regions(p->pdev);
   prev = NULL;
   next = first_aic7xxx;
   while(next != NULL)

drivers/scsi/aic7xxx_old/aic7xxx.h

@@ -45,6 +45,7 @@
 	can_queue: 255,		/* max simultaneous cmds      */\
 	this_id: -1,		/* scsi id of host adapter    */\
 	sg_tablesize: 0,	/* max scatter-gather cmds    */\
+	max_sectors: 2048,	/* max physical sectors in 1 cmd */\
 	cmd_per_lun: 3,		/* cmds per lun (linked cmds) */\
 	present: 0,		/* number of 7xxx's present   */\
 	unchecked_isa_dma: 0,	/* no memory DMA restrictions */\

drivers/scsi/scsi.c

@@ -160,15 +160,13 @@ void scsi_build_commandblocks(Scsi_Device * SDpnt);
  */
 void  scsi_initialize_queue(Scsi_Device * SDpnt, struct Scsi_Host * SHpnt)
 {
-	request_queue_t *q = &SDpnt->request_queue;
+	request_queue_t *q = SDpnt->request_queue;
 
 	/*
 	 * tell block layer about assigned host_lock for this host
 	 */
 	blk_init_queue(q, scsi_request_fn, SHpnt->host_lock);
 
-	q->queuedata = (void *) SDpnt;
-
 	/* Hardware imposed limit. */
 	blk_queue_max_hw_segments(q, SHpnt->sg_tablesize);
 
@@ -223,7 +221,7 @@ __setup("scsi_logging=", scsi_logging_setup);
 static void scsi_wait_done(Scsi_Cmnd * SCpnt)
 {
 	struct request *req = SCpnt->request;
-        struct request_queue *q = &SCpnt->device->request_queue;
+        struct request_queue *q = SCpnt->device->request_queue;
         unsigned long flags;
 
         ASSERT_LOCK(q->queue_lock, 0);
@@ -656,17 +654,14 @@ int scsi_mlqueue_insert(Scsi_Cmnd * cmd, int reason)
  */
 void scsi_release_command(Scsi_Cmnd * SCpnt)
 {
-        request_queue_t *q = &SCpnt->device->request_queue;
-
         __scsi_release_command(SCpnt);
-
         /*
          * Finally, hit the queue request function to make sure that
          * the device is actually busy if there are requests present.
          * This won't block - if the device cannot take any more, life
          * will go on.  
          */
-        scsi_queue_next_request(q, NULL);                
+        scsi_queue_next_request(SCpnt->device->request_queue, NULL);
 }
 
 /*
@@ -810,13 +805,12 @@ void scsi_wait_req (Scsi_Request * SRpnt, const void *cmnd ,
  		  int timeout, int retries)
 {
 	DECLARE_COMPLETION(wait);
-	request_queue_t *q = &SRpnt->sr_device->request_queue;
 	
 	SRpnt->sr_request->waiting = &wait;
 	SRpnt->sr_request->rq_status = RQ_SCSI_BUSY;
 	scsi_do_req (SRpnt, (void *) cmnd,
 		buffer, bufflen, scsi_wait_done, timeout, retries);
-	generic_unplug_device(q);
+	generic_unplug_device(SRpnt->sr_device->request_queue);
 	wait_for_completion(&wait);
 	SRpnt->sr_request->waiting = NULL;
 	if( SRpnt->sr_command != NULL )
@@ -1912,10 +1906,8 @@ void scsi_device_put(struct scsi_device *sdev)
  */
 int scsi_slave_attach(struct scsi_device *sdev)
 {
+	/* all this code is now handled elsewhere 
 	if (sdev->attached++ == 0) {
-		/*
-		 * No one was attached.
-		 */
 		scsi_build_commandblocks(sdev);
 		if (sdev->current_queue_depth == 0) {
 			printk(KERN_ERR "scsi: Allocation failure during"
@@ -1935,6 +1927,8 @@ int scsi_slave_attach(struct scsi_device *sdev)
 			scsi_adjust_queue_depth(sdev, 0,
 						sdev->host->cmd_per_lun);
 	}
+		 */
+	sdev->attached++;
 	return 0;
 }
 
@@ -1950,9 +1944,12 @@ int scsi_slave_attach(struct scsi_device *sdev)
  */
 void scsi_slave_detach(struct scsi_device *sdev)
 {
+	/*
 	if (--sdev->attached == 0) {
 		scsi_release_commandblocks(sdev);
 	}
+	*/
+	sdev->attached--;
 }
 /*
  * This entry point should be called by a loadable module if it is trying

drivers/scsi/scsi.h

@@ -569,14 +569,12 @@ struct scsi_device {
 	/*
 	 * This information is private to the scsi mid-layer.
 	 */
-	struct scsi_device *next;	/* Used for linked list */
-	struct scsi_device *prev;	/* Used for linked list */
 	struct list_head    siblings;   /* list of all devices on this host */
 	struct list_head    same_target_siblings; /* just the devices sharing same target id */
 	wait_queue_head_t   scpnt_wait;	/* Used to wait if
 					   device is busy */
 	struct Scsi_Host *host;
-	request_queue_t request_queue;
+	request_queue_t *request_queue;
         atomic_t                device_active; /* commands checked out for device */
 	volatile unsigned short device_busy;	/* commands actually active on low-level */
 	struct list_head free_cmnds;    /* list of available Scsi_Cmnd structs */
@@ -894,11 +892,9 @@ extern int scsi_reset_provider(Scsi_Device *, int);
  *	would be adjustable from 0 to depth.
  **/
 static inline void scsi_activate_tcq(Scsi_Device *SDpnt, int depth) {
-        request_queue_t *q = &SDpnt->request_queue;
-
         if(SDpnt->tagged_supported) {
-		if(!blk_queue_tagged(q))
-			blk_queue_init_tags(q, depth);
+		if(!blk_queue_tagged(SDpnt->request_queue))
+			blk_queue_init_tags(SDpnt->request_queue, depth);
 		scsi_adjust_queue_depth(SDpnt, MSG_ORDERED_TAG, depth);
         }
 }
@@ -908,10 +904,8 @@ static inline void scsi_activate_tcq(Scsi_Device *SDpnt, int depth) {
  * @SDpnt:	device to turn off TCQ for
  **/
 static inline void scsi_deactivate_tcq(Scsi_Device *SDpnt, int depth) {
-	request_queue_t *q = &SDpnt->request_queue;
-
-	if(blk_queue_tagged(q))
-		blk_queue_free_tags(q);
+	if(blk_queue_tagged(SDpnt->request_queue))
+		blk_queue_free_tags(SDpnt->request_queue);
 	scsi_adjust_queue_depth(SDpnt, 0, depth);
 }
 
@@ -957,7 +951,7 @@ static inline Scsi_Cmnd *scsi_find_tag(Scsi_Device *SDpnt, int tag) {
                 /* single command, look in space */
                 return SDpnt->current_cmnd;
 
-        req = blk_queue_find_tag(&SDpnt->request_queue, tag);
+        req = blk_queue_find_tag(SDpnt->request_queue, tag);
 
         if(req == NULL)
                 return NULL;

drivers/scsi/scsi_error.c

@@ -1487,7 +1487,7 @@ static void scsi_restart_operations(struct Scsi_Host *shost)
 			break;
 		}
 
-		__blk_run_queue(&sdev->request_queue);
+		__blk_run_queue(sdev->request_queue);
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 }

drivers/scsi/scsi_lib.c

@@ -57,9 +57,8 @@ struct scsi_host_sg_pool scsi_sg_pools[SG_MEMPOOL_NR] = {
  */
 int scsi_insert_special_cmd(Scsi_Cmnd * SCpnt, int at_head)
 {
-	request_queue_t *q = &SCpnt->device->request_queue;
-
-	blk_insert_request(q, SCpnt->request, at_head, SCpnt);
+	blk_insert_request(SCpnt->device->request_queue, SCpnt->request,
+		       	   at_head, SCpnt);
 	return 0;
 }
 
@@ -85,16 +84,13 @@ int scsi_insert_special_cmd(Scsi_Cmnd * SCpnt, int at_head)
  */
 int scsi_insert_special_req(Scsi_Request * SRpnt, int at_head)
 {
-	request_queue_t *q = &SRpnt->sr_device->request_queue;
-
 	/* This is used to insert SRpnt specials.  Because users of
 	 * this function are apt to reuse requests with no modification,
 	 * we have to sanitise the request flags here
 	 */
-
 	SRpnt->sr_request->flags &= ~REQ_DONTPREP;
-
-	blk_insert_request(q, SRpnt->sr_request, at_head, SRpnt);
+	blk_insert_request(SRpnt->sr_device->request_queue, SRpnt->sr_request,
+		       	   at_head, SRpnt);
 	return 0;
 }
 
@@ -215,7 +211,7 @@ void scsi_queue_next_request(request_queue_t * q, Scsi_Cmnd * SCpnt)
 {
 	int all_clear;
 	unsigned long flags;
-	Scsi_Device *SDpnt;
+	Scsi_Device *SDpnt, *SDpnt2;
 	struct Scsi_Host *SHpnt;
 
 	ASSERT_LOCK(q->queue_lock, 0);
@@ -256,17 +252,17 @@ void scsi_queue_next_request(request_queue_t * q, Scsi_Cmnd * SCpnt)
 	 * with special case code, then spin off separate versions and
 	 * use function pointers to pick the right one.
 	 */
-	if (SDpnt->single_lun && blk_queue_empty(q) && SDpnt->device_busy ==0) {
-		list_for_each_entry(SDpnt, &SHpnt->my_devices, siblings) {
-			if (((SHpnt->can_queue > 0)
-			     && (SHpnt->host_busy >= SHpnt->can_queue))
-			    || (SHpnt->host_blocked)
-			    || (SHpnt->host_self_blocked)
-			    || (SDpnt->device_blocked)) {
+	if (SDpnt->single_lun && blk_queue_empty(q) && SDpnt->device_busy ==0 &&
+			!SHpnt->host_blocked && !SHpnt->host_self_blocked &&
+			!((SHpnt->can_queue > 0) && (SHpnt->host_busy >=
+				       		     SHpnt->can_queue))) {
+		list_for_each_entry(SDpnt2, &SDpnt->same_target_siblings,
+			       same_target_siblings) {
+			if (!SDpnt2->device_blocked &&
+			    !blk_queue_empty(SDpnt2->request_queue)) {
+				__blk_run_queue(SDpnt2->request_queue);
 				break;
 			}
-
-			__blk_run_queue(&SDpnt->request_queue);
 		}
 	}
 
@@ -289,7 +285,7 @@ void scsi_queue_next_request(request_queue_t * q, Scsi_Cmnd * SCpnt)
 			if (SDpnt->device_blocked || !SDpnt->starved) {
 				continue;
 			}
-			__blk_run_queue(&SDpnt->request_queue);
+			__blk_run_queue(SDpnt->request_queue);
 			all_clear = 0;
 		}
 		if (SDpnt == NULL && all_clear) {
@@ -327,7 +323,7 @@ static Scsi_Cmnd *scsi_end_request(Scsi_Cmnd * SCpnt,
 				     int sectors,
 				     int requeue)
 {
-	request_queue_t *q = &SCpnt->device->request_queue;
+	request_queue_t *q = SCpnt->device->request_queue;
 	struct request *req = SCpnt->request;
 	unsigned long flags;
 
@@ -497,7 +493,7 @@ void scsi_io_completion(Scsi_Cmnd * SCpnt, int good_sectors,
 {
 	int result = SCpnt->result;
 	int this_count = SCpnt->bufflen >> 9;
-	request_queue_t *q = &SCpnt->device->request_queue;
+	request_queue_t *q = SCpnt->device->request_queue;
 	struct request *req = SCpnt->request;
 
 	/*
@@ -1094,7 +1090,7 @@ void scsi_unblock_requests(struct Scsi_Host * SHpnt)
 	SHpnt->host_self_blocked = FALSE;
 	/* Now that we are unblocked, try to start the queues. */
 	list_for_each_entry(SDloop, &SHpnt->my_devices, siblings)
-		scsi_queue_next_request(&SDloop->request_queue, NULL);
+		scsi_queue_next_request(SDloop->request_queue, NULL);
 }
 
 /*

drivers/scsi/sd.c

@@ -301,10 +301,10 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
 	
 	if (block > 0xffffffff) {
 		SCpnt->cmnd[0] += READ_16 - READ_6;
-		SCpnt->cmnd[2] = (unsigned char) (block >> 56) & 0xff;
-		SCpnt->cmnd[3] = (unsigned char) (block >> 48) & 0xff;
-		SCpnt->cmnd[4] = (unsigned char) (block >> 40) & 0xff;
-		SCpnt->cmnd[5] = (unsigned char) (block >> 32) & 0xff;
+		SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
+		SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
+		SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
+		SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
 		SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
 		SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
 		SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
@@ -931,7 +931,7 @@ sd_read_capacity(struct scsi_disk *sdkp, char *diskname,
 		if (longrc) {
 			memset((void *) cmd, 0, 16);
 			cmd[0] = SERVICE_ACTION_IN;
-			cmd[1] = 0x10; /* READ CAPACITY (16) */
+			cmd[1] = SAI_READ_CAPACITY_16;
 			cmd[13] = 12;
 			memset((void *) buffer, 0, 12);
 		} else {
@@ -1003,20 +1003,24 @@ sd_read_capacity(struct scsi_disk *sdkp, char *diskname,
 			(buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
 		if (buffer[0] == 0xff && buffer[1] == 0xff &&
 		    buffer[2] == 0xff && buffer[3] == 0xff) {
+			if(sizeof(sdkp->capacity) > 4) {
 				printk(KERN_NOTICE "%s : very big device. try to use"
 				       " READ CAPACITY(16).\n", diskname);
 				longrc = 1;
 				goto repeat;
+			} else {
+				printk(KERN_ERR "%s: too big for kernel.  Assuming maximum 2Tb\n", diskname);
+			}
 		}
 		sdkp->capacity = 1 + (((sector_t)buffer[0] << 24) |
 			(buffer[1] << 16) |
 			(buffer[2] << 8) |
 			buffer[3]);			
 	} else {
-		sdkp->capacity = 1 + (((sector_t)buffer[0] << 56) |
-			((sector_t)buffer[1] << 48) |
-			((sector_t)buffer[2] << 40) |
-			((sector_t)buffer[3] << 32) |
+		sdkp->capacity = 1 + (((u64)buffer[0] << 56) |
+			((u64)buffer[1] << 48) |
+			((u64)buffer[2] << 40) |
+			((u64)buffer[3] << 32) |
 			((sector_t)buffer[4] << 24) |
 			((sector_t)buffer[5] << 16) |
 			((sector_t)buffer[6] << 8)  |
@@ -1056,7 +1060,7 @@ sd_read_capacity(struct scsi_disk *sdkp, char *diskname,
 		 */
 		int hard_sector = sector_size;
 		sector_t sz = sdkp->capacity * (hard_sector/256);
-		request_queue_t *queue = &sdp->request_queue;
+		request_queue_t *queue = sdp->request_queue;
 		sector_t mb;
 
 		blk_queue_hardsect_size(queue, hard_sector);
@@ -1291,7 +1295,7 @@ static int sd_attach(struct scsi_device * sdp)
 	if (sdp->removable)
 		gd->flags |= GENHD_FL_REMOVABLE;
 	gd->private_data = &sdkp->driver;
-	gd->queue = &sdkp->device->request_queue;
+	gd->queue = sdkp->device->request_queue;
 
 	sd_devlist_insert(sdkp);
 	set_capacity(gd, sdkp->capacity);

drivers/scsi/sg.c

@@ -695,7 +695,7 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
 	}
 
 	srp->my_cmdp = SRpnt;
-	q = &SRpnt->sr_device->request_queue;
+	q = SRpnt->sr_device->request_queue;
 	SRpnt->sr_request->rq_disk = sdp->disk;
 	SRpnt->sr_sense_buffer[0] = 0;
 	SRpnt->sr_cmd_len = hp->cmd_len;

drivers/scsi/sr.c

@@ -563,7 +563,7 @@ static int sr_attach(struct scsi_device *sdev)
 	register_cdrom(&cd->cdi);
 	set_capacity(disk, cd->capacity);
 	disk->private_data = &cd->driver;
-	disk->queue = &sdev->request_queue;
+	disk->queue = sdev->request_queue;
 
 	add_disk(disk);
 	sr_devlist_insert(cd);
@@ -672,7 +672,7 @@ static void get_sectorsize(struct scsi_cd *cd)
 		set_capacity(cd->disk, cd->capacity);
 	}
 
-	queue = &cd->device->request_queue;
+	queue = cd->device->request_queue;
 	blk_queue_hardsect_size(queue, sector_size);
 out:
 	kfree(buffer);

include/scsi/scsi.h

@@ -99,6 +99,8 @@ extern const unsigned char scsi_command_size[8];
 #define READ_16               0x88
 #define WRITE_16              0x8a
 #define SERVICE_ACTION_IN     0x9e
+/* values for service action in */
+#define	SAI_READ_CAPACITY_16  0x10
 
 
 /*