aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/block/cciss.c611
-rw-r--r--drivers/block/cciss.h2
-rw-r--r--drivers/block/cciss_scsi.c591
3 files changed, 592 insertions, 612 deletions
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 2abe6df9445e..70ad24f3604f 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -191,17 +191,17 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time, int via_ioctl);
191static int deregister_disk(ctlr_info_t *h, int drv_index, 191static int deregister_disk(ctlr_info_t *h, int drv_index,
192 int clear_all, int via_ioctl); 192 int clear_all, int via_ioctl);
193 193
194static void cciss_read_capacity(int ctlr, int logvol, 194static void cciss_read_capacity(ctlr_info_t *h, int logvol,
195 sector_t *total_size, unsigned int *block_size); 195 sector_t *total_size, unsigned int *block_size);
196static void cciss_read_capacity_16(int ctlr, int logvol, 196static void cciss_read_capacity_16(ctlr_info_t *h, int logvol,
197 sector_t *total_size, unsigned int *block_size); 197 sector_t *total_size, unsigned int *block_size);
198static void cciss_geometry_inquiry(int ctlr, int logvol, 198static void cciss_geometry_inquiry(ctlr_info_t *h, int logvol,
199 sector_t total_size, 199 sector_t total_size,
200 unsigned int block_size, InquiryData_struct *inq_buff, 200 unsigned int block_size, InquiryData_struct *inq_buff,
201 drive_info_struct *drv); 201 drive_info_struct *drv);
202static void __devinit cciss_interrupt_mode(ctlr_info_t *); 202static void __devinit cciss_interrupt_mode(ctlr_info_t *);
203static void start_io(ctlr_info_t *h); 203static void start_io(ctlr_info_t *h);
204static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size, 204static int sendcmd_withirq(ctlr_info_t *h, __u8 cmd, void *buff, size_t size,
205 __u8 page_code, unsigned char scsi3addr[], 205 __u8 page_code, unsigned char scsi3addr[],
206 int cmd_type); 206 int cmd_type);
207static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c, 207static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
@@ -229,9 +229,9 @@ static void calc_bucket_map(int *bucket, int num_buckets, int nsgs,
229static void cciss_put_controller_into_performant_mode(ctlr_info_t *h); 229static void cciss_put_controller_into_performant_mode(ctlr_info_t *h);
230 230
231#ifdef CONFIG_PROC_FS 231#ifdef CONFIG_PROC_FS
232static void cciss_procinit(int i); 232static void cciss_procinit(ctlr_info_t *h);
233#else 233#else
234static void cciss_procinit(int i) 234static void cciss_procinit(ctlr_info_t *h)
235{ 235{
236} 236}
237#endif /* CONFIG_PROC_FS */ 237#endif /* CONFIG_PROC_FS */
@@ -416,26 +416,25 @@ static void cciss_seq_show_header(struct seq_file *seq)
416 h->maxQsinceinit, h->max_outstanding, h->maxSG); 416 h->maxQsinceinit, h->max_outstanding, h->maxSG);
417 417
418#ifdef CONFIG_CISS_SCSI_TAPE 418#ifdef CONFIG_CISS_SCSI_TAPE
419 cciss_seq_tape_report(seq, h->ctlr); 419 cciss_seq_tape_report(seq, h);
420#endif /* CONFIG_CISS_SCSI_TAPE */ 420#endif /* CONFIG_CISS_SCSI_TAPE */
421} 421}
422 422
423static void *cciss_seq_start(struct seq_file *seq, loff_t *pos) 423static void *cciss_seq_start(struct seq_file *seq, loff_t *pos)
424{ 424{
425 ctlr_info_t *h = seq->private; 425 ctlr_info_t *h = seq->private;
426 unsigned ctlr = h->ctlr;
427 unsigned long flags; 426 unsigned long flags;
428 427
429 /* prevent displaying bogus info during configuration 428 /* prevent displaying bogus info during configuration
430 * or deconfiguration of a logical volume 429 * or deconfiguration of a logical volume
431 */ 430 */
432 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 431 spin_lock_irqsave(&h->lock, flags);
433 if (h->busy_configuring) { 432 if (h->busy_configuring) {
434 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 433 spin_unlock_irqrestore(&h->lock, flags);
435 return ERR_PTR(-EBUSY); 434 return ERR_PTR(-EBUSY);
436 } 435 }
437 h->busy_configuring = 1; 436 h->busy_configuring = 1;
438 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 437 spin_unlock_irqrestore(&h->lock, flags);
439 438
440 if (*pos == 0) 439 if (*pos == 0)
441 cciss_seq_show_header(seq); 440 cciss_seq_show_header(seq);
@@ -543,7 +542,7 @@ cciss_proc_write(struct file *file, const char __user *buf,
543 struct seq_file *seq = file->private_data; 542 struct seq_file *seq = file->private_data;
544 ctlr_info_t *h = seq->private; 543 ctlr_info_t *h = seq->private;
545 544
546 err = cciss_engage_scsi(h->ctlr); 545 err = cciss_engage_scsi(h);
547 if (err == 0) 546 if (err == 0)
548 err = length; 547 err = length;
549 } else 548 } else
@@ -566,7 +565,7 @@ static const struct file_operations cciss_proc_fops = {
566 .write = cciss_proc_write, 565 .write = cciss_proc_write,
567}; 566};
568 567
569static void __devinit cciss_procinit(int i) 568static void __devinit cciss_procinit(ctlr_info_t *h)
570{ 569{
571 struct proc_dir_entry *pde; 570 struct proc_dir_entry *pde;
572 571
@@ -574,9 +573,9 @@ static void __devinit cciss_procinit(int i)
574 proc_cciss = proc_mkdir("driver/cciss", NULL); 573 proc_cciss = proc_mkdir("driver/cciss", NULL);
575 if (!proc_cciss) 574 if (!proc_cciss)
576 return; 575 return;
577 pde = proc_create_data(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP | 576 pde = proc_create_data(h->devname, S_IWUSR | S_IRUSR | S_IRGRP |
578 S_IROTH, proc_cciss, 577 S_IROTH, proc_cciss,
579 &cciss_proc_fops, hba[i]); 578 &cciss_proc_fops, h);
580} 579}
581#endif /* CONFIG_PROC_FS */ 580#endif /* CONFIG_PROC_FS */
582 581
@@ -609,12 +608,12 @@ static ssize_t dev_show_unique_id(struct device *dev,
609 unsigned long flags; 608 unsigned long flags;
610 int ret = 0; 609 int ret = 0;
611 610
612 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 611 spin_lock_irqsave(&h->lock, flags);
613 if (h->busy_configuring) 612 if (h->busy_configuring)
614 ret = -EBUSY; 613 ret = -EBUSY;
615 else 614 else
616 memcpy(sn, drv->serial_no, sizeof(sn)); 615 memcpy(sn, drv->serial_no, sizeof(sn));
617 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 616 spin_unlock_irqrestore(&h->lock, flags);
618 617
619 if (ret) 618 if (ret)
620 return ret; 619 return ret;
@@ -639,12 +638,12 @@ static ssize_t dev_show_vendor(struct device *dev,
639 unsigned long flags; 638 unsigned long flags;
640 int ret = 0; 639 int ret = 0;
641 640
642 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 641 spin_lock_irqsave(&h->lock, flags);
643 if (h->busy_configuring) 642 if (h->busy_configuring)
644 ret = -EBUSY; 643 ret = -EBUSY;
645 else 644 else
646 memcpy(vendor, drv->vendor, VENDOR_LEN + 1); 645 memcpy(vendor, drv->vendor, VENDOR_LEN + 1);
647 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 646 spin_unlock_irqrestore(&h->lock, flags);
648 647
649 if (ret) 648 if (ret)
650 return ret; 649 return ret;
@@ -663,12 +662,12 @@ static ssize_t dev_show_model(struct device *dev,
663 unsigned long flags; 662 unsigned long flags;
664 int ret = 0; 663 int ret = 0;
665 664
666 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 665 spin_lock_irqsave(&h->lock, flags);
667 if (h->busy_configuring) 666 if (h->busy_configuring)
668 ret = -EBUSY; 667 ret = -EBUSY;
669 else 668 else
670 memcpy(model, drv->model, MODEL_LEN + 1); 669 memcpy(model, drv->model, MODEL_LEN + 1);
671 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 670 spin_unlock_irqrestore(&h->lock, flags);
672 671
673 if (ret) 672 if (ret)
674 return ret; 673 return ret;
@@ -687,12 +686,12 @@ static ssize_t dev_show_rev(struct device *dev,
687 unsigned long flags; 686 unsigned long flags;
688 int ret = 0; 687 int ret = 0;
689 688
690 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 689 spin_lock_irqsave(&h->lock, flags);
691 if (h->busy_configuring) 690 if (h->busy_configuring)
692 ret = -EBUSY; 691 ret = -EBUSY;
693 else 692 else
694 memcpy(rev, drv->rev, REV_LEN + 1); 693 memcpy(rev, drv->rev, REV_LEN + 1);
695 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 694 spin_unlock_irqrestore(&h->lock, flags);
696 695
697 if (ret) 696 if (ret)
698 return ret; 697 return ret;
@@ -709,17 +708,17 @@ static ssize_t cciss_show_lunid(struct device *dev,
709 unsigned long flags; 708 unsigned long flags;
710 unsigned char lunid[8]; 709 unsigned char lunid[8];
711 710
712 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 711 spin_lock_irqsave(&h->lock, flags);
713 if (h->busy_configuring) { 712 if (h->busy_configuring) {
714 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 713 spin_unlock_irqrestore(&h->lock, flags);
715 return -EBUSY; 714 return -EBUSY;
716 } 715 }
717 if (!drv->heads) { 716 if (!drv->heads) {
718 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 717 spin_unlock_irqrestore(&h->lock, flags);
719 return -ENOTTY; 718 return -ENOTTY;
720 } 719 }
721 memcpy(lunid, drv->LunID, sizeof(lunid)); 720 memcpy(lunid, drv->LunID, sizeof(lunid));
722 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 721 spin_unlock_irqrestore(&h->lock, flags);
723 return snprintf(buf, 20, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 722 return snprintf(buf, 20, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
724 lunid[0], lunid[1], lunid[2], lunid[3], 723 lunid[0], lunid[1], lunid[2], lunid[3],
725 lunid[4], lunid[5], lunid[6], lunid[7]); 724 lunid[4], lunid[5], lunid[6], lunid[7]);
@@ -734,13 +733,13 @@ static ssize_t cciss_show_raid_level(struct device *dev,
734 int raid; 733 int raid;
735 unsigned long flags; 734 unsigned long flags;
736 735
737 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 736 spin_lock_irqsave(&h->lock, flags);
738 if (h->busy_configuring) { 737 if (h->busy_configuring) {
739 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 738 spin_unlock_irqrestore(&h->lock, flags);
740 return -EBUSY; 739 return -EBUSY;
741 } 740 }
742 raid = drv->raid_level; 741 raid = drv->raid_level;
743 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 742 spin_unlock_irqrestore(&h->lock, flags);
744 if (raid < 0 || raid > RAID_UNKNOWN) 743 if (raid < 0 || raid > RAID_UNKNOWN)
745 raid = RAID_UNKNOWN; 744 raid = RAID_UNKNOWN;
746 745
@@ -757,13 +756,13 @@ static ssize_t cciss_show_usage_count(struct device *dev,
757 unsigned long flags; 756 unsigned long flags;
758 int count; 757 int count;
759 758
760 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 759 spin_lock_irqsave(&h->lock, flags);
761 if (h->busy_configuring) { 760 if (h->busy_configuring) {
762 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 761 spin_unlock_irqrestore(&h->lock, flags);
763 return -EBUSY; 762 return -EBUSY;
764 } 763 }
765 count = drv->usage_count; 764 count = drv->usage_count;
766 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 765 spin_unlock_irqrestore(&h->lock, flags);
767 return snprintf(buf, 20, "%d\n", count); 766 return snprintf(buf, 20, "%d\n", count);
768} 767}
769static DEVICE_ATTR(usage_count, S_IRUGO, cciss_show_usage_count, NULL); 768static DEVICE_ATTR(usage_count, S_IRUGO, cciss_show_usage_count, NULL);
@@ -1012,7 +1011,7 @@ static inline drive_info_struct *get_drv(struct gendisk *disk)
1012 */ 1011 */
1013static int cciss_open(struct block_device *bdev, fmode_t mode) 1012static int cciss_open(struct block_device *bdev, fmode_t mode)
1014{ 1013{
1015 ctlr_info_t *host = get_host(bdev->bd_disk); 1014 ctlr_info_t *h = get_host(bdev->bd_disk);
1016 drive_info_struct *drv = get_drv(bdev->bd_disk); 1015 drive_info_struct *drv = get_drv(bdev->bd_disk);
1017 1016
1018#ifdef CCISS_DEBUG 1017#ifdef CCISS_DEBUG
@@ -1044,7 +1043,7 @@ static int cciss_open(struct block_device *bdev, fmode_t mode)
1044 return -EPERM; 1043 return -EPERM;
1045 } 1044 }
1046 drv->usage_count++; 1045 drv->usage_count++;
1047 host->usage_count++; 1046 h->usage_count++;
1048 return 0; 1047 return 0;
1049} 1048}
1050 1049
@@ -1064,11 +1063,11 @@ static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode)
1064 */ 1063 */
1065static int cciss_release(struct gendisk *disk, fmode_t mode) 1064static int cciss_release(struct gendisk *disk, fmode_t mode)
1066{ 1065{
1067 ctlr_info_t *host; 1066 ctlr_info_t *h;
1068 drive_info_struct *drv; 1067 drive_info_struct *drv;
1069 1068
1070 lock_kernel(); 1069 lock_kernel();
1071 host = get_host(disk); 1070 h = get_host(disk);
1072 drv = get_drv(disk); 1071 drv = get_drv(disk);
1073 1072
1074#ifdef CCISS_DEBUG 1073#ifdef CCISS_DEBUG
@@ -1076,7 +1075,7 @@ static int cciss_release(struct gendisk *disk, fmode_t mode)
1076#endif /* CCISS_DEBUG */ 1075#endif /* CCISS_DEBUG */
1077 1076
1078 drv->usage_count--; 1077 drv->usage_count--;
1079 host->usage_count--; 1078 h->usage_count--;
1080 unlock_kernel(); 1079 unlock_kernel();
1081 return 0; 1080 return 0;
1082} 1081}
@@ -1223,11 +1222,11 @@ static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1223 return 0; 1222 return 0;
1224} 1223}
1225 1224
1226static void check_ioctl_unit_attention(ctlr_info_t *host, CommandList_struct *c) 1225static void check_ioctl_unit_attention(ctlr_info_t *h, CommandList_struct *c)
1227{ 1226{
1228 if (c->err_info->CommandStatus == CMD_TARGET_STATUS && 1227 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1229 c->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) 1228 c->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION)
1230 (void)check_for_unit_attention(host, c); 1229 (void)check_for_unit_attention(h, c);
1231} 1230}
1232/* 1231/*
1233 * ioctl 1232 * ioctl
@@ -1236,9 +1235,8 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1236 unsigned int cmd, unsigned long arg) 1235 unsigned int cmd, unsigned long arg)
1237{ 1236{
1238 struct gendisk *disk = bdev->bd_disk; 1237 struct gendisk *disk = bdev->bd_disk;
1239 ctlr_info_t *host = get_host(disk); 1238 ctlr_info_t *h = get_host(disk);
1240 drive_info_struct *drv = get_drv(disk); 1239 drive_info_struct *drv = get_drv(disk);
1241 int ctlr = host->ctlr;
1242 void __user *argp = (void __user *)arg; 1240 void __user *argp = (void __user *)arg;
1243 1241
1244#ifdef CCISS_DEBUG 1242#ifdef CCISS_DEBUG
@@ -1252,10 +1250,10 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1252 1250
1253 if (!arg) 1251 if (!arg)
1254 return -EINVAL; 1252 return -EINVAL;
1255 pciinfo.domain = pci_domain_nr(host->pdev->bus); 1253 pciinfo.domain = pci_domain_nr(h->pdev->bus);
1256 pciinfo.bus = host->pdev->bus->number; 1254 pciinfo.bus = h->pdev->bus->number;
1257 pciinfo.dev_fn = host->pdev->devfn; 1255 pciinfo.dev_fn = h->pdev->devfn;
1258 pciinfo.board_id = host->board_id; 1256 pciinfo.board_id = h->board_id;
1259 if (copy_to_user 1257 if (copy_to_user
1260 (argp, &pciinfo, sizeof(cciss_pci_info_struct))) 1258 (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
1261 return -EFAULT; 1259 return -EFAULT;
@@ -1267,9 +1265,9 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1267 if (!arg) 1265 if (!arg)
1268 return -EINVAL; 1266 return -EINVAL;
1269 intinfo.delay = 1267 intinfo.delay =
1270 readl(&host->cfgtable->HostWrite.CoalIntDelay); 1268 readl(&h->cfgtable->HostWrite.CoalIntDelay);
1271 intinfo.count = 1269 intinfo.count =
1272 readl(&host->cfgtable->HostWrite.CoalIntCount); 1270 readl(&h->cfgtable->HostWrite.CoalIntCount);
1273 if (copy_to_user 1271 if (copy_to_user
1274 (argp, &intinfo, sizeof(cciss_coalint_struct))) 1272 (argp, &intinfo, sizeof(cciss_coalint_struct)))
1275 return -EFAULT; 1273 return -EFAULT;
@@ -1293,22 +1291,22 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1293// printk("cciss_ioctl: delay and count cannot be 0\n"); 1291// printk("cciss_ioctl: delay and count cannot be 0\n");
1294 return -EINVAL; 1292 return -EINVAL;
1295 } 1293 }
1296 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1294 spin_lock_irqsave(&h->lock, flags);
1297 /* Update the field, and then ring the doorbell */ 1295 /* Update the field, and then ring the doorbell */
1298 writel(intinfo.delay, 1296 writel(intinfo.delay,
1299 &(host->cfgtable->HostWrite.CoalIntDelay)); 1297 &(h->cfgtable->HostWrite.CoalIntDelay));
1300 writel(intinfo.count, 1298 writel(intinfo.count,
1301 &(host->cfgtable->HostWrite.CoalIntCount)); 1299 &(h->cfgtable->HostWrite.CoalIntCount));
1302 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL); 1300 writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
1303 1301
1304 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) { 1302 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
1305 if (!(readl(host->vaddr + SA5_DOORBELL) 1303 if (!(readl(h->vaddr + SA5_DOORBELL)
1306 & CFGTBL_ChangeReq)) 1304 & CFGTBL_ChangeReq))
1307 break; 1305 break;
1308 /* delay and try again */ 1306 /* delay and try again */
1309 udelay(1000); 1307 udelay(1000);
1310 } 1308 }
1311 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1309 spin_unlock_irqrestore(&h->lock, flags);
1312 if (i >= MAX_IOCTL_CONFIG_WAIT) 1310 if (i >= MAX_IOCTL_CONFIG_WAIT)
1313 return -EAGAIN; 1311 return -EAGAIN;
1314 return 0; 1312 return 0;
@@ -1322,7 +1320,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1322 return -EINVAL; 1320 return -EINVAL;
1323 for (i = 0; i < 16; i++) 1321 for (i = 0; i < 16; i++)
1324 NodeName[i] = 1322 NodeName[i] =
1325 readb(&host->cfgtable->ServerName[i]); 1323 readb(&h->cfgtable->ServerName[i]);
1326 if (copy_to_user(argp, NodeName, sizeof(NodeName_type))) 1324 if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
1327 return -EFAULT; 1325 return -EFAULT;
1328 return 0; 1326 return 0;
@@ -1342,23 +1340,23 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1342 (NodeName, argp, sizeof(NodeName_type))) 1340 (NodeName, argp, sizeof(NodeName_type)))
1343 return -EFAULT; 1341 return -EFAULT;
1344 1342
1345 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1343 spin_lock_irqsave(&h->lock, flags);
1346 1344
1347 /* Update the field, and then ring the doorbell */ 1345 /* Update the field, and then ring the doorbell */
1348 for (i = 0; i < 16; i++) 1346 for (i = 0; i < 16; i++)
1349 writeb(NodeName[i], 1347 writeb(NodeName[i],
1350 &host->cfgtable->ServerName[i]); 1348 &h->cfgtable->ServerName[i]);
1351 1349
1352 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL); 1350 writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
1353 1351
1354 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) { 1352 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
1355 if (!(readl(host->vaddr + SA5_DOORBELL) 1353 if (!(readl(h->vaddr + SA5_DOORBELL)
1356 & CFGTBL_ChangeReq)) 1354 & CFGTBL_ChangeReq))
1357 break; 1355 break;
1358 /* delay and try again */ 1356 /* delay and try again */
1359 udelay(1000); 1357 udelay(1000);
1360 } 1358 }
1361 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1359 spin_unlock_irqrestore(&h->lock, flags);
1362 if (i >= MAX_IOCTL_CONFIG_WAIT) 1360 if (i >= MAX_IOCTL_CONFIG_WAIT)
1363 return -EAGAIN; 1361 return -EAGAIN;
1364 return 0; 1362 return 0;
@@ -1370,7 +1368,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1370 1368
1371 if (!arg) 1369 if (!arg)
1372 return -EINVAL; 1370 return -EINVAL;
1373 heartbeat = readl(&host->cfgtable->HeartBeat); 1371 heartbeat = readl(&h->cfgtable->HeartBeat);
1374 if (copy_to_user 1372 if (copy_to_user
1375 (argp, &heartbeat, sizeof(Heartbeat_type))) 1373 (argp, &heartbeat, sizeof(Heartbeat_type)))
1376 return -EFAULT; 1374 return -EFAULT;
@@ -1382,7 +1380,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1382 1380
1383 if (!arg) 1381 if (!arg)
1384 return -EINVAL; 1382 return -EINVAL;
1385 BusTypes = readl(&host->cfgtable->BusTypes); 1383 BusTypes = readl(&h->cfgtable->BusTypes);
1386 if (copy_to_user 1384 if (copy_to_user
1387 (argp, &BusTypes, sizeof(BusTypes_type))) 1385 (argp, &BusTypes, sizeof(BusTypes_type)))
1388 return -EFAULT; 1386 return -EFAULT;
@@ -1394,7 +1392,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1394 1392
1395 if (!arg) 1393 if (!arg)
1396 return -EINVAL; 1394 return -EINVAL;
1397 memcpy(firmware, host->firm_ver, 4); 1395 memcpy(firmware, h->firm_ver, 4);
1398 1396
1399 if (copy_to_user 1397 if (copy_to_user
1400 (argp, firmware, sizeof(FirmwareVer_type))) 1398 (argp, firmware, sizeof(FirmwareVer_type)))
@@ -1417,7 +1415,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1417 case CCISS_DEREGDISK: 1415 case CCISS_DEREGDISK:
1418 case CCISS_REGNEWD: 1416 case CCISS_REGNEWD:
1419 case CCISS_REVALIDVOLS: 1417 case CCISS_REVALIDVOLS:
1420 return rebuild_lun_table(host, 0, 1); 1418 return rebuild_lun_table(h, 0, 1);
1421 1419
1422 case CCISS_GETLUNINFO:{ 1420 case CCISS_GETLUNINFO:{
1423 LogvolInfo_struct luninfo; 1421 LogvolInfo_struct luninfo;
@@ -1472,7 +1470,8 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1472 } else { 1470 } else {
1473 memset(buff, 0, iocommand.buf_size); 1471 memset(buff, 0, iocommand.buf_size);
1474 } 1472 }
1475 if ((c = cmd_alloc(host, 0)) == NULL) { 1473 c = cmd_alloc(h, 0);
1474 if (!c) {
1476 kfree(buff); 1475 kfree(buff);
1477 return -ENOMEM; 1476 return -ENOMEM;
1478 } 1477 }
@@ -1498,7 +1497,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1498 1497
1499 /* Fill in the scatter gather information */ 1498 /* Fill in the scatter gather information */
1500 if (iocommand.buf_size > 0) { 1499 if (iocommand.buf_size > 0) {
1501 temp64.val = pci_map_single(host->pdev, buff, 1500 temp64.val = pci_map_single(h->pdev, buff,
1502 iocommand.buf_size, 1501 iocommand.buf_size,
1503 PCI_DMA_BIDIRECTIONAL); 1502 PCI_DMA_BIDIRECTIONAL);
1504 c->SG[0].Addr.lower = temp64.val32.lower; 1503 c->SG[0].Addr.lower = temp64.val32.lower;
@@ -1508,24 +1507,24 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1508 } 1507 }
1509 c->waiting = &wait; 1508 c->waiting = &wait;
1510 1509
1511 enqueue_cmd_and_start_io(host, c); 1510 enqueue_cmd_and_start_io(h, c);
1512 wait_for_completion(&wait); 1511 wait_for_completion(&wait);
1513 1512
1514 /* unlock the buffers from DMA */ 1513 /* unlock the buffers from DMA */
1515 temp64.val32.lower = c->SG[0].Addr.lower; 1514 temp64.val32.lower = c->SG[0].Addr.lower;
1516 temp64.val32.upper = c->SG[0].Addr.upper; 1515 temp64.val32.upper = c->SG[0].Addr.upper;
1517 pci_unmap_single(host->pdev, (dma_addr_t) temp64.val, 1516 pci_unmap_single(h->pdev, (dma_addr_t) temp64.val,
1518 iocommand.buf_size, 1517 iocommand.buf_size,
1519 PCI_DMA_BIDIRECTIONAL); 1518 PCI_DMA_BIDIRECTIONAL);
1520 1519
1521 check_ioctl_unit_attention(host, c); 1520 check_ioctl_unit_attention(h, c);
1522 1521
1523 /* Copy the error information out */ 1522 /* Copy the error information out */
1524 iocommand.error_info = *(c->err_info); 1523 iocommand.error_info = *(c->err_info);
1525 if (copy_to_user 1524 if (copy_to_user
1526 (argp, &iocommand, sizeof(IOCTL_Command_struct))) { 1525 (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
1527 kfree(buff); 1526 kfree(buff);
1528 cmd_free(host, c, 0); 1527 cmd_free(h, c, 0);
1529 return -EFAULT; 1528 return -EFAULT;
1530 } 1529 }
1531 1530
@@ -1534,12 +1533,12 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1534 if (copy_to_user 1533 if (copy_to_user
1535 (iocommand.buf, buff, iocommand.buf_size)) { 1534 (iocommand.buf, buff, iocommand.buf_size)) {
1536 kfree(buff); 1535 kfree(buff);
1537 cmd_free(host, c, 0); 1536 cmd_free(h, c, 0);
1538 return -EFAULT; 1537 return -EFAULT;
1539 } 1538 }
1540 } 1539 }
1541 kfree(buff); 1540 kfree(buff);
1542 cmd_free(host, c, 0); 1541 cmd_free(h, c, 0);
1543 return 0; 1542 return 0;
1544 } 1543 }
1545 case CCISS_BIG_PASSTHRU:{ 1544 case CCISS_BIG_PASSTHRU:{
@@ -1621,7 +1620,8 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1621 data_ptr += sz; 1620 data_ptr += sz;
1622 sg_used++; 1621 sg_used++;
1623 } 1622 }
1624 if ((c = cmd_alloc(host, 0)) == NULL) { 1623 c = cmd_alloc(h, 0);
1624 if (!c) {
1625 status = -ENOMEM; 1625 status = -ENOMEM;
1626 goto cleanup1; 1626 goto cleanup1;
1627 } 1627 }
@@ -1642,7 +1642,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1642 if (ioc->buf_size > 0) { 1642 if (ioc->buf_size > 0) {
1643 for (i = 0; i < sg_used; i++) { 1643 for (i = 0; i < sg_used; i++) {
1644 temp64.val = 1644 temp64.val =
1645 pci_map_single(host->pdev, buff[i], 1645 pci_map_single(h->pdev, buff[i],
1646 buff_size[i], 1646 buff_size[i],
1647 PCI_DMA_BIDIRECTIONAL); 1647 PCI_DMA_BIDIRECTIONAL);
1648 c->SG[i].Addr.lower = 1648 c->SG[i].Addr.lower =
@@ -1654,21 +1654,21 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1654 } 1654 }
1655 } 1655 }
1656 c->waiting = &wait; 1656 c->waiting = &wait;
1657 enqueue_cmd_and_start_io(host, c); 1657 enqueue_cmd_and_start_io(h, c);
1658 wait_for_completion(&wait); 1658 wait_for_completion(&wait);
1659 /* unlock the buffers from DMA */ 1659 /* unlock the buffers from DMA */
1660 for (i = 0; i < sg_used; i++) { 1660 for (i = 0; i < sg_used; i++) {
1661 temp64.val32.lower = c->SG[i].Addr.lower; 1661 temp64.val32.lower = c->SG[i].Addr.lower;
1662 temp64.val32.upper = c->SG[i].Addr.upper; 1662 temp64.val32.upper = c->SG[i].Addr.upper;
1663 pci_unmap_single(host->pdev, 1663 pci_unmap_single(h->pdev,
1664 (dma_addr_t) temp64.val, buff_size[i], 1664 (dma_addr_t) temp64.val, buff_size[i],
1665 PCI_DMA_BIDIRECTIONAL); 1665 PCI_DMA_BIDIRECTIONAL);
1666 } 1666 }
1667 check_ioctl_unit_attention(host, c); 1667 check_ioctl_unit_attention(h, c);
1668 /* Copy the error information out */ 1668 /* Copy the error information out */
1669 ioc->error_info = *(c->err_info); 1669 ioc->error_info = *(c->err_info);
1670 if (copy_to_user(argp, ioc, sizeof(*ioc))) { 1670 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1671 cmd_free(host, c, 0); 1671 cmd_free(h, c, 0);
1672 status = -EFAULT; 1672 status = -EFAULT;
1673 goto cleanup1; 1673 goto cleanup1;
1674 } 1674 }
@@ -1678,14 +1678,14 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
1678 for (i = 0; i < sg_used; i++) { 1678 for (i = 0; i < sg_used; i++) {
1679 if (copy_to_user 1679 if (copy_to_user
1680 (ptr, buff[i], buff_size[i])) { 1680 (ptr, buff[i], buff_size[i])) {
1681 cmd_free(host, c, 0); 1681 cmd_free(h, c, 0);
1682 status = -EFAULT; 1682 status = -EFAULT;
1683 goto cleanup1; 1683 goto cleanup1;
1684 } 1684 }
1685 ptr += buff_size[i]; 1685 ptr += buff_size[i];
1686 } 1686 }
1687 } 1687 }
1688 cmd_free(host, c, 0); 1688 cmd_free(h, c, 0);
1689 status = 0; 1689 status = 0;
1690 cleanup1: 1690 cleanup1:
1691 if (buff) { 1691 if (buff) {
@@ -1773,26 +1773,26 @@ static void cciss_check_queues(ctlr_info_t *h)
1773 1773
1774static void cciss_softirq_done(struct request *rq) 1774static void cciss_softirq_done(struct request *rq)
1775{ 1775{
1776 CommandList_struct *cmd = rq->completion_data; 1776 CommandList_struct *c = rq->completion_data;
1777 ctlr_info_t *h = hba[cmd->ctlr]; 1777 ctlr_info_t *h = hba[c->ctlr];
1778 SGDescriptor_struct *curr_sg = cmd->SG; 1778 SGDescriptor_struct *curr_sg = c->SG;
1779 u64bit temp64; 1779 u64bit temp64;
1780 unsigned long flags; 1780 unsigned long flags;
1781 int i, ddir; 1781 int i, ddir;
1782 int sg_index = 0; 1782 int sg_index = 0;
1783 1783
1784 if (cmd->Request.Type.Direction == XFER_READ) 1784 if (c->Request.Type.Direction == XFER_READ)
1785 ddir = PCI_DMA_FROMDEVICE; 1785 ddir = PCI_DMA_FROMDEVICE;
1786 else 1786 else
1787 ddir = PCI_DMA_TODEVICE; 1787 ddir = PCI_DMA_TODEVICE;
1788 1788
1789 /* command did not need to be retried */ 1789 /* command did not need to be retried */
1790 /* unmap the DMA mapping for all the scatter gather elements */ 1790 /* unmap the DMA mapping for all the scatter gather elements */
1791 for (i = 0; i < cmd->Header.SGList; i++) { 1791 for (i = 0; i < c->Header.SGList; i++) {
1792 if (curr_sg[sg_index].Ext == CCISS_SG_CHAIN) { 1792 if (curr_sg[sg_index].Ext == CCISS_SG_CHAIN) {
1793 cciss_unmap_sg_chain_block(h, cmd); 1793 cciss_unmap_sg_chain_block(h, c);
1794 /* Point to the next block */ 1794 /* Point to the next block */
1795 curr_sg = h->cmd_sg_list[cmd->cmdindex]; 1795 curr_sg = h->cmd_sg_list[c->cmdindex];
1796 sg_index = 0; 1796 sg_index = 0;
1797 } 1797 }
1798 temp64.val32.lower = curr_sg[sg_index].Addr.lower; 1798 temp64.val32.lower = curr_sg[sg_index].Addr.lower;
@@ -1808,12 +1808,12 @@ static void cciss_softirq_done(struct request *rq)
1808 1808
1809 /* set the residual count for pc requests */ 1809 /* set the residual count for pc requests */
1810 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) 1810 if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
1811 rq->resid_len = cmd->err_info->ResidualCnt; 1811 rq->resid_len = c->err_info->ResidualCnt;
1812 1812
1813 blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO); 1813 blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);
1814 1814
1815 spin_lock_irqsave(&h->lock, flags); 1815 spin_lock_irqsave(&h->lock, flags);
1816 cmd_free(h, cmd, 1); 1816 cmd_free(h, c, 1);
1817 cciss_check_queues(h); 1817 cciss_check_queues(h);
1818 spin_unlock_irqrestore(&h->lock, flags); 1818 spin_unlock_irqrestore(&h->lock, flags);
1819} 1819}
@@ -1829,7 +1829,7 @@ static inline void log_unit_to_scsi3addr(ctlr_info_t *h,
1829 * via the inquiry page 0. Model, vendor, and rev are set to empty strings if 1829 * via the inquiry page 0. Model, vendor, and rev are set to empty strings if
1830 * they cannot be read. 1830 * they cannot be read.
1831 */ 1831 */
1832static void cciss_get_device_descr(int ctlr, int logvol, 1832static void cciss_get_device_descr(ctlr_info_t *h, int logvol,
1833 char *vendor, char *model, char *rev) 1833 char *vendor, char *model, char *rev)
1834{ 1834{
1835 int rc; 1835 int rc;
@@ -1844,8 +1844,8 @@ static void cciss_get_device_descr(int ctlr, int logvol,
1844 if (!inq_buf) 1844 if (!inq_buf)
1845 return; 1845 return;
1846 1846
1847 log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); 1847 log_unit_to_scsi3addr(h, scsi3addr, logvol);
1848 rc = sendcmd_withirq(CISS_INQUIRY, ctlr, inq_buf, sizeof(*inq_buf), 0, 1848 rc = sendcmd_withirq(h, CISS_INQUIRY, inq_buf, sizeof(*inq_buf), 0,
1849 scsi3addr, TYPE_CMD); 1849 scsi3addr, TYPE_CMD);
1850 if (rc == IO_OK) { 1850 if (rc == IO_OK) {
1851 memcpy(vendor, &inq_buf->data_byte[8], VENDOR_LEN); 1851 memcpy(vendor, &inq_buf->data_byte[8], VENDOR_LEN);
@@ -1865,7 +1865,7 @@ static void cciss_get_device_descr(int ctlr, int logvol,
1865 * number cannot be had, for whatever reason, 16 bytes of 0xff 1865 * number cannot be had, for whatever reason, 16 bytes of 0xff
1866 * are returned instead. 1866 * are returned instead.
1867 */ 1867 */
1868static void cciss_get_serial_no(int ctlr, int logvol, 1868static void cciss_get_serial_no(ctlr_info_t *h, int logvol,
1869 unsigned char *serial_no, int buflen) 1869 unsigned char *serial_no, int buflen)
1870{ 1870{
1871#define PAGE_83_INQ_BYTES 64 1871#define PAGE_83_INQ_BYTES 64
@@ -1880,8 +1880,8 @@ static void cciss_get_serial_no(int ctlr, int logvol,
1880 if (!buf) 1880 if (!buf)
1881 return; 1881 return;
1882 memset(serial_no, 0, buflen); 1882 memset(serial_no, 0, buflen);
1883 log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); 1883 log_unit_to_scsi3addr(h, scsi3addr, logvol);
1884 rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf, 1884 rc = sendcmd_withirq(h, CISS_INQUIRY, buf,
1885 PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD); 1885 PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
1886 if (rc == IO_OK) 1886 if (rc == IO_OK)
1887 memcpy(serial_no, &buf[8], buflen); 1887 memcpy(serial_no, &buf[8], buflen);
@@ -1947,10 +1947,9 @@ init_queue_failure:
1947 * is also the controller node. Any changes to disk 0 will show up on 1947 * is also the controller node. Any changes to disk 0 will show up on
1948 * the next reboot. 1948 * the next reboot.
1949 */ 1949 */
1950static void cciss_update_drive_info(int ctlr, int drv_index, int first_time, 1950static void cciss_update_drive_info(ctlr_info_t *h, int drv_index,
1951 int via_ioctl) 1951 int first_time, int via_ioctl)
1952{ 1952{
1953 ctlr_info_t *h = hba[ctlr];
1954 struct gendisk *disk; 1953 struct gendisk *disk;
1955 InquiryData_struct *inq_buff = NULL; 1954 InquiryData_struct *inq_buff = NULL;
1956 unsigned int block_size; 1955 unsigned int block_size;
@@ -1967,16 +1966,16 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time,
1967 1966
1968 /* testing to see if 16-byte CDBs are already being used */ 1967 /* testing to see if 16-byte CDBs are already being used */
1969 if (h->cciss_read == CCISS_READ_16) { 1968 if (h->cciss_read == CCISS_READ_16) {
1970 cciss_read_capacity_16(h->ctlr, drv_index, 1969 cciss_read_capacity_16(h, drv_index,
1971 &total_size, &block_size); 1970 &total_size, &block_size);
1972 1971
1973 } else { 1972 } else {
1974 cciss_read_capacity(ctlr, drv_index, &total_size, &block_size); 1973 cciss_read_capacity(h, drv_index, &total_size, &block_size);
1975 /* if read_capacity returns all F's this volume is >2TB */ 1974 /* if read_capacity returns all F's this volume is >2TB */
1976 /* in size so we switch to 16-byte CDB's for all */ 1975 /* in size so we switch to 16-byte CDB's for all */
1977 /* read/write ops */ 1976 /* read/write ops */
1978 if (total_size == 0xFFFFFFFFULL) { 1977 if (total_size == 0xFFFFFFFFULL) {
1979 cciss_read_capacity_16(ctlr, drv_index, 1978 cciss_read_capacity_16(h, drv_index,
1980 &total_size, &block_size); 1979 &total_size, &block_size);
1981 h->cciss_read = CCISS_READ_16; 1980 h->cciss_read = CCISS_READ_16;
1982 h->cciss_write = CCISS_WRITE_16; 1981 h->cciss_write = CCISS_WRITE_16;
@@ -1986,14 +1985,14 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time,
1986 } 1985 }
1987 } 1986 }
1988 1987
1989 cciss_geometry_inquiry(ctlr, drv_index, total_size, block_size, 1988 cciss_geometry_inquiry(h, drv_index, total_size, block_size,
1990 inq_buff, drvinfo); 1989 inq_buff, drvinfo);
1991 drvinfo->block_size = block_size; 1990 drvinfo->block_size = block_size;
1992 drvinfo->nr_blocks = total_size + 1; 1991 drvinfo->nr_blocks = total_size + 1;
1993 1992
1994 cciss_get_device_descr(ctlr, drv_index, drvinfo->vendor, 1993 cciss_get_device_descr(h, drv_index, drvinfo->vendor,
1995 drvinfo->model, drvinfo->rev); 1994 drvinfo->model, drvinfo->rev);
1996 cciss_get_serial_no(ctlr, drv_index, drvinfo->serial_no, 1995 cciss_get_serial_no(h, drv_index, drvinfo->serial_no,
1997 sizeof(drvinfo->serial_no)); 1996 sizeof(drvinfo->serial_no));
1998 /* Save the lunid in case we deregister the disk, below. */ 1997 /* Save the lunid in case we deregister the disk, below. */
1999 memcpy(drvinfo->LunID, h->drv[drv_index]->LunID, 1998 memcpy(drvinfo->LunID, h->drv[drv_index]->LunID,
@@ -2019,9 +2018,9 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time,
2019 */ 2018 */
2020 if (h->drv[drv_index]->raid_level != -1 && drv_index != 0) { 2019 if (h->drv[drv_index]->raid_level != -1 && drv_index != 0) {
2021 printk(KERN_WARNING "disk %d has changed.\n", drv_index); 2020 printk(KERN_WARNING "disk %d has changed.\n", drv_index);
2022 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 2021 spin_lock_irqsave(&h->lock, flags);
2023 h->drv[drv_index]->busy_configuring = 1; 2022 h->drv[drv_index]->busy_configuring = 1;
2024 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 2023 spin_unlock_irqrestore(&h->lock, flags);
2025 2024
2026 /* deregister_disk sets h->drv[drv_index]->queue = NULL 2025 /* deregister_disk sets h->drv[drv_index]->queue = NULL
2027 * which keeps the interrupt handler from starting 2026 * which keeps the interrupt handler from starting
@@ -2243,7 +2242,6 @@ error:
2243static int rebuild_lun_table(ctlr_info_t *h, int first_time, 2242static int rebuild_lun_table(ctlr_info_t *h, int first_time,
2244 int via_ioctl) 2243 int via_ioctl)
2245{ 2244{
2246 int ctlr = h->ctlr;
2247 int num_luns; 2245 int num_luns;
2248 ReportLunData_struct *ld_buff = NULL; 2246 ReportLunData_struct *ld_buff = NULL;
2249 int return_code; 2247 int return_code;
@@ -2258,19 +2256,19 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time,
2258 return -EPERM; 2256 return -EPERM;
2259 2257
2260 /* Set busy_configuring flag for this operation */ 2258 /* Set busy_configuring flag for this operation */
2261 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 2259 spin_lock_irqsave(&h->lock, flags);
2262 if (h->busy_configuring) { 2260 if (h->busy_configuring) {
2263 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 2261 spin_unlock_irqrestore(&h->lock, flags);
2264 return -EBUSY; 2262 return -EBUSY;
2265 } 2263 }
2266 h->busy_configuring = 1; 2264 h->busy_configuring = 1;
2267 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 2265 spin_unlock_irqrestore(&h->lock, flags);
2268 2266
2269 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL); 2267 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
2270 if (ld_buff == NULL) 2268 if (ld_buff == NULL)
2271 goto mem_msg; 2269 goto mem_msg;
2272 2270
2273 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff, 2271 return_code = sendcmd_withirq(h, CISS_REPORT_LOG, ld_buff,
2274 sizeof(ReportLunData_struct), 2272 sizeof(ReportLunData_struct),
2275 0, CTLR_LUNID, TYPE_CMD); 2273 0, CTLR_LUNID, TYPE_CMD);
2276 2274
@@ -2317,9 +2315,9 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time,
2317 } 2315 }
2318 if (!drv_found) { 2316 if (!drv_found) {
2319 /* Deregister it from the OS, it's gone. */ 2317 /* Deregister it from the OS, it's gone. */
2320 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 2318 spin_lock_irqsave(&h->lock, flags);
2321 h->drv[i]->busy_configuring = 1; 2319 h->drv[i]->busy_configuring = 1;
2322 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 2320 spin_unlock_irqrestore(&h->lock, flags);
2323 return_code = deregister_disk(h, i, 1, via_ioctl); 2321 return_code = deregister_disk(h, i, 1, via_ioctl);
2324 if (h->drv[i] != NULL) 2322 if (h->drv[i] != NULL)
2325 h->drv[i]->busy_configuring = 0; 2323 h->drv[i]->busy_configuring = 0;
@@ -2358,8 +2356,7 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time,
2358 if (drv_index == -1) 2356 if (drv_index == -1)
2359 goto freeret; 2357 goto freeret;
2360 } 2358 }
2361 cciss_update_drive_info(ctlr, drv_index, first_time, 2359 cciss_update_drive_info(h, drv_index, first_time, via_ioctl);
2362 via_ioctl);
2363 } /* end for */ 2360 } /* end for */
2364 2361
2365freeret: 2362freeret:
@@ -2491,11 +2488,10 @@ static int deregister_disk(ctlr_info_t *h, int drv_index,
2491 return 0; 2488 return 0;
2492} 2489}
2493 2490
2494static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, 2491static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff,
2495 size_t size, __u8 page_code, unsigned char *scsi3addr, 2492 size_t size, __u8 page_code, unsigned char *scsi3addr,
2496 int cmd_type) 2493 int cmd_type)
2497{ 2494{
2498 ctlr_info_t *h = hba[ctlr];
2499 u64bit buff_dma_handle; 2495 u64bit buff_dma_handle;
2500 int status = IO_OK; 2496 int status = IO_OK;
2501 2497
@@ -2580,7 +2576,8 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
2580 break; 2576 break;
2581 default: 2577 default:
2582 printk(KERN_WARNING 2578 printk(KERN_WARNING
2583 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd); 2579 "cciss%d: Unknown Command 0x%c\n",
2580 h->ctlr, cmd);
2584 return IO_ERROR; 2581 return IO_ERROR;
2585 } 2582 }
2586 } else if (cmd_type == TYPE_MSG) { 2583 } else if (cmd_type == TYPE_MSG) {
@@ -2613,12 +2610,13 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
2613 break; 2610 break;
2614 default: 2611 default:
2615 printk(KERN_WARNING 2612 printk(KERN_WARNING
2616 "cciss%d: unknown message type %d\n", ctlr, cmd); 2613 "cciss%d: unknown message type %d\n",
2614 h->ctlr, cmd);
2617 return IO_ERROR; 2615 return IO_ERROR;
2618 } 2616 }
2619 } else { 2617 } else {
2620 printk(KERN_WARNING 2618 printk(KERN_WARNING
2621 "cciss%d: unknown command type %d\n", ctlr, cmd_type); 2619 "cciss%d: unknown command type %d\n", h->ctlr, cmd_type);
2622 return IO_ERROR; 2620 return IO_ERROR;
2623 } 2621 }
2624 /* Fill in the scatter gather information */ 2622 /* Fill in the scatter gather information */
@@ -2760,18 +2758,17 @@ command_done:
2760 return return_status; 2758 return return_status;
2761} 2759}
2762 2760
2763static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size, 2761static int sendcmd_withirq(ctlr_info_t *h, __u8 cmd, void *buff, size_t size,
2764 __u8 page_code, unsigned char scsi3addr[], 2762 __u8 page_code, unsigned char scsi3addr[],
2765 int cmd_type) 2763 int cmd_type)
2766{ 2764{
2767 ctlr_info_t *h = hba[ctlr];
2768 CommandList_struct *c; 2765 CommandList_struct *c;
2769 int return_status; 2766 int return_status;
2770 2767
2771 c = cmd_alloc(h, 0); 2768 c = cmd_alloc(h, 0);
2772 if (!c) 2769 if (!c)
2773 return -ENOMEM; 2770 return -ENOMEM;
2774 return_status = fill_cmd(c, cmd, ctlr, buff, size, page_code, 2771 return_status = fill_cmd(h, c, cmd, buff, size, page_code,
2775 scsi3addr, cmd_type); 2772 scsi3addr, cmd_type);
2776 if (return_status == IO_OK) 2773 if (return_status == IO_OK)
2777 return_status = sendcmd_withirq_core(h, c, 1); 2774 return_status = sendcmd_withirq_core(h, c, 1);
@@ -2780,7 +2777,7 @@ static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
2780 return return_status; 2777 return return_status;
2781} 2778}
2782 2779
2783static void cciss_geometry_inquiry(int ctlr, int logvol, 2780static void cciss_geometry_inquiry(ctlr_info_t *h, int logvol,
2784 sector_t total_size, 2781 sector_t total_size,
2785 unsigned int block_size, 2782 unsigned int block_size,
2786 InquiryData_struct *inq_buff, 2783 InquiryData_struct *inq_buff,
@@ -2791,8 +2788,8 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
2791 unsigned char scsi3addr[8]; 2788 unsigned char scsi3addr[8];
2792 2789
2793 memset(inq_buff, 0, sizeof(InquiryData_struct)); 2790 memset(inq_buff, 0, sizeof(InquiryData_struct));
2794 log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); 2791 log_unit_to_scsi3addr(h, scsi3addr, logvol);
2795 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr, inq_buff, 2792 return_code = sendcmd_withirq(h, CISS_INQUIRY, inq_buff,
2796 sizeof(*inq_buff), 0xC1, scsi3addr, TYPE_CMD); 2793 sizeof(*inq_buff), 0xC1, scsi3addr, TYPE_CMD);
2797 if (return_code == IO_OK) { 2794 if (return_code == IO_OK) {
2798 if (inq_buff->data_byte[8] == 0xFF) { 2795 if (inq_buff->data_byte[8] == 0xFF) {
@@ -2826,7 +2823,7 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
2826} 2823}
2827 2824
2828static void 2825static void
2829cciss_read_capacity(int ctlr, int logvol, sector_t *total_size, 2826cciss_read_capacity(ctlr_info_t *h, int logvol, sector_t *total_size,
2830 unsigned int *block_size) 2827 unsigned int *block_size)
2831{ 2828{
2832 ReadCapdata_struct *buf; 2829 ReadCapdata_struct *buf;
@@ -2839,8 +2836,8 @@ cciss_read_capacity(int ctlr, int logvol, sector_t *total_size,
2839 return; 2836 return;
2840 } 2837 }
2841 2838
2842 log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); 2839 log_unit_to_scsi3addr(h, scsi3addr, logvol);
2843 return_code = sendcmd_withirq(CCISS_READ_CAPACITY, ctlr, buf, 2840 return_code = sendcmd_withirq(h, CCISS_READ_CAPACITY, buf,
2844 sizeof(ReadCapdata_struct), 0, scsi3addr, TYPE_CMD); 2841 sizeof(ReadCapdata_struct), 0, scsi3addr, TYPE_CMD);
2845 if (return_code == IO_OK) { 2842 if (return_code == IO_OK) {
2846 *total_size = be32_to_cpu(*(__be32 *) buf->total_size); 2843 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
@@ -2853,7 +2850,7 @@ cciss_read_capacity(int ctlr, int logvol, sector_t *total_size,
2853 kfree(buf); 2850 kfree(buf);
2854} 2851}
2855 2852
2856static void cciss_read_capacity_16(int ctlr, int logvol, 2853static void cciss_read_capacity_16(ctlr_info_t *h, int logvol,
2857 sector_t *total_size, unsigned int *block_size) 2854 sector_t *total_size, unsigned int *block_size)
2858{ 2855{
2859 ReadCapdata_struct_16 *buf; 2856 ReadCapdata_struct_16 *buf;
@@ -2866,9 +2863,9 @@ static void cciss_read_capacity_16(int ctlr, int logvol,
2866 return; 2863 return;
2867 } 2864 }
2868 2865
2869 log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); 2866 log_unit_to_scsi3addr(h, scsi3addr, logvol);
2870 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16, 2867 return_code = sendcmd_withirq(h, CCISS_READ_CAPACITY_16,
2871 ctlr, buf, sizeof(ReadCapdata_struct_16), 2868 buf, sizeof(ReadCapdata_struct_16),
2872 0, scsi3addr, TYPE_CMD); 2869 0, scsi3addr, TYPE_CMD);
2873 if (return_code == IO_OK) { 2870 if (return_code == IO_OK) {
2874 *total_size = be64_to_cpu(*(__be64 *) buf->total_size); 2871 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
@@ -2910,13 +2907,13 @@ static int cciss_revalidate(struct gendisk *disk)
2910 return 1; 2907 return 1;
2911 } 2908 }
2912 if (h->cciss_read == CCISS_READ_10) { 2909 if (h->cciss_read == CCISS_READ_10) {
2913 cciss_read_capacity(h->ctlr, logvol, 2910 cciss_read_capacity(h, logvol,
2914 &total_size, &block_size); 2911 &total_size, &block_size);
2915 } else { 2912 } else {
2916 cciss_read_capacity_16(h->ctlr, logvol, 2913 cciss_read_capacity_16(h, logvol,
2917 &total_size, &block_size); 2914 &total_size, &block_size);
2918 } 2915 }
2919 cciss_geometry_inquiry(h->ctlr, logvol, total_size, block_size, 2916 cciss_geometry_inquiry(h, logvol, total_size, block_size,
2920 inq_buff, drv); 2917 inq_buff, drv);
2921 2918
2922 blk_queue_logical_block_size(drv->queue, drv->block_size); 2919 blk_queue_logical_block_size(drv->queue, drv->block_size);
@@ -2966,7 +2963,7 @@ static void start_io(ctlr_info_t *h)
2966 } 2963 }
2967} 2964}
2968 2965
2969/* Assumes that CCISS_LOCK(h->ctlr) is held. */ 2966/* Assumes that h->lock is held. */
2970/* Zeros out the error record and then resends the command back */ 2967/* Zeros out the error record and then resends the command back */
2971/* to the controller */ 2968/* to the controller */
2972static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c) 2969static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
@@ -3494,7 +3491,7 @@ static irqreturn_t do_cciss_intx(int irq, void *dev_id)
3494 * If there are completed commands in the completion queue, 3491 * If there are completed commands in the completion queue,
3495 * we had better do something about it. 3492 * we had better do something about it.
3496 */ 3493 */
3497 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 3494 spin_lock_irqsave(&h->lock, flags);
3498 while (interrupt_pending(h)) { 3495 while (interrupt_pending(h)) {
3499 raw_tag = get_next_completion(h); 3496 raw_tag = get_next_completion(h);
3500 while (raw_tag != FIFO_EMPTY) { 3497 while (raw_tag != FIFO_EMPTY) {
@@ -3505,7 +3502,7 @@ static irqreturn_t do_cciss_intx(int irq, void *dev_id)
3505 } 3502 }
3506 } 3503 }
3507 3504
3508 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 3505 spin_unlock_irqrestore(&h->lock, flags);
3509 return IRQ_HANDLED; 3506 return IRQ_HANDLED;
3510} 3507}
3511 3508
@@ -3524,7 +3521,7 @@ static irqreturn_t do_cciss_msix_intr(int irq, void *dev_id)
3524 * If there are completed commands in the completion queue, 3521 * If there are completed commands in the completion queue,
3525 * we had better do something about it. 3522 * we had better do something about it.
3526 */ 3523 */
3527 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 3524 spin_lock_irqsave(&h->lock, flags);
3528 raw_tag = get_next_completion(h); 3525 raw_tag = get_next_completion(h);
3529 while (raw_tag != FIFO_EMPTY) { 3526 while (raw_tag != FIFO_EMPTY) {
3530 if (cciss_tag_contains_index(raw_tag)) 3527 if (cciss_tag_contains_index(raw_tag))
@@ -3533,7 +3530,7 @@ static irqreturn_t do_cciss_msix_intr(int irq, void *dev_id)
3533 raw_tag = process_nonindexed_cmd(h, raw_tag); 3530 raw_tag = process_nonindexed_cmd(h, raw_tag);
3534 } 3531 }
3535 3532
3536 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 3533 spin_unlock_irqrestore(&h->lock, flags);
3537 return IRQ_HANDLED; 3534 return IRQ_HANDLED;
3538} 3535}
3539 3536
@@ -3961,7 +3958,7 @@ clean_up:
3961 * controllers that are capable. If not, we use IO-APIC mode. 3958 * controllers that are capable. If not, we use IO-APIC mode.
3962 */ 3959 */
3963 3960
3964static void __devinit cciss_interrupt_mode(ctlr_info_t *c) 3961static void __devinit cciss_interrupt_mode(ctlr_info_t *h)
3965{ 3962{
3966#ifdef CONFIG_PCI_MSI 3963#ifdef CONFIG_PCI_MSI
3967 int err; 3964 int err;
@@ -3970,18 +3967,18 @@ static void __devinit cciss_interrupt_mode(ctlr_info_t *c)
3970 }; 3967 };
3971 3968
3972 /* Some boards advertise MSI but don't really support it */ 3969 /* Some boards advertise MSI but don't really support it */
3973 if ((c->board_id == 0x40700E11) || (c->board_id == 0x40800E11) || 3970 if ((h->board_id == 0x40700E11) || (h->board_id == 0x40800E11) ||
3974 (c->board_id == 0x40820E11) || (c->board_id == 0x40830E11)) 3971 (h->board_id == 0x40820E11) || (h->board_id == 0x40830E11))
3975 goto default_int_mode; 3972 goto default_int_mode;
3976 3973
3977 if (pci_find_capability(c->pdev, PCI_CAP_ID_MSIX)) { 3974 if (pci_find_capability(h->pdev, PCI_CAP_ID_MSIX)) {
3978 err = pci_enable_msix(c->pdev, cciss_msix_entries, 4); 3975 err = pci_enable_msix(h->pdev, cciss_msix_entries, 4);
3979 if (!err) { 3976 if (!err) {
3980 c->intr[0] = cciss_msix_entries[0].vector; 3977 h->intr[0] = cciss_msix_entries[0].vector;
3981 c->intr[1] = cciss_msix_entries[1].vector; 3978 h->intr[1] = cciss_msix_entries[1].vector;
3982 c->intr[2] = cciss_msix_entries[2].vector; 3979 h->intr[2] = cciss_msix_entries[2].vector;
3983 c->intr[3] = cciss_msix_entries[3].vector; 3980 h->intr[3] = cciss_msix_entries[3].vector;
3984 c->msix_vector = 1; 3981 h->msix_vector = 1;
3985 return; 3982 return;
3986 } 3983 }
3987 if (err > 0) { 3984 if (err > 0) {
@@ -3994,17 +3991,16 @@ static void __devinit cciss_interrupt_mode(ctlr_info_t *c)
3994 goto default_int_mode; 3991 goto default_int_mode;
3995 } 3992 }
3996 } 3993 }
3997 if (pci_find_capability(c->pdev, PCI_CAP_ID_MSI)) { 3994 if (pci_find_capability(h->pdev, PCI_CAP_ID_MSI)) {
3998 if (!pci_enable_msi(c->pdev)) { 3995 if (!pci_enable_msi(h->pdev))
3999 c->msi_vector = 1; 3996 h->msi_vector = 1;
4000 } else { 3997 else
4001 printk(KERN_WARNING "cciss: MSI init failed\n"); 3998 printk(KERN_WARNING "cciss: MSI init failed\n");
4002 }
4003 } 3999 }
4004default_int_mode: 4000default_int_mode:
4005#endif /* CONFIG_PCI_MSI */ 4001#endif /* CONFIG_PCI_MSI */
4006 /* if we get here we're going to use the default interrupt mode */ 4002 /* if we get here we're going to use the default interrupt mode */
4007 c->intr[PERF_MODE_INT] = c->pdev->irq; 4003 h->intr[PERF_MODE_INT] = h->pdev->irq;
4008 return; 4004 return;
4009} 4005}
4010 4006
@@ -4190,28 +4186,28 @@ static inline void cciss_p600_dma_prefetch_quirk(ctlr_info_t *h)
4190 pci_write_config_dword(h->pdev, PCI_COMMAND_PARITY, dma_refetch); 4186 pci_write_config_dword(h->pdev, PCI_COMMAND_PARITY, dma_refetch);
4191} 4187}
4192 4188
4193static int __devinit cciss_pci_init(ctlr_info_t *c) 4189static int __devinit cciss_pci_init(ctlr_info_t *h)
4194{ 4190{
4195 int prod_index, err; 4191 int prod_index, err;
4196 4192
4197 prod_index = cciss_lookup_board_id(c->pdev, &c->board_id); 4193 prod_index = cciss_lookup_board_id(h->pdev, &h->board_id);
4198 if (prod_index < 0) 4194 if (prod_index < 0)
4199 return -ENODEV; 4195 return -ENODEV;
4200 c->product_name = products[prod_index].product_name; 4196 h->product_name = products[prod_index].product_name;
4201 c->access = *(products[prod_index].access); 4197 h->access = *(products[prod_index].access);
4202 4198
4203 if (cciss_board_disabled(c)) { 4199 if (cciss_board_disabled(h)) {
4204 printk(KERN_WARNING 4200 printk(KERN_WARNING
4205 "cciss: controller appears to be disabled\n"); 4201 "cciss: controller appears to be disabled\n");
4206 return -ENODEV; 4202 return -ENODEV;
4207 } 4203 }
4208 err = pci_enable_device(c->pdev); 4204 err = pci_enable_device(h->pdev);
4209 if (err) { 4205 if (err) {
4210 printk(KERN_ERR "cciss: Unable to Enable PCI device\n"); 4206 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
4211 return err; 4207 return err;
4212 } 4208 }
4213 4209
4214 err = pci_request_regions(c->pdev, "cciss"); 4210 err = pci_request_regions(h->pdev, "cciss");
4215 if (err) { 4211 if (err) {
4216 printk(KERN_ERR "cciss: Cannot obtain PCI resources, " 4212 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
4217 "aborting\n"); 4213 "aborting\n");
@@ -4220,38 +4216,38 @@ static int __devinit cciss_pci_init(ctlr_info_t *c)
4220 4216
4221#ifdef CCISS_DEBUG 4217#ifdef CCISS_DEBUG
4222 printk(KERN_INFO "command = %x\n", command); 4218 printk(KERN_INFO "command = %x\n", command);
4223 printk(KERN_INFO "irq = %x\n", c->pdev->irq); 4219 printk(KERN_INFO "irq = %x\n", h->pdev->irq);
4224 printk(KERN_INFO "board_id = %x\n", c->board_id); 4220 printk(KERN_INFO "board_id = %x\n", h->board_id);
4225#endif /* CCISS_DEBUG */ 4221#endif /* CCISS_DEBUG */
4226 4222
4227/* If the kernel supports MSI/MSI-X we will try to enable that functionality, 4223/* If the kernel supports MSI/MSI-X we will try to enable that functionality,
4228 * else we use the IO-APIC interrupt assigned to us by system ROM. 4224 * else we use the IO-APIC interrupt assigned to us by system ROM.
4229 */ 4225 */
4230 cciss_interrupt_mode(c); 4226 cciss_interrupt_mode(h);
4231 err = cciss_pci_find_memory_BAR(c->pdev, &c->paddr); 4227 err = cciss_pci_find_memory_BAR(h->pdev, &h->paddr);
4232 if (err) 4228 if (err)
4233 goto err_out_free_res; 4229 goto err_out_free_res;
4234 c->vaddr = remap_pci_mem(c->paddr, 0x250); 4230 h->vaddr = remap_pci_mem(h->paddr, 0x250);
4235 if (!c->vaddr) { 4231 if (!h->vaddr) {
4236 err = -ENOMEM; 4232 err = -ENOMEM;
4237 goto err_out_free_res; 4233 goto err_out_free_res;
4238 } 4234 }
4239 err = cciss_wait_for_board_ready(c); 4235 err = cciss_wait_for_board_ready(h);
4240 if (err) 4236 if (err)
4241 goto err_out_free_res; 4237 goto err_out_free_res;
4242 err = cciss_find_cfgtables(c); 4238 err = cciss_find_cfgtables(h);
4243 if (err) 4239 if (err)
4244 goto err_out_free_res; 4240 goto err_out_free_res;
4245 print_cfg_table(c->cfgtable); 4241 print_cfg_table(h->cfgtable);
4246 cciss_find_board_params(c); 4242 cciss_find_board_params(h);
4247 4243
4248 if (!CISS_signature_present(c)) { 4244 if (!CISS_signature_present(h)) {
4249 err = -ENODEV; 4245 err = -ENODEV;
4250 goto err_out_free_res; 4246 goto err_out_free_res;
4251 } 4247 }
4252 cciss_enable_scsi_prefetch(c); 4248 cciss_enable_scsi_prefetch(h);
4253 cciss_p600_dma_prefetch_quirk(c); 4249 cciss_p600_dma_prefetch_quirk(h);
4254 cciss_put_controller_into_performant_mode(c); 4250 cciss_put_controller_into_performant_mode(h);
4255 return 0; 4251 return 0;
4256 4252
4257err_out_free_res: 4253err_out_free_res:
@@ -4259,13 +4255,13 @@ err_out_free_res:
4259 * Deliberately omit pci_disable_device(): it does something nasty to 4255 * Deliberately omit pci_disable_device(): it does something nasty to
4260 * Smart Array controllers that pci_enable_device does not undo 4256 * Smart Array controllers that pci_enable_device does not undo
4261 */ 4257 */
4262 if (c->transtable) 4258 if (h->transtable)
4263 iounmap(c->transtable); 4259 iounmap(h->transtable);
4264 if (c->cfgtable) 4260 if (h->cfgtable)
4265 iounmap(c->cfgtable); 4261 iounmap(h->cfgtable);
4266 if (c->vaddr) 4262 if (h->vaddr)
4267 iounmap(c->vaddr); 4263 iounmap(h->vaddr);
4268 pci_release_regions(c->pdev); 4264 pci_release_regions(h->pdev);
4269 return err; 4265 return err;
4270} 4266}
4271 4267
@@ -4278,12 +4274,12 @@ static int alloc_cciss_hba(void)
4278 4274
4279 for (i = 0; i < MAX_CTLR; i++) { 4275 for (i = 0; i < MAX_CTLR; i++) {
4280 if (!hba[i]) { 4276 if (!hba[i]) {
4281 ctlr_info_t *p; 4277 ctlr_info_t *h;
4282 4278
4283 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL); 4279 h = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
4284 if (!p) 4280 if (!h)
4285 goto Enomem; 4281 goto Enomem;
4286 hba[i] = p; 4282 hba[i] = h;
4287 return i; 4283 return i;
4288 } 4284 }
4289 } 4285 }
@@ -4295,12 +4291,11 @@ Enomem:
4295 return -1; 4291 return -1;
4296} 4292}
4297 4293
4298static void free_hba(int n) 4294static void free_hba(ctlr_info_t *h)
4299{ 4295{
4300 ctlr_info_t *h = hba[n];
4301 int i; 4296 int i;
4302 4297
4303 hba[n] = NULL; 4298 hba[h->ctlr] = NULL;
4304 for (i = 0; i < h->highest_lun + 1; i++) 4299 for (i = 0; i < h->highest_lun + 1; i++)
4305 if (h->gendisk[i] != NULL) 4300 if (h->gendisk[i] != NULL)
4306 put_disk(h->gendisk[i]); 4301 put_disk(h->gendisk[i]);
@@ -4651,6 +4646,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
4651 int rc; 4646 int rc;
4652 int dac, return_code; 4647 int dac, return_code;
4653 InquiryData_struct *inq_buff; 4648 InquiryData_struct *inq_buff;
4649 ctlr_info_t *h;
4654 4650
4655 rc = cciss_init_reset_devices(pdev); 4651 rc = cciss_init_reset_devices(pdev);
4656 if (rc) 4652 if (rc)
@@ -4659,21 +4655,22 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
4659 if (i < 0) 4655 if (i < 0)
4660 return -1; 4656 return -1;
4661 4657
4662 hba[i]->pdev = pdev; 4658 h = hba[i];
4663 hba[i]->busy_initializing = 1; 4659 h->pdev = pdev;
4664 INIT_HLIST_HEAD(&hba[i]->cmpQ); 4660 h->busy_initializing = 1;
4665 INIT_HLIST_HEAD(&hba[i]->reqQ); 4661 INIT_HLIST_HEAD(&h->cmpQ);
4666 mutex_init(&hba[i]->busy_shutting_down); 4662 INIT_HLIST_HEAD(&h->reqQ);
4663 mutex_init(&h->busy_shutting_down);
4667 4664
4668 if (cciss_pci_init(hba[i]) != 0) 4665 if (cciss_pci_init(h) != 0)
4669 goto clean_no_release_regions; 4666 goto clean_no_release_regions;
4670 4667
4671 sprintf(hba[i]->devname, "cciss%d", i); 4668 sprintf(h->devname, "cciss%d", i);
4672 hba[i]->ctlr = i; 4669 h->ctlr = i;
4673 4670
4674 init_completion(&hba[i]->scan_wait); 4671 init_completion(&h->scan_wait);
4675 4672
4676 if (cciss_create_hba_sysfs_entry(hba[i])) 4673 if (cciss_create_hba_sysfs_entry(h))
4677 goto clean0; 4674 goto clean0;
4678 4675
4679 /* configure PCI DMA stuff */ 4676 /* configure PCI DMA stuff */
@@ -4692,100 +4689,100 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
4692 * 8 controller support. 4689 * 8 controller support.
4693 */ 4690 */
4694 if (i < MAX_CTLR_ORIG) 4691 if (i < MAX_CTLR_ORIG)
4695 hba[i]->major = COMPAQ_CISS_MAJOR + i; 4692 h->major = COMPAQ_CISS_MAJOR + i;
4696 rc = register_blkdev(hba[i]->major, hba[i]->devname); 4693 rc = register_blkdev(h->major, h->devname);
4697 if (rc == -EBUSY || rc == -EINVAL) { 4694 if (rc == -EBUSY || rc == -EINVAL) {
4698 printk(KERN_ERR 4695 printk(KERN_ERR
4699 "cciss: Unable to get major number %d for %s " 4696 "cciss: Unable to get major number %d for %s "
4700 "on hba %d\n", hba[i]->major, hba[i]->devname, i); 4697 "on hba %d\n", h->major, h->devname, i);
4701 goto clean1; 4698 goto clean1;
4702 } else { 4699 } else {
4703 if (i >= MAX_CTLR_ORIG) 4700 if (i >= MAX_CTLR_ORIG)
4704 hba[i]->major = rc; 4701 h->major = rc;
4705 } 4702 }
4706 4703
4707 /* make sure the board interrupts are off */ 4704 /* make sure the board interrupts are off */
4708 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF); 4705 h->access.set_intr_mask(h, CCISS_INTR_OFF);
4709 if (hba[i]->msi_vector || hba[i]->msix_vector) { 4706 if (h->msi_vector || h->msix_vector) {
4710 if (request_irq(hba[i]->intr[PERF_MODE_INT], 4707 if (request_irq(h->intr[PERF_MODE_INT],
4711 do_cciss_msix_intr, 4708 do_cciss_msix_intr,
4712 IRQF_DISABLED, hba[i]->devname, hba[i])) { 4709 IRQF_DISABLED, h->devname, h)) {
4713 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n", 4710 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
4714 hba[i]->intr[PERF_MODE_INT], hba[i]->devname); 4711 h->intr[PERF_MODE_INT], h->devname);
4715 goto clean2; 4712 goto clean2;
4716 } 4713 }
4717 } else { 4714 } else {
4718 if (request_irq(hba[i]->intr[PERF_MODE_INT], do_cciss_intx, 4715 if (request_irq(h->intr[PERF_MODE_INT], do_cciss_intx,
4719 IRQF_DISABLED, hba[i]->devname, hba[i])) { 4716 IRQF_DISABLED, h->devname, h)) {
4720 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n", 4717 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
4721 hba[i]->intr[PERF_MODE_INT], hba[i]->devname); 4718 h->intr[PERF_MODE_INT], h->devname);
4722 goto clean2; 4719 goto clean2;
4723 } 4720 }
4724 } 4721 }
4725 4722
4726 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n", 4723 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
4727 hba[i]->devname, pdev->device, pci_name(pdev), 4724 h->devname, pdev->device, pci_name(pdev),
4728 hba[i]->intr[PERF_MODE_INT], dac ? "" : " not"); 4725 h->intr[PERF_MODE_INT], dac ? "" : " not");
4729 4726
4730 hba[i]->cmd_pool_bits = 4727 h->cmd_pool_bits =
4731 kmalloc(DIV_ROUND_UP(hba[i]->nr_cmds, BITS_PER_LONG) 4728 kmalloc(DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG)
4732 * sizeof(unsigned long), GFP_KERNEL); 4729 * sizeof(unsigned long), GFP_KERNEL);
4733 hba[i]->cmd_pool = (CommandList_struct *) 4730 h->cmd_pool = (CommandList_struct *)
4734 pci_alloc_consistent(hba[i]->pdev, 4731 pci_alloc_consistent(h->pdev,
4735 hba[i]->nr_cmds * sizeof(CommandList_struct), 4732 h->nr_cmds * sizeof(CommandList_struct),
4736 &(hba[i]->cmd_pool_dhandle)); 4733 &(h->cmd_pool_dhandle));
4737 hba[i]->errinfo_pool = (ErrorInfo_struct *) 4734 h->errinfo_pool = (ErrorInfo_struct *)
4738 pci_alloc_consistent(hba[i]->pdev, 4735 pci_alloc_consistent(h->pdev,
4739 hba[i]->nr_cmds * sizeof(ErrorInfo_struct), 4736 h->nr_cmds * sizeof(ErrorInfo_struct),
4740 &(hba[i]->errinfo_pool_dhandle)); 4737 &(h->errinfo_pool_dhandle));
4741 if ((hba[i]->cmd_pool_bits == NULL) 4738 if ((h->cmd_pool_bits == NULL)
4742 || (hba[i]->cmd_pool == NULL) 4739 || (h->cmd_pool == NULL)
4743 || (hba[i]->errinfo_pool == NULL)) { 4740 || (h->errinfo_pool == NULL)) {
4744 printk(KERN_ERR "cciss: out of memory"); 4741 printk(KERN_ERR "cciss: out of memory");
4745 goto clean4; 4742 goto clean4;
4746 } 4743 }
4747 4744
4748 /* Need space for temp scatter list */ 4745 /* Need space for temp scatter list */
4749 hba[i]->scatter_list = kmalloc(hba[i]->max_commands * 4746 h->scatter_list = kmalloc(h->max_commands *
4750 sizeof(struct scatterlist *), 4747 sizeof(struct scatterlist *),
4751 GFP_KERNEL); 4748 GFP_KERNEL);
4752 for (k = 0; k < hba[i]->nr_cmds; k++) { 4749 for (k = 0; k < h->nr_cmds; k++) {
4753 hba[i]->scatter_list[k] = kmalloc(sizeof(struct scatterlist) * 4750 h->scatter_list[k] = kmalloc(sizeof(struct scatterlist) *
4754 hba[i]->maxsgentries, 4751 h->maxsgentries,
4755 GFP_KERNEL); 4752 GFP_KERNEL);
4756 if (hba[i]->scatter_list[k] == NULL) { 4753 if (h->scatter_list[k] == NULL) {
4757 printk(KERN_ERR "cciss%d: could not allocate " 4754 printk(KERN_ERR "cciss%d: could not allocate "
4758 "s/g lists\n", i); 4755 "s/g lists\n", i);
4759 goto clean4; 4756 goto clean4;
4760 } 4757 }
4761 } 4758 }
4762 hba[i]->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[i], 4759 h->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
4763 hba[i]->chainsize, hba[i]->nr_cmds); 4760 h->chainsize, h->nr_cmds);
4764 if (!hba[i]->cmd_sg_list && hba[i]->chainsize > 0) 4761 if (!h->cmd_sg_list && h->chainsize > 0)
4765 goto clean4; 4762 goto clean4;
4766 4763
4767 spin_lock_init(&hba[i]->lock); 4764 spin_lock_init(&h->lock);
4768 4765
4769 /* Initialize the pdev driver private data. 4766 /* Initialize the pdev driver private data.
4770 have it point to hba[i]. */ 4767 have it point to h. */
4771 pci_set_drvdata(pdev, hba[i]); 4768 pci_set_drvdata(pdev, h);
4772 /* command and error info recs zeroed out before 4769 /* command and error info recs zeroed out before
4773 they are used */ 4770 they are used */
4774 memset(hba[i]->cmd_pool_bits, 0, 4771 memset(h->cmd_pool_bits, 0,
4775 DIV_ROUND_UP(hba[i]->nr_cmds, BITS_PER_LONG) 4772 DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG)
4776 * sizeof(unsigned long)); 4773 * sizeof(unsigned long));
4777 4774
4778 hba[i]->num_luns = 0; 4775 h->num_luns = 0;
4779 hba[i]->highest_lun = -1; 4776 h->highest_lun = -1;
4780 for (j = 0; j < CISS_MAX_LUN; j++) { 4777 for (j = 0; j < CISS_MAX_LUN; j++) {
4781 hba[i]->drv[j] = NULL; 4778 h->drv[j] = NULL;
4782 hba[i]->gendisk[j] = NULL; 4779 h->gendisk[j] = NULL;
4783 } 4780 }
4784 4781
4785 cciss_scsi_setup(i); 4782 cciss_scsi_setup(h);
4786 4783
4787 /* Turn the interrupts on so we can service requests */ 4784 /* Turn the interrupts on so we can service requests */
4788 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON); 4785 h->access.set_intr_mask(h, CCISS_INTR_ON);
4789 4786
4790 /* Get the firmware version */ 4787 /* Get the firmware version */
4791 inq_buff = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL); 4788 inq_buff = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL);
@@ -4794,59 +4791,59 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
4794 goto clean4; 4791 goto clean4;
4795 } 4792 }
4796 4793
4797 return_code = sendcmd_withirq(CISS_INQUIRY, i, inq_buff, 4794 return_code = sendcmd_withirq(h, CISS_INQUIRY, inq_buff,
4798 sizeof(InquiryData_struct), 0, CTLR_LUNID, TYPE_CMD); 4795 sizeof(InquiryData_struct), 0, CTLR_LUNID, TYPE_CMD);
4799 if (return_code == IO_OK) { 4796 if (return_code == IO_OK) {
4800 hba[i]->firm_ver[0] = inq_buff->data_byte[32]; 4797 h->firm_ver[0] = inq_buff->data_byte[32];
4801 hba[i]->firm_ver[1] = inq_buff->data_byte[33]; 4798 h->firm_ver[1] = inq_buff->data_byte[33];
4802 hba[i]->firm_ver[2] = inq_buff->data_byte[34]; 4799 h->firm_ver[2] = inq_buff->data_byte[34];
4803 hba[i]->firm_ver[3] = inq_buff->data_byte[35]; 4800 h->firm_ver[3] = inq_buff->data_byte[35];
4804 } else { /* send command failed */ 4801 } else { /* send command failed */
4805 printk(KERN_WARNING "cciss: unable to determine firmware" 4802 printk(KERN_WARNING "cciss: unable to determine firmware"
4806 " version of controller\n"); 4803 " version of controller\n");
4807 } 4804 }
4808 kfree(inq_buff); 4805 kfree(inq_buff);
4809 4806
4810 cciss_procinit(i); 4807 cciss_procinit(h);
4811 4808
4812 hba[i]->cciss_max_sectors = 8192; 4809 h->cciss_max_sectors = 8192;
4813 4810
4814 rebuild_lun_table(hba[i], 1, 0); 4811 rebuild_lun_table(h, 1, 0);
4815 hba[i]->busy_initializing = 0; 4812 h->busy_initializing = 0;
4816 return 1; 4813 return 1;
4817 4814
4818clean4: 4815clean4:
4819 kfree(hba[i]->cmd_pool_bits); 4816 kfree(h->cmd_pool_bits);
4820 /* Free up sg elements */ 4817 /* Free up sg elements */
4821 for (k = 0; k < hba[i]->nr_cmds; k++) 4818 for (k = 0; k < h->nr_cmds; k++)
4822 kfree(hba[i]->scatter_list[k]); 4819 kfree(h->scatter_list[k]);
4823 kfree(hba[i]->scatter_list); 4820 kfree(h->scatter_list);
4824 cciss_free_sg_chain_blocks(hba[i]->cmd_sg_list, hba[i]->nr_cmds); 4821 cciss_free_sg_chain_blocks(h->cmd_sg_list, h->nr_cmds);
4825 if (hba[i]->cmd_pool) 4822 if (h->cmd_pool)
4826 pci_free_consistent(hba[i]->pdev, 4823 pci_free_consistent(h->pdev,
4827 hba[i]->nr_cmds * sizeof(CommandList_struct), 4824 h->nr_cmds * sizeof(CommandList_struct),
4828 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle); 4825 h->cmd_pool, h->cmd_pool_dhandle);
4829 if (hba[i]->errinfo_pool) 4826 if (h->errinfo_pool)
4830 pci_free_consistent(hba[i]->pdev, 4827 pci_free_consistent(h->pdev,
4831 hba[i]->nr_cmds * sizeof(ErrorInfo_struct), 4828 h->nr_cmds * sizeof(ErrorInfo_struct),
4832 hba[i]->errinfo_pool, 4829 h->errinfo_pool,
4833 hba[i]->errinfo_pool_dhandle); 4830 h->errinfo_pool_dhandle);
4834 free_irq(hba[i]->intr[PERF_MODE_INT], hba[i]); 4831 free_irq(h->intr[PERF_MODE_INT], h);
4835clean2: 4832clean2:
4836 unregister_blkdev(hba[i]->major, hba[i]->devname); 4833 unregister_blkdev(h->major, h->devname);
4837clean1: 4834clean1:
4838 cciss_destroy_hba_sysfs_entry(hba[i]); 4835 cciss_destroy_hba_sysfs_entry(h);
4839clean0: 4836clean0:
4840 pci_release_regions(pdev); 4837 pci_release_regions(pdev);
4841clean_no_release_regions: 4838clean_no_release_regions:
4842 hba[i]->busy_initializing = 0; 4839 h->busy_initializing = 0;
4843 4840
4844 /* 4841 /*
4845 * Deliberately omit pci_disable_device(): it does something nasty to 4842 * Deliberately omit pci_disable_device(): it does something nasty to
4846 * Smart Array controllers that pci_enable_device does not undo 4843 * Smart Array controllers that pci_enable_device does not undo
4847 */ 4844 */
4848 pci_set_drvdata(pdev, NULL); 4845 pci_set_drvdata(pdev, NULL);
4849 free_hba(i); 4846 free_hba(h);
4850 return -1; 4847 return -1;
4851} 4848}
4852 4849
@@ -4866,7 +4863,7 @@ static void cciss_shutdown(struct pci_dev *pdev)
4866 } 4863 }
4867 /* write all data in the battery backed cache to disk */ 4864 /* write all data in the battery backed cache to disk */
4868 memset(flush_buf, 0, 4); 4865 memset(flush_buf, 0, 4);
4869 return_code = sendcmd_withirq(CCISS_CACHE_FLUSH, h->ctlr, flush_buf, 4866 return_code = sendcmd_withirq(h, CCISS_CACHE_FLUSH, flush_buf,
4870 4, 0, CTLR_LUNID, TYPE_CMD); 4867 4, 0, CTLR_LUNID, TYPE_CMD);
4871 kfree(flush_buf); 4868 kfree(flush_buf);
4872 if (return_code != IO_OK) 4869 if (return_code != IO_OK)
@@ -4878,7 +4875,7 @@ static void cciss_shutdown(struct pci_dev *pdev)
4878 4875
4879static void __devexit cciss_remove_one(struct pci_dev *pdev) 4876static void __devexit cciss_remove_one(struct pci_dev *pdev)
4880{ 4877{
4881 ctlr_info_t *tmp_ptr; 4878 ctlr_info_t *h;
4882 int i, j; 4879 int i, j;
4883 4880
4884 if (pci_get_drvdata(pdev) == NULL) { 4881 if (pci_get_drvdata(pdev) == NULL) {
@@ -4886,28 +4883,28 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
4886 return; 4883 return;
4887 } 4884 }
4888 4885
4889 tmp_ptr = pci_get_drvdata(pdev); 4886 h = pci_get_drvdata(pdev);
4890 i = tmp_ptr->ctlr; 4887 i = h->ctlr;
4891 if (hba[i] == NULL) { 4888 if (hba[i] == NULL) {
4892 printk(KERN_ERR "cciss: device appears to " 4889 printk(KERN_ERR "cciss: device appears to "
4893 "already be removed \n"); 4890 "already be removed\n");
4894 return; 4891 return;
4895 } 4892 }
4896 4893
4897 mutex_lock(&hba[i]->busy_shutting_down); 4894 mutex_lock(&h->busy_shutting_down);
4898 4895
4899 remove_from_scan_list(hba[i]); 4896 remove_from_scan_list(h);
4900 remove_proc_entry(hba[i]->devname, proc_cciss); 4897 remove_proc_entry(h->devname, proc_cciss);
4901 unregister_blkdev(hba[i]->major, hba[i]->devname); 4898 unregister_blkdev(h->major, h->devname);
4902 4899
4903 /* remove it from the disk list */ 4900 /* remove it from the disk list */
4904 for (j = 0; j < CISS_MAX_LUN; j++) { 4901 for (j = 0; j < CISS_MAX_LUN; j++) {
4905 struct gendisk *disk = hba[i]->gendisk[j]; 4902 struct gendisk *disk = h->gendisk[j];
4906 if (disk) { 4903 if (disk) {
4907 struct request_queue *q = disk->queue; 4904 struct request_queue *q = disk->queue;
4908 4905
4909 if (disk->flags & GENHD_FL_UP) { 4906 if (disk->flags & GENHD_FL_UP) {
4910 cciss_destroy_ld_sysfs_entry(hba[i], j, 1); 4907 cciss_destroy_ld_sysfs_entry(h, j, 1);
4911 del_gendisk(disk); 4908 del_gendisk(disk);
4912 } 4909 }
4913 if (q) 4910 if (q)
@@ -4916,41 +4913,41 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
4916 } 4913 }
4917 4914
4918#ifdef CONFIG_CISS_SCSI_TAPE 4915#ifdef CONFIG_CISS_SCSI_TAPE
4919 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */ 4916 cciss_unregister_scsi(h); /* unhook from SCSI subsystem */
4920#endif 4917#endif
4921 4918
4922 cciss_shutdown(pdev); 4919 cciss_shutdown(pdev);
4923 4920
4924#ifdef CONFIG_PCI_MSI 4921#ifdef CONFIG_PCI_MSI
4925 if (hba[i]->msix_vector) 4922 if (h->msix_vector)
4926 pci_disable_msix(hba[i]->pdev); 4923 pci_disable_msix(h->pdev);
4927 else if (hba[i]->msi_vector) 4924 else if (h->msi_vector)
4928 pci_disable_msi(hba[i]->pdev); 4925 pci_disable_msi(h->pdev);
4929#endif /* CONFIG_PCI_MSI */ 4926#endif /* CONFIG_PCI_MSI */
4930 4927
4931 iounmap(hba[i]->transtable); 4928 iounmap(h->transtable);
4932 iounmap(hba[i]->cfgtable); 4929 iounmap(h->cfgtable);
4933 iounmap(hba[i]->vaddr); 4930 iounmap(h->vaddr);
4934 4931
4935 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct), 4932 pci_free_consistent(h->pdev, h->nr_cmds * sizeof(CommandList_struct),
4936 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle); 4933 h->cmd_pool, h->cmd_pool_dhandle);
4937 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct), 4934 pci_free_consistent(h->pdev, h->nr_cmds * sizeof(ErrorInfo_struct),
4938 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle); 4935 h->errinfo_pool, h->errinfo_pool_dhandle);
4939 kfree(hba[i]->cmd_pool_bits); 4936 kfree(h->cmd_pool_bits);
4940 /* Free up sg elements */ 4937 /* Free up sg elements */
4941 for (j = 0; j < hba[i]->nr_cmds; j++) 4938 for (j = 0; j < h->nr_cmds; j++)
4942 kfree(hba[i]->scatter_list[j]); 4939 kfree(h->scatter_list[j]);
4943 kfree(hba[i]->scatter_list); 4940 kfree(h->scatter_list);
4944 cciss_free_sg_chain_blocks(hba[i]->cmd_sg_list, hba[i]->nr_cmds); 4941 cciss_free_sg_chain_blocks(h->cmd_sg_list, h->nr_cmds);
4945 /* 4942 /*
4946 * Deliberately omit pci_disable_device(): it does something nasty to 4943 * Deliberately omit pci_disable_device(): it does something nasty to
4947 * Smart Array controllers that pci_enable_device does not undo 4944 * Smart Array controllers that pci_enable_device does not undo
4948 */ 4945 */
4949 pci_release_regions(pdev); 4946 pci_release_regions(pdev);
4950 pci_set_drvdata(pdev, NULL); 4947 pci_set_drvdata(pdev, NULL);
4951 cciss_destroy_hba_sysfs_entry(hba[i]); 4948 cciss_destroy_hba_sysfs_entry(h);
4952 mutex_unlock(&hba[i]->busy_shutting_down); 4949 mutex_unlock(&h->busy_shutting_down);
4953 free_hba(i); 4950 free_hba(h);
4954} 4951}
4955 4952
4956static struct pci_driver cciss_pci_driver = { 4953static struct pci_driver cciss_pci_driver = {
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index 4290b7f0f639..ae340ffc8f81 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -419,6 +419,4 @@ struct board_type {
419 int nr_cmds; /* Max cmds this kind of ctlr can handle. */ 419 int nr_cmds; /* Max cmds this kind of ctlr can handle. */
420}; 420};
421 421
422#define CCISS_LOCK(i) (&hba[i]->lock)
423
424#endif /* CCISS_H */ 422#endif /* CCISS_H */
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index 3604b72f2af9..9133ad4c7b1b 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -44,7 +44,7 @@
44#define CCISS_ABORT_MSG 0x00 44#define CCISS_ABORT_MSG 0x00
45#define CCISS_RESET_MSG 0x01 45#define CCISS_RESET_MSG 0x01
46 46
47static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, 47static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff,
48 size_t size, 48 size_t size,
49 __u8 page_code, unsigned char *scsi3addr, 49 __u8 page_code, unsigned char *scsi3addr,
50 int cmd_type); 50 int cmd_type);
@@ -127,16 +127,16 @@ struct cciss_scsi_adapter_data_t {
127 spinlock_t lock; // to protect ccissscsi[ctlr]; 127 spinlock_t lock; // to protect ccissscsi[ctlr];
128}; 128};
129 129
130#define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \ 130#define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
131 &hba[ctlr]->scsi_ctlr->lock, flags); 131 &h->scsi_ctlr->lock, flags);
132#define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \ 132#define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
133 &hba[ctlr]->scsi_ctlr->lock, flags); 133 &h->scsi_ctlr->lock, flags);
134 134
135static CommandList_struct * 135static CommandList_struct *
136scsi_cmd_alloc(ctlr_info_t *h) 136scsi_cmd_alloc(ctlr_info_t *h)
137{ 137{
138 /* assume only one process in here at a time, locking done by caller. */ 138 /* assume only one process in here at a time, locking done by caller. */
139 /* use CCISS_LOCK(ctlr) */ 139 /* use h->lock */
140 /* might be better to rewrite how we allocate scsi commands in a way that */ 140 /* might be better to rewrite how we allocate scsi commands in a way that */
141 /* needs no locking at all. */ 141 /* needs no locking at all. */
142 142
@@ -177,10 +177,10 @@ scsi_cmd_alloc(ctlr_info_t *h)
177} 177}
178 178
179static void 179static void
180scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd) 180scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c)
181{ 181{
182 /* assume only one process in here at a time, locking done by caller. */ 182 /* assume only one process in here at a time, locking done by caller. */
183 /* use CCISS_LOCK(ctlr) */ 183 /* use h->lock */
184 /* drop the free memory chunk on top of the stack. */ 184 /* drop the free memory chunk on top of the stack. */
185 185
186 struct cciss_scsi_adapter_data_t *sa; 186 struct cciss_scsi_adapter_data_t *sa;
@@ -193,19 +193,19 @@ scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
193 printk("cciss: scsi_cmd_free called too many times.\n"); 193 printk("cciss: scsi_cmd_free called too many times.\n");
194 BUG(); 194 BUG();
195 } 195 }
196 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd; 196 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c;
197} 197}
198 198
199static int 199static int
200scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa) 200scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa)
201{ 201{
202 int i; 202 int i;
203 struct cciss_scsi_cmd_stack_t *stk; 203 struct cciss_scsi_cmd_stack_t *stk;
204 size_t size; 204 size_t size;
205 205
206 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[ctlr], 206 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
207 hba[ctlr]->chainsize, CMD_STACK_SIZE); 207 h->chainsize, CMD_STACK_SIZE);
208 if (!sa->cmd_sg_list && hba[ctlr]->chainsize > 0) 208 if (!sa->cmd_sg_list && h->chainsize > 0)
209 return -ENOMEM; 209 return -ENOMEM;
210 210
211 stk = &sa->cmd_stack; 211 stk = &sa->cmd_stack;
@@ -215,7 +215,7 @@ scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
215 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0); 215 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
216 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */ 216 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
217 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *) 217 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
218 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle); 218 pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle);
219 219
220 if (stk->pool == NULL) { 220 if (stk->pool == NULL) {
221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE); 221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
@@ -234,13 +234,13 @@ scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
234} 234}
235 235
236static void 236static void
237scsi_cmd_stack_free(int ctlr) 237scsi_cmd_stack_free(ctlr_info_t *h)
238{ 238{
239 struct cciss_scsi_adapter_data_t *sa; 239 struct cciss_scsi_adapter_data_t *sa;
240 struct cciss_scsi_cmd_stack_t *stk; 240 struct cciss_scsi_cmd_stack_t *stk;
241 size_t size; 241 size_t size;
242 242
243 sa = hba[ctlr]->scsi_ctlr; 243 sa = h->scsi_ctlr;
244 stk = &sa->cmd_stack; 244 stk = &sa->cmd_stack;
245 if (stk->top != CMD_STACK_SIZE-1) { 245 if (stk->top != CMD_STACK_SIZE-1) {
246 printk( "cciss: %d scsi commands are still outstanding.\n", 246 printk( "cciss: %d scsi commands are still outstanding.\n",
@@ -250,7 +250,7 @@ scsi_cmd_stack_free(int ctlr)
250 } 250 }
251 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE; 251 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
252 252
253 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle); 253 pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle);
254 stk->pool = NULL; 254 stk->pool = NULL;
255 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE); 255 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
256} 256}
@@ -342,20 +342,20 @@ print_cmd(CommandList_struct *cp)
342#endif 342#endif
343 343
344static int 344static int
345find_bus_target_lun(int ctlr, int *bus, int *target, int *lun) 345find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun)
346{ 346{
347 /* finds an unused bus, target, lun for a new device */ 347 /* finds an unused bus, target, lun for a new device */
348 /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 348 /* assumes h->scsi_ctlr->lock is held */
349 int i, found=0; 349 int i, found=0;
350 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA]; 350 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
351 351
352 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA); 352 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
353 353
354 target_taken[SELF_SCSI_ID] = 1; 354 target_taken[SELF_SCSI_ID] = 1;
355 for (i=0;i<ccissscsi[ctlr].ndevices;i++) 355 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++)
356 target_taken[ccissscsi[ctlr].dev[i].target] = 1; 356 target_taken[ccissscsi[h->ctlr].dev[i].target] = 1;
357 357
358 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) { 358 for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) {
359 if (!target_taken[i]) { 359 if (!target_taken[i]) {
360 *bus = 0; *target=i; *lun = 0; found=1; 360 *bus = 0; *target=i; *lun = 0; found=1;
361 break; 361 break;
@@ -369,19 +369,19 @@ struct scsi2map {
369}; 369};
370 370
371static int 371static int
372cciss_scsi_add_entry(int ctlr, int hostno, 372cciss_scsi_add_entry(ctlr_info_t *h, int hostno,
373 struct cciss_scsi_dev_t *device, 373 struct cciss_scsi_dev_t *device,
374 struct scsi2map *added, int *nadded) 374 struct scsi2map *added, int *nadded)
375{ 375{
376 /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 376 /* assumes h->scsi_ctlr->lock is held */
377 int n = ccissscsi[ctlr].ndevices; 377 int n = ccissscsi[h->ctlr].ndevices;
378 struct cciss_scsi_dev_t *sd; 378 struct cciss_scsi_dev_t *sd;
379 int i, bus, target, lun; 379 int i, bus, target, lun;
380 unsigned char addr1[8], addr2[8]; 380 unsigned char addr1[8], addr2[8];
381 381
382 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) { 382 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
383 printk("cciss%d: Too many devices, " 383 printk("cciss%d: Too many devices, "
384 "some will be inaccessible.\n", ctlr); 384 "some will be inaccessible.\n", h->ctlr);
385 return -1; 385 return -1;
386 } 386 }
387 387
@@ -397,7 +397,7 @@ cciss_scsi_add_entry(int ctlr, int hostno,
397 memcpy(addr1, device->scsi3addr, 8); 397 memcpy(addr1, device->scsi3addr, 8);
398 addr1[4] = 0; 398 addr1[4] = 0;
399 for (i = 0; i < n; i++) { 399 for (i = 0; i < n; i++) {
400 sd = &ccissscsi[ctlr].dev[i]; 400 sd = &ccissscsi[h->ctlr].dev[i];
401 memcpy(addr2, sd->scsi3addr, 8); 401 memcpy(addr2, sd->scsi3addr, 8);
402 addr2[4] = 0; 402 addr2[4] = 0;
403 /* differ only in byte 4? */ 403 /* differ only in byte 4? */
@@ -410,9 +410,9 @@ cciss_scsi_add_entry(int ctlr, int hostno,
410 } 410 }
411 } 411 }
412 412
413 sd = &ccissscsi[ctlr].dev[n]; 413 sd = &ccissscsi[h->ctlr].dev[n];
414 if (lun == 0) { 414 if (lun == 0) {
415 if (find_bus_target_lun(ctlr, 415 if (find_bus_target_lun(h,
416 &sd->bus, &sd->target, &sd->lun) != 0) 416 &sd->bus, &sd->target, &sd->lun) != 0)
417 return -1; 417 return -1;
418 } else { 418 } else {
@@ -431,37 +431,37 @@ cciss_scsi_add_entry(int ctlr, int hostno,
431 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id)); 431 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
432 sd->devtype = device->devtype; 432 sd->devtype = device->devtype;
433 433
434 ccissscsi[ctlr].ndevices++; 434 ccissscsi[h->ctlr].ndevices++;
435 435
436 /* initially, (before registering with scsi layer) we don't 436 /* initially, (before registering with scsi layer) we don't
437 know our hostno and we don't want to print anything first 437 know our hostno and we don't want to print anything first
438 time anyway (the scsi layer's inquiries will show that info) */ 438 time anyway (the scsi layer's inquiries will show that info) */
439 if (hostno != -1) 439 if (hostno != -1)
440 printk("cciss%d: %s device c%db%dt%dl%d added.\n", 440 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
441 ctlr, scsi_device_type(sd->devtype), hostno, 441 h->ctlr, scsi_device_type(sd->devtype), hostno,
442 sd->bus, sd->target, sd->lun); 442 sd->bus, sd->target, sd->lun);
443 return 0; 443 return 0;
444} 444}
445 445
446static void 446static void
447cciss_scsi_remove_entry(int ctlr, int hostno, int entry, 447cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry,
448 struct scsi2map *removed, int *nremoved) 448 struct scsi2map *removed, int *nremoved)
449{ 449{
450 /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 450 /* assumes h->ctlr]->scsi_ctlr->lock is held */
451 int i; 451 int i;
452 struct cciss_scsi_dev_t sd; 452 struct cciss_scsi_dev_t sd;
453 453
454 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return; 454 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
455 sd = ccissscsi[ctlr].dev[entry]; 455 sd = ccissscsi[h->ctlr].dev[entry];
456 removed[*nremoved].bus = sd.bus; 456 removed[*nremoved].bus = sd.bus;
457 removed[*nremoved].target = sd.target; 457 removed[*nremoved].target = sd.target;
458 removed[*nremoved].lun = sd.lun; 458 removed[*nremoved].lun = sd.lun;
459 (*nremoved)++; 459 (*nremoved)++;
460 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++) 460 for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++)
461 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1]; 461 ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1];
462 ccissscsi[ctlr].ndevices--; 462 ccissscsi[h->ctlr].ndevices--;
463 printk("cciss%d: %s device c%db%dt%dl%d removed.\n", 463 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
464 ctlr, scsi_device_type(sd.devtype), hostno, 464 h->ctlr, scsi_device_type(sd.devtype), hostno,
465 sd.bus, sd.target, sd.lun); 465 sd.bus, sd.target, sd.lun);
466} 466}
467 467
@@ -476,24 +476,24 @@ cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
476 (a)[1] == (b)[1] && \ 476 (a)[1] == (b)[1] && \
477 (a)[0] == (b)[0]) 477 (a)[0] == (b)[0])
478 478
479static void fixup_botched_add(int ctlr, char *scsi3addr) 479static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr)
480{ 480{
481 /* called when scsi_add_device fails in order to re-adjust */ 481 /* called when scsi_add_device fails in order to re-adjust */
482 /* ccissscsi[] to match the mid layer's view. */ 482 /* ccissscsi[] to match the mid layer's view. */
483 unsigned long flags; 483 unsigned long flags;
484 int i, j; 484 int i, j;
485 CPQ_TAPE_LOCK(ctlr, flags); 485 CPQ_TAPE_LOCK(h, flags);
486 for (i = 0; i < ccissscsi[ctlr].ndevices; i++) { 486 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
487 if (memcmp(scsi3addr, 487 if (memcmp(scsi3addr,
488 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) { 488 ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) {
489 for (j = i; j < ccissscsi[ctlr].ndevices-1; j++) 489 for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++)
490 ccissscsi[ctlr].dev[j] = 490 ccissscsi[h->ctlr].dev[j] =
491 ccissscsi[ctlr].dev[j+1]; 491 ccissscsi[h->ctlr].dev[j+1];
492 ccissscsi[ctlr].ndevices--; 492 ccissscsi[h->ctlr].ndevices--;
493 break; 493 break;
494 } 494 }
495 } 495 }
496 CPQ_TAPE_UNLOCK(ctlr, flags); 496 CPQ_TAPE_UNLOCK(h, flags);
497} 497}
498 498
499static int device_is_the_same(struct cciss_scsi_dev_t *dev1, 499static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
@@ -513,7 +513,7 @@ static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
513} 513}
514 514
515static int 515static int
516adjust_cciss_scsi_table(int ctlr, int hostno, 516adjust_cciss_scsi_table(ctlr_info_t *h, int hostno,
517 struct cciss_scsi_dev_t sd[], int nsds) 517 struct cciss_scsi_dev_t sd[], int nsds)
518{ 518{
519 /* sd contains scsi3 addresses and devtypes, but 519 /* sd contains scsi3 addresses and devtypes, but
@@ -535,14 +535,14 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
535 535
536 if (!added || !removed) { 536 if (!added || !removed) {
537 printk(KERN_WARNING "cciss%d: Out of memory in " 537 printk(KERN_WARNING "cciss%d: Out of memory in "
538 "adjust_cciss_scsi_table\n", ctlr); 538 "adjust_cciss_scsi_table\n", h->ctlr);
539 goto free_and_out; 539 goto free_and_out;
540 } 540 }
541 541
542 CPQ_TAPE_LOCK(ctlr, flags); 542 CPQ_TAPE_LOCK(h, flags);
543 543
544 if (hostno != -1) /* if it's not the first time... */ 544 if (hostno != -1) /* if it's not the first time... */
545 sh = hba[ctlr]->scsi_ctlr->scsi_host; 545 sh = h->scsi_ctlr->scsi_host;
546 546
547 /* find any devices in ccissscsi[] that are not in 547 /* find any devices in ccissscsi[] that are not in
548 sd[] and remove them from ccissscsi[] */ 548 sd[] and remove them from ccissscsi[] */
@@ -550,8 +550,8 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
550 i = 0; 550 i = 0;
551 nremoved = 0; 551 nremoved = 0;
552 nadded = 0; 552 nadded = 0;
553 while(i<ccissscsi[ctlr].ndevices) { 553 while (i < ccissscsi[h->ctlr].ndevices) {
554 csd = &ccissscsi[ctlr].dev[i]; 554 csd = &ccissscsi[h->ctlr].dev[i];
555 found=0; 555 found=0;
556 for (j=0;j<nsds;j++) { 556 for (j=0;j<nsds;j++) {
557 if (SCSI3ADDR_EQ(sd[j].scsi3addr, 557 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
@@ -567,19 +567,20 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
567 if (found == 0) { /* device no longer present. */ 567 if (found == 0) { /* device no longer present. */
568 changes++; 568 changes++;
569 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n", 569 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
570 ctlr, scsi_device_type(csd->devtype), hostno, 570 h->ctlr, scsi_device_type(csd->devtype), hostno,
571 csd->bus, csd->target, csd->lun); */ 571 csd->bus, csd->target, csd->lun); */
572 cciss_scsi_remove_entry(ctlr, hostno, i, 572 cciss_scsi_remove_entry(h, hostno, i,
573 removed, &nremoved); 573 removed, &nremoved);
574 /* remove ^^^, hence i not incremented */ 574 /* remove ^^^, hence i not incremented */
575 } else if (found == 1) { /* device is different in some way */ 575 } else if (found == 1) { /* device is different in some way */
576 changes++; 576 changes++;
577 printk("cciss%d: device c%db%dt%dl%d has changed.\n", 577 printk("cciss%d: device c%db%dt%dl%d has changed.\n",
578 ctlr, hostno, csd->bus, csd->target, csd->lun); 578 h->ctlr, hostno,
579 cciss_scsi_remove_entry(ctlr, hostno, i, 579 csd->bus, csd->target, csd->lun);
580 cciss_scsi_remove_entry(h, hostno, i,
580 removed, &nremoved); 581 removed, &nremoved);
581 /* remove ^^^, hence i not incremented */ 582 /* remove ^^^, hence i not incremented */
582 if (cciss_scsi_add_entry(ctlr, hostno, &sd[j], 583 if (cciss_scsi_add_entry(h, hostno, &sd[j],
583 added, &nadded) != 0) 584 added, &nadded) != 0)
584 /* we just removed one, so add can't fail. */ 585 /* we just removed one, so add can't fail. */
585 BUG(); 586 BUG();
@@ -601,8 +602,8 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
601 602
602 for (i=0;i<nsds;i++) { 603 for (i=0;i<nsds;i++) {
603 found=0; 604 found=0;
604 for (j=0;j<ccissscsi[ctlr].ndevices;j++) { 605 for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) {
605 csd = &ccissscsi[ctlr].dev[j]; 606 csd = &ccissscsi[h->ctlr].dev[j];
606 if (SCSI3ADDR_EQ(sd[i].scsi3addr, 607 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
607 csd->scsi3addr)) { 608 csd->scsi3addr)) {
608 if (device_is_the_same(&sd[i], csd)) 609 if (device_is_the_same(&sd[i], csd))
@@ -614,18 +615,18 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
614 } 615 }
615 if (!found) { 616 if (!found) {
616 changes++; 617 changes++;
617 if (cciss_scsi_add_entry(ctlr, hostno, &sd[i], 618 if (cciss_scsi_add_entry(h, hostno, &sd[i],
618 added, &nadded) != 0) 619 added, &nadded) != 0)
619 break; 620 break;
620 } else if (found == 1) { 621 } else if (found == 1) {
621 /* should never happen... */ 622 /* should never happen... */
622 changes++; 623 changes++;
623 printk(KERN_WARNING "cciss%d: device " 624 printk(KERN_WARNING "cciss%d: device "
624 "unexpectedly changed\n", ctlr); 625 "unexpectedly changed\n", h->ctlr);
625 /* but if it does happen, we just ignore that device */ 626 /* but if it does happen, we just ignore that device */
626 } 627 }
627 } 628 }
628 CPQ_TAPE_UNLOCK(ctlr, flags); 629 CPQ_TAPE_UNLOCK(h, flags);
629 630
630 /* Don't notify scsi mid layer of any changes the first time through */ 631 /* Don't notify scsi mid layer of any changes the first time through */
631 /* (or if there are no changes) scsi_scan_host will do it later the */ 632 /* (or if there are no changes) scsi_scan_host will do it later the */
@@ -647,7 +648,7 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
647 /* timeout as if the device was gone. */ 648 /* timeout as if the device was gone. */
648 printk(KERN_WARNING "cciss%d: didn't find " 649 printk(KERN_WARNING "cciss%d: didn't find "
649 "c%db%dt%dl%d\n for removal.", 650 "c%db%dt%dl%d\n for removal.",
650 ctlr, hostno, removed[i].bus, 651 h->ctlr, hostno, removed[i].bus,
651 removed[i].target, removed[i].lun); 652 removed[i].target, removed[i].lun);
652 } 653 }
653 } 654 }
@@ -661,11 +662,11 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
661 continue; 662 continue;
662 printk(KERN_WARNING "cciss%d: scsi_add_device " 663 printk(KERN_WARNING "cciss%d: scsi_add_device "
663 "c%db%dt%dl%d failed, device not added.\n", 664 "c%db%dt%dl%d failed, device not added.\n",
664 ctlr, hostno, 665 h->ctlr, hostno,
665 added[i].bus, added[i].target, added[i].lun); 666 added[i].bus, added[i].target, added[i].lun);
666 /* now we have to remove it from ccissscsi, */ 667 /* now we have to remove it from ccissscsi, */
667 /* since it didn't get added to scsi mid layer */ 668 /* since it didn't get added to scsi mid layer */
668 fixup_botched_add(ctlr, added[i].scsi3addr); 669 fixup_botched_add(h, added[i].scsi3addr);
669 } 670 }
670 671
671free_and_out: 672free_and_out:
@@ -675,33 +676,33 @@ free_and_out:
675} 676}
676 677
677static int 678static int
678lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr) 679lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr)
679{ 680{
680 int i; 681 int i;
681 struct cciss_scsi_dev_t *sd; 682 struct cciss_scsi_dev_t *sd;
682 unsigned long flags; 683 unsigned long flags;
683 684
684 CPQ_TAPE_LOCK(ctlr, flags); 685 CPQ_TAPE_LOCK(h, flags);
685 for (i=0;i<ccissscsi[ctlr].ndevices;i++) { 686 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
686 sd = &ccissscsi[ctlr].dev[i]; 687 sd = &ccissscsi[h->ctlr].dev[i];
687 if (sd->bus == bus && 688 if (sd->bus == bus &&
688 sd->target == target && 689 sd->target == target &&
689 sd->lun == lun) { 690 sd->lun == lun) {
690 memcpy(scsi3addr, &sd->scsi3addr[0], 8); 691 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
691 CPQ_TAPE_UNLOCK(ctlr, flags); 692 CPQ_TAPE_UNLOCK(h, flags);
692 return 0; 693 return 0;
693 } 694 }
694 } 695 }
695 CPQ_TAPE_UNLOCK(ctlr, flags); 696 CPQ_TAPE_UNLOCK(h, flags);
696 return -1; 697 return -1;
697} 698}
698 699
699static void 700static void
700cciss_scsi_setup(int cntl_num) 701cciss_scsi_setup(ctlr_info_t *h)
701{ 702{
702 struct cciss_scsi_adapter_data_t * shba; 703 struct cciss_scsi_adapter_data_t * shba;
703 704
704 ccissscsi[cntl_num].ndevices = 0; 705 ccissscsi[h->ctlr].ndevices = 0;
705 shba = (struct cciss_scsi_adapter_data_t *) 706 shba = (struct cciss_scsi_adapter_data_t *)
706 kmalloc(sizeof(*shba), GFP_KERNEL); 707 kmalloc(sizeof(*shba), GFP_KERNEL);
707 if (shba == NULL) 708 if (shba == NULL)
@@ -709,35 +710,35 @@ cciss_scsi_setup(int cntl_num)
709 shba->scsi_host = NULL; 710 shba->scsi_host = NULL;
710 spin_lock_init(&shba->lock); 711 spin_lock_init(&shba->lock);
711 shba->registered = 0; 712 shba->registered = 0;
712 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) { 713 if (scsi_cmd_stack_setup(h, shba) != 0) {
713 kfree(shba); 714 kfree(shba);
714 shba = NULL; 715 shba = NULL;
715 } 716 }
716 hba[cntl_num]->scsi_ctlr = shba; 717 h->scsi_ctlr = shba;
717 return; 718 return;
718} 719}
719 720
720static void 721static void complete_scsi_command(CommandList_struct *c, int timeout,
721complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag) 722 __u32 tag)
722{ 723{
723 struct scsi_cmnd *cmd; 724 struct scsi_cmnd *cmd;
724 ctlr_info_t *ctlr; 725 ctlr_info_t *h;
725 ErrorInfo_struct *ei; 726 ErrorInfo_struct *ei;
726 727
727 ei = cp->err_info; 728 ei = c->err_info;
728 729
729 /* First, see if it was a message rather than a command */ 730 /* First, see if it was a message rather than a command */
730 if (cp->Request.Type.Type == TYPE_MSG) { 731 if (c->Request.Type.Type == TYPE_MSG) {
731 cp->cmd_type = CMD_MSG_DONE; 732 c->cmd_type = CMD_MSG_DONE;
732 return; 733 return;
733 } 734 }
734 735
735 cmd = (struct scsi_cmnd *) cp->scsi_cmd; 736 cmd = (struct scsi_cmnd *) c->scsi_cmd;
736 ctlr = hba[cp->ctlr]; 737 h = hba[c->ctlr];
737 738
738 scsi_dma_unmap(cmd); 739 scsi_dma_unmap(cmd);
739 if (cp->Header.SGTotal > ctlr->max_cmd_sgentries) 740 if (c->Header.SGTotal > h->max_cmd_sgentries)
740 cciss_unmap_sg_chain_block(ctlr, cp); 741 cciss_unmap_sg_chain_block(h, c);
741 742
742 cmd->result = (DID_OK << 16); /* host byte */ 743 cmd->result = (DID_OK << 16); /* host byte */
743 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */ 744 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
@@ -764,9 +765,8 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
764 { 765 {
765#if 0 766#if 0
766 printk(KERN_WARNING "cciss: cmd %p " 767 printk(KERN_WARNING "cciss: cmd %p "
767 "has SCSI Status = %x\n", 768 "has SCSI Status = %x\n",
768 cp, 769 c, ei->ScsiStatus);
769 ei->ScsiStatus);
770#endif 770#endif
771 cmd->result |= (ei->ScsiStatus << 1); 771 cmd->result |= (ei->ScsiStatus << 1);
772 } 772 }
@@ -786,13 +786,13 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
786 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ 786 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
787 break; 787 break;
788 case CMD_DATA_OVERRUN: 788 case CMD_DATA_OVERRUN:
789 printk(KERN_WARNING "cciss: cp %p has" 789 printk(KERN_WARNING "cciss: %p has"
790 " completed with data overrun " 790 " completed with data overrun "
791 "reported\n", cp); 791 "reported\n", c);
792 break; 792 break;
793 case CMD_INVALID: { 793 case CMD_INVALID: {
794 /* print_bytes(cp, sizeof(*cp), 1, 0); 794 /* print_bytes(c, sizeof(*c), 1, 0);
795 print_cmd(cp); */ 795 print_cmd(c); */
796 /* We get CMD_INVALID if you address a non-existent tape drive instead 796 /* We get CMD_INVALID if you address a non-existent tape drive instead
797 of a selection timeout (no response). You will see this if you yank 797 of a selection timeout (no response). You will see this if you yank
798 out a tape drive, then try to access it. This is kind of a shame 798 out a tape drive, then try to access it. This is kind of a shame
@@ -802,54 +802,52 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
802 } 802 }
803 break; 803 break;
804 case CMD_PROTOCOL_ERR: 804 case CMD_PROTOCOL_ERR:
805 printk(KERN_WARNING "cciss: cp %p has " 805 printk(KERN_WARNING "cciss: %p has "
806 "protocol error \n", cp); 806 "protocol error\n", c);
807 break; 807 break;
808 case CMD_HARDWARE_ERR: 808 case CMD_HARDWARE_ERR:
809 cmd->result = DID_ERROR << 16; 809 cmd->result = DID_ERROR << 16;
810 printk(KERN_WARNING "cciss: cp %p had " 810 printk(KERN_WARNING "cciss: %p had "
811 " hardware error\n", cp); 811 " hardware error\n", c);
812 break; 812 break;
813 case CMD_CONNECTION_LOST: 813 case CMD_CONNECTION_LOST:
814 cmd->result = DID_ERROR << 16; 814 cmd->result = DID_ERROR << 16;
815 printk(KERN_WARNING "cciss: cp %p had " 815 printk(KERN_WARNING "cciss: %p had "
816 "connection lost\n", cp); 816 "connection lost\n", c);
817 break; 817 break;
818 case CMD_ABORTED: 818 case CMD_ABORTED:
819 cmd->result = DID_ABORT << 16; 819 cmd->result = DID_ABORT << 16;
820 printk(KERN_WARNING "cciss: cp %p was " 820 printk(KERN_WARNING "cciss: %p was "
821 "aborted\n", cp); 821 "aborted\n", c);
822 break; 822 break;
823 case CMD_ABORT_FAILED: 823 case CMD_ABORT_FAILED:
824 cmd->result = DID_ERROR << 16; 824 cmd->result = DID_ERROR << 16;
825 printk(KERN_WARNING "cciss: cp %p reports " 825 printk(KERN_WARNING "cciss: %p reports "
826 "abort failed\n", cp); 826 "abort failed\n", c);
827 break; 827 break;
828 case CMD_UNSOLICITED_ABORT: 828 case CMD_UNSOLICITED_ABORT:
829 cmd->result = DID_ABORT << 16; 829 cmd->result = DID_ABORT << 16;
830 printk(KERN_WARNING "cciss: cp %p aborted " 830 printk(KERN_WARNING "cciss: %p aborted "
831 "do to an unsolicited abort\n", cp); 831 "do to an unsolicited abort\n", c);
832 break; 832 break;
833 case CMD_TIMEOUT: 833 case CMD_TIMEOUT:
834 cmd->result = DID_TIME_OUT << 16; 834 cmd->result = DID_TIME_OUT << 16;
835 printk(KERN_WARNING "cciss: cp %p timedout\n", 835 printk(KERN_WARNING "cciss: %p timedout\n",
836 cp); 836 c);
837 break; 837 break;
838 default: 838 default:
839 cmd->result = DID_ERROR << 16; 839 cmd->result = DID_ERROR << 16;
840 printk(KERN_WARNING "cciss: cp %p returned " 840 printk(KERN_WARNING "cciss: %p returned "
841 "unknown status %x\n", cp, 841 "unknown status %x\n", c,
842 ei->CommandStatus); 842 ei->CommandStatus);
843 } 843 }
844 } 844 }
845 // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
846 // cmd->target, cmd->lun);
847 cmd->scsi_done(cmd); 845 cmd->scsi_done(cmd);
848 scsi_cmd_free(ctlr, cp); 846 scsi_cmd_free(h, c);
849} 847}
850 848
851static int 849static int
852cciss_scsi_detect(int ctlr) 850cciss_scsi_detect(ctlr_info_t *h)
853{ 851{
854 struct Scsi_Host *sh; 852 struct Scsi_Host *sh;
855 int error; 853 int error;
@@ -860,15 +858,15 @@ cciss_scsi_detect(int ctlr)
860 sh->io_port = 0; // good enough? FIXME, 858 sh->io_port = 0; // good enough? FIXME,
861 sh->n_io_port = 0; // I don't think we use these two... 859 sh->n_io_port = 0; // I don't think we use these two...
862 sh->this_id = SELF_SCSI_ID; 860 sh->this_id = SELF_SCSI_ID;
863 sh->sg_tablesize = hba[ctlr]->maxsgentries; 861 sh->sg_tablesize = h->maxsgentries;
864 sh->max_cmd_len = MAX_COMMAND_SIZE; 862 sh->max_cmd_len = MAX_COMMAND_SIZE;
865 863
866 ((struct cciss_scsi_adapter_data_t *) 864 ((struct cciss_scsi_adapter_data_t *)
867 hba[ctlr]->scsi_ctlr)->scsi_host = sh; 865 h->scsi_ctlr)->scsi_host = sh;
868 sh->hostdata[0] = (unsigned long) hba[ctlr]; 866 sh->hostdata[0] = (unsigned long) h;
869 sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT]; 867 sh->irq = h->intr[SIMPLE_MODE_INT];
870 sh->unique_id = sh->irq; 868 sh->unique_id = sh->irq;
871 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev); 869 error = scsi_add_host(sh, &h->pdev->dev);
872 if (error) 870 if (error)
873 goto fail_host_put; 871 goto fail_host_put;
874 scsi_scan_host(sh); 872 scsi_scan_host(sh);
@@ -882,20 +880,20 @@ cciss_scsi_detect(int ctlr)
882 880
883static void 881static void
884cciss_unmap_one(struct pci_dev *pdev, 882cciss_unmap_one(struct pci_dev *pdev,
885 CommandList_struct *cp, 883 CommandList_struct *c,
886 size_t buflen, 884 size_t buflen,
887 int data_direction) 885 int data_direction)
888{ 886{
889 u64bit addr64; 887 u64bit addr64;
890 888
891 addr64.val32.lower = cp->SG[0].Addr.lower; 889 addr64.val32.lower = c->SG[0].Addr.lower;
892 addr64.val32.upper = cp->SG[0].Addr.upper; 890 addr64.val32.upper = c->SG[0].Addr.upper;
893 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction); 891 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
894} 892}
895 893
896static void 894static void
897cciss_map_one(struct pci_dev *pdev, 895cciss_map_one(struct pci_dev *pdev,
898 CommandList_struct *cp, 896 CommandList_struct *c,
899 unsigned char *buf, 897 unsigned char *buf,
900 size_t buflen, 898 size_t buflen,
901 int data_direction) 899 int data_direction)
@@ -903,18 +901,18 @@ cciss_map_one(struct pci_dev *pdev,
903 __u64 addr64; 901 __u64 addr64;
904 902
905 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction); 903 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
906 cp->SG[0].Addr.lower = 904 c->SG[0].Addr.lower =
907 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF); 905 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
908 cp->SG[0].Addr.upper = 906 c->SG[0].Addr.upper =
909 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF); 907 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
910 cp->SG[0].Len = buflen; 908 c->SG[0].Len = buflen;
911 cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */ 909 c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
912 cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */ 910 c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
913} 911}
914 912
915static int 913static int
916cciss_scsi_do_simple_cmd(ctlr_info_t *c, 914cciss_scsi_do_simple_cmd(ctlr_info_t *h,
917 CommandList_struct *cp, 915 CommandList_struct *c,
918 unsigned char *scsi3addr, 916 unsigned char *scsi3addr,
919 unsigned char *cdb, 917 unsigned char *cdb,
920 unsigned char cdblen, 918 unsigned char cdblen,
@@ -923,53 +921,52 @@ cciss_scsi_do_simple_cmd(ctlr_info_t *c,
923{ 921{
924 DECLARE_COMPLETION_ONSTACK(wait); 922 DECLARE_COMPLETION_ONSTACK(wait);
925 923
926 cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl 924 c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
927 cp->scsi_cmd = NULL; 925 c->scsi_cmd = NULL;
928 cp->Header.ReplyQueue = 0; // unused in simple mode 926 c->Header.ReplyQueue = 0; /* unused in simple mode */
929 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN)); 927 memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
930 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag 928 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
931 // Fill in the request block... 929 // Fill in the request block...
932 930
933 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", 931 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
934 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3], 932 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
935 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */ 933 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
936 934
937 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB)); 935 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
938 memcpy(cp->Request.CDB, cdb, cdblen); 936 memcpy(c->Request.CDB, cdb, cdblen);
939 cp->Request.Timeout = 0; 937 c->Request.Timeout = 0;
940 cp->Request.CDBLen = cdblen; 938 c->Request.CDBLen = cdblen;
941 cp->Request.Type.Type = TYPE_CMD; 939 c->Request.Type.Type = TYPE_CMD;
942 cp->Request.Type.Attribute = ATTR_SIMPLE; 940 c->Request.Type.Attribute = ATTR_SIMPLE;
943 cp->Request.Type.Direction = direction; 941 c->Request.Type.Direction = direction;
944 942
945 /* Fill in the SG list and do dma mapping */ 943 /* Fill in the SG list and do dma mapping */
946 cciss_map_one(c->pdev, cp, (unsigned char *) buf, 944 cciss_map_one(h->pdev, c, (unsigned char *) buf,
947 bufsize, DMA_FROM_DEVICE); 945 bufsize, DMA_FROM_DEVICE);
948 946
949 cp->waiting = &wait; 947 c->waiting = &wait;
950 enqueue_cmd_and_start_io(c, cp); 948 enqueue_cmd_and_start_io(h, c);
951 wait_for_completion(&wait); 949 wait_for_completion(&wait);
952 950
953 /* undo the dma mapping */ 951 /* undo the dma mapping */
954 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE); 952 cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
955 return(0); 953 return(0);
956} 954}
957 955
958static void 956static void
959cciss_scsi_interpret_error(CommandList_struct *cp) 957cciss_scsi_interpret_error(CommandList_struct *c)
960{ 958{
961 ErrorInfo_struct *ei; 959 ErrorInfo_struct *ei;
962 960
963 ei = cp->err_info; 961 ei = c->err_info;
964 switch(ei->CommandStatus) 962 switch(ei->CommandStatus)
965 { 963 {
966 case CMD_TARGET_STATUS: 964 case CMD_TARGET_STATUS:
967 printk(KERN_WARNING "cciss: cmd %p has " 965 printk(KERN_WARNING "cciss: cmd %p has "
968 "completed with errors\n", cp); 966 "completed with errors\n", c);
969 printk(KERN_WARNING "cciss: cmd %p " 967 printk(KERN_WARNING "cciss: cmd %p "
970 "has SCSI Status = %x\n", 968 "has SCSI Status = %x\n",
971 cp, 969 c, ei->ScsiStatus);
972 ei->ScsiStatus);
973 if (ei->ScsiStatus == 0) 970 if (ei->ScsiStatus == 0)
974 printk(KERN_WARNING 971 printk(KERN_WARNING
975 "cciss:SCSI status is abnormally zero. " 972 "cciss:SCSI status is abnormally zero. "
@@ -981,78 +978,75 @@ cciss_scsi_interpret_error(CommandList_struct *cp)
981 printk("UNDERRUN\n"); 978 printk("UNDERRUN\n");
982 break; 979 break;
983 case CMD_DATA_OVERRUN: 980 case CMD_DATA_OVERRUN:
984 printk(KERN_WARNING "cciss: cp %p has" 981 printk(KERN_WARNING "cciss: %p has"
985 " completed with data overrun " 982 " completed with data overrun "
986 "reported\n", cp); 983 "reported\n", c);
987 break; 984 break;
988 case CMD_INVALID: { 985 case CMD_INVALID: {
989 /* controller unfortunately reports SCSI passthru's */ 986 /* controller unfortunately reports SCSI passthru's */
990 /* to non-existent targets as invalid commands. */ 987 /* to non-existent targets as invalid commands. */
991 printk(KERN_WARNING "cciss: cp %p is " 988 printk(KERN_WARNING "cciss: %p is "
992 "reported invalid (probably means " 989 "reported invalid (probably means "
993 "target device no longer present)\n", 990 "target device no longer present)\n", c);
994 cp); 991 /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
995 /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0); 992 print_cmd(c); */
996 print_cmd(cp); */
997 } 993 }
998 break; 994 break;
999 case CMD_PROTOCOL_ERR: 995 case CMD_PROTOCOL_ERR:
1000 printk(KERN_WARNING "cciss: cp %p has " 996 printk(KERN_WARNING "cciss: %p has "
1001 "protocol error \n", cp); 997 "protocol error\n", c);
1002 break; 998 break;
1003 case CMD_HARDWARE_ERR: 999 case CMD_HARDWARE_ERR:
1004 /* cmd->result = DID_ERROR << 16; */ 1000 /* cmd->result = DID_ERROR << 16; */
1005 printk(KERN_WARNING "cciss: cp %p had " 1001 printk(KERN_WARNING "cciss: %p had "
1006 " hardware error\n", cp); 1002 " hardware error\n", c);
1007 break; 1003 break;
1008 case CMD_CONNECTION_LOST: 1004 case CMD_CONNECTION_LOST:
1009 printk(KERN_WARNING "cciss: cp %p had " 1005 printk(KERN_WARNING "cciss: %p had "
1010 "connection lost\n", cp); 1006 "connection lost\n", c);
1011 break; 1007 break;
1012 case CMD_ABORTED: 1008 case CMD_ABORTED:
1013 printk(KERN_WARNING "cciss: cp %p was " 1009 printk(KERN_WARNING "cciss: %p was "
1014 "aborted\n", cp); 1010 "aborted\n", c);
1015 break; 1011 break;
1016 case CMD_ABORT_FAILED: 1012 case CMD_ABORT_FAILED:
1017 printk(KERN_WARNING "cciss: cp %p reports " 1013 printk(KERN_WARNING "cciss: %p reports "
1018 "abort failed\n", cp); 1014 "abort failed\n", c);
1019 break; 1015 break;
1020 case CMD_UNSOLICITED_ABORT: 1016 case CMD_UNSOLICITED_ABORT:
1021 printk(KERN_WARNING "cciss: cp %p aborted " 1017 printk(KERN_WARNING "cciss: %p aborted "
1022 "do to an unsolicited abort\n", cp); 1018 "do to an unsolicited abort\n", c);
1023 break; 1019 break;
1024 case CMD_TIMEOUT: 1020 case CMD_TIMEOUT:
1025 printk(KERN_WARNING "cciss: cp %p timedout\n", 1021 printk(KERN_WARNING "cciss: %p timedout\n", c);
1026 cp);
1027 break; 1022 break;
1028 default: 1023 default:
1029 printk(KERN_WARNING "cciss: cp %p returned " 1024 printk(KERN_WARNING "cciss: %p returned "
1030 "unknown status %x\n", cp, 1025 "unknown status %x\n", c, ei->CommandStatus);
1031 ei->CommandStatus);
1032 } 1026 }
1033} 1027}
1034 1028
1035static int 1029static int
1036cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr, 1030cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
1037 unsigned char page, unsigned char *buf, 1031 unsigned char page, unsigned char *buf,
1038 unsigned char bufsize) 1032 unsigned char bufsize)
1039{ 1033{
1040 int rc; 1034 int rc;
1041 CommandList_struct *cp; 1035 CommandList_struct *c;
1042 char cdb[6]; 1036 char cdb[6];
1043 ErrorInfo_struct *ei; 1037 ErrorInfo_struct *ei;
1044 unsigned long flags; 1038 unsigned long flags;
1045 1039
1046 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); 1040 spin_lock_irqsave(&h->lock, flags);
1047 cp = scsi_cmd_alloc(c); 1041 c = scsi_cmd_alloc(h);
1048 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); 1042 spin_unlock_irqrestore(&h->lock, flags);
1049 1043
1050 if (cp == NULL) { /* trouble... */ 1044 if (c == NULL) { /* trouble... */
1051 printk("cmd_alloc returned NULL!\n"); 1045 printk("cmd_alloc returned NULL!\n");
1052 return -1; 1046 return -1;
1053 } 1047 }
1054 1048
1055 ei = cp->err_info; 1049 ei = c->err_info;
1056 1050
1057 cdb[0] = CISS_INQUIRY; 1051 cdb[0] = CISS_INQUIRY;
1058 cdb[1] = (page != 0); 1052 cdb[1] = (page != 0);
@@ -1060,24 +1054,24 @@ cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
1060 cdb[3] = 0; 1054 cdb[3] = 0;
1061 cdb[4] = bufsize; 1055 cdb[4] = bufsize;
1062 cdb[5] = 0; 1056 cdb[5] = 0;
1063 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb, 1057 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
1064 6, buf, bufsize, XFER_READ); 1058 6, buf, bufsize, XFER_READ);
1065 1059
1066 if (rc != 0) return rc; /* something went wrong */ 1060 if (rc != 0) return rc; /* something went wrong */
1067 1061
1068 if (ei->CommandStatus != 0 && 1062 if (ei->CommandStatus != 0 &&
1069 ei->CommandStatus != CMD_DATA_UNDERRUN) { 1063 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1070 cciss_scsi_interpret_error(cp); 1064 cciss_scsi_interpret_error(c);
1071 rc = -1; 1065 rc = -1;
1072 } 1066 }
1073 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); 1067 spin_lock_irqsave(&h->lock, flags);
1074 scsi_cmd_free(c, cp); 1068 scsi_cmd_free(h, c);
1075 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); 1069 spin_unlock_irqrestore(&h->lock, flags);
1076 return rc; 1070 return rc;
1077} 1071}
1078 1072
1079/* Get the device id from inquiry page 0x83 */ 1073/* Get the device id from inquiry page 0x83 */
1080static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr, 1074static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
1081 unsigned char *device_id, int buflen) 1075 unsigned char *device_id, int buflen)
1082{ 1076{
1083 int rc; 1077 int rc;
@@ -1088,7 +1082,7 @@ static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1088 buf = kzalloc(64, GFP_KERNEL); 1082 buf = kzalloc(64, GFP_KERNEL);
1089 if (!buf) 1083 if (!buf)
1090 return -1; 1084 return -1;
1091 rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64); 1085 rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
1092 if (rc == 0) 1086 if (rc == 0)
1093 memcpy(device_id, &buf[8], buflen); 1087 memcpy(device_id, &buf[8], buflen);
1094 kfree(buf); 1088 kfree(buf);
@@ -1096,20 +1090,20 @@ static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1096} 1090}
1097 1091
1098static int 1092static int
1099cciss_scsi_do_report_phys_luns(ctlr_info_t *c, 1093cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
1100 ReportLunData_struct *buf, int bufsize) 1094 ReportLunData_struct *buf, int bufsize)
1101{ 1095{
1102 int rc; 1096 int rc;
1103 CommandList_struct *cp; 1097 CommandList_struct *c;
1104 unsigned char cdb[12]; 1098 unsigned char cdb[12];
1105 unsigned char scsi3addr[8]; 1099 unsigned char scsi3addr[8];
1106 ErrorInfo_struct *ei; 1100 ErrorInfo_struct *ei;
1107 unsigned long flags; 1101 unsigned long flags;
1108 1102
1109 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); 1103 spin_lock_irqsave(&h->lock, flags);
1110 cp = scsi_cmd_alloc(c); 1104 c = scsi_cmd_alloc(h);
1111 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); 1105 spin_unlock_irqrestore(&h->lock, flags);
1112 if (cp == NULL) { /* trouble... */ 1106 if (c == NULL) { /* trouble... */
1113 printk("cmd_alloc returned NULL!\n"); 1107 printk("cmd_alloc returned NULL!\n");
1114 return -1; 1108 return -1;
1115 } 1109 }
@@ -1128,27 +1122,27 @@ cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1128 cdb[10] = 0; 1122 cdb[10] = 0;
1129 cdb[11] = 0; 1123 cdb[11] = 0;
1130 1124
1131 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, 1125 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
1132 cdb, 12, 1126 cdb, 12,
1133 (unsigned char *) buf, 1127 (unsigned char *) buf,
1134 bufsize, XFER_READ); 1128 bufsize, XFER_READ);
1135 1129
1136 if (rc != 0) return rc; /* something went wrong */ 1130 if (rc != 0) return rc; /* something went wrong */
1137 1131
1138 ei = cp->err_info; 1132 ei = c->err_info;
1139 if (ei->CommandStatus != 0 && 1133 if (ei->CommandStatus != 0 &&
1140 ei->CommandStatus != CMD_DATA_UNDERRUN) { 1134 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1141 cciss_scsi_interpret_error(cp); 1135 cciss_scsi_interpret_error(c);
1142 rc = -1; 1136 rc = -1;
1143 } 1137 }
1144 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags); 1138 spin_lock_irqsave(&h->lock, flags);
1145 scsi_cmd_free(c, cp); 1139 scsi_cmd_free(h, c);
1146 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags); 1140 spin_unlock_irqrestore(&h->lock, flags);
1147 return rc; 1141 return rc;
1148} 1142}
1149 1143
1150static void 1144static void
1151cciss_update_non_disk_devices(int cntl_num, int hostno) 1145cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
1152{ 1146{
1153 /* the idea here is we could get notified from /proc 1147 /* the idea here is we could get notified from /proc
1154 that some devices have changed, so we do a report 1148 that some devices have changed, so we do a report
@@ -1181,7 +1175,6 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1181 ReportLunData_struct *ld_buff; 1175 ReportLunData_struct *ld_buff;
1182 unsigned char *inq_buff; 1176 unsigned char *inq_buff;
1183 unsigned char scsi3addr[8]; 1177 unsigned char scsi3addr[8];
1184 ctlr_info_t *c;
1185 __u32 num_luns=0; 1178 __u32 num_luns=0;
1186 unsigned char *ch; 1179 unsigned char *ch;
1187 struct cciss_scsi_dev_t *currentsd, *this_device; 1180 struct cciss_scsi_dev_t *currentsd, *this_device;
@@ -1189,7 +1182,6 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1189 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8; 1182 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1190 int i; 1183 int i;
1191 1184
1192 c = (ctlr_info_t *) hba[cntl_num];
1193 ld_buff = kzalloc(reportlunsize, GFP_KERNEL); 1185 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1194 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL); 1186 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1195 currentsd = kzalloc(sizeof(*currentsd) * 1187 currentsd = kzalloc(sizeof(*currentsd) *
@@ -1199,7 +1191,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1199 goto out; 1191 goto out;
1200 } 1192 }
1201 this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA]; 1193 this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1202 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) { 1194 if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
1203 ch = &ld_buff->LUNListLength[0]; 1195 ch = &ld_buff->LUNListLength[0];
1204 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8; 1196 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1205 if (num_luns > CISS_MAX_PHYS_LUN) { 1197 if (num_luns > CISS_MAX_PHYS_LUN) {
@@ -1223,7 +1215,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1223 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE); 1215 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1224 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8); 1216 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1225 1217
1226 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff, 1218 if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
1227 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) 1219 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1228 /* Inquiry failed (msg printed already) */ 1220 /* Inquiry failed (msg printed already) */
1229 continue; /* so we will skip this device. */ 1221 continue; /* so we will skip this device. */
@@ -1241,7 +1233,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1241 sizeof(this_device->revision)); 1233 sizeof(this_device->revision));
1242 memset(this_device->device_id, 0, 1234 memset(this_device->device_id, 0,
1243 sizeof(this_device->device_id)); 1235 sizeof(this_device->device_id));
1244 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr, 1236 cciss_scsi_get_device_id(h, scsi3addr,
1245 this_device->device_id, sizeof(this_device->device_id)); 1237 this_device->device_id, sizeof(this_device->device_id));
1246 1238
1247 switch (this_device->devtype) 1239 switch (this_device->devtype)
@@ -1268,7 +1260,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1268 case 0x08: /* medium changer */ 1260 case 0x08: /* medium changer */
1269 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) { 1261 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1270 printk(KERN_INFO "cciss%d: %s ignored, " 1262 printk(KERN_INFO "cciss%d: %s ignored, "
1271 "too many devices.\n", cntl_num, 1263 "too many devices.\n", h->ctlr,
1272 scsi_device_type(this_device->devtype)); 1264 scsi_device_type(this_device->devtype));
1273 break; 1265 break;
1274 } 1266 }
@@ -1280,7 +1272,7 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
1280 } 1272 }
1281 } 1273 }
1282 1274
1283 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent); 1275 adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
1284out: 1276out:
1285 kfree(inq_buff); 1277 kfree(inq_buff);
1286 kfree(ld_buff); 1278 kfree(ld_buff);
@@ -1299,12 +1291,12 @@ is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1299} 1291}
1300 1292
1301static int 1293static int
1302cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length) 1294cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
1303{ 1295{
1304 int arg_len; 1296 int arg_len;
1305 1297
1306 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0) 1298 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1307 cciss_update_non_disk_devices(ctlr, hostno); 1299 cciss_update_non_disk_devices(h, hostno);
1308 else 1300 else
1309 return -EINVAL; 1301 return -EINVAL;
1310 return length; 1302 return length;
@@ -1321,20 +1313,16 @@ cciss_scsi_proc_info(struct Scsi_Host *sh,
1321{ 1313{
1322 1314
1323 int buflen, datalen; 1315 int buflen, datalen;
1324 ctlr_info_t *ci; 1316 ctlr_info_t *h;
1325 int i; 1317 int i;
1326 int cntl_num;
1327 1318
1328 1319 h = (ctlr_info_t *) sh->hostdata[0];
1329 ci = (ctlr_info_t *) sh->hostdata[0]; 1320 if (h == NULL) /* This really shouldn't ever happen. */
1330 if (ci == NULL) /* This really shouldn't ever happen. */
1331 return -EINVAL; 1321 return -EINVAL;
1332 1322
1333 cntl_num = ci->ctlr; /* Get our index into the hba[] array */
1334
1335 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */ 1323 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
1336 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n", 1324 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1337 cntl_num, sh->host_no); 1325 h->ctlr, sh->host_no);
1338 1326
1339 /* this information is needed by apps to know which cciss 1327 /* this information is needed by apps to know which cciss
1340 device corresponds to which scsi host number without 1328 device corresponds to which scsi host number without
@@ -1344,8 +1332,9 @@ cciss_scsi_proc_info(struct Scsi_Host *sh,
1344 this info is for an app to be able to use to know how to 1332 this info is for an app to be able to use to know how to
1345 get them back in sync. */ 1333 get them back in sync. */
1346 1334
1347 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) { 1335 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1348 struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i]; 1336 struct cciss_scsi_dev_t *sd =
1337 &ccissscsi[h->ctlr].dev[i];
1349 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d " 1338 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1350 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 1339 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1351 sh->host_no, sd->bus, sd->target, sd->lun, 1340 sh->host_no, sd->bus, sd->target, sd->lun,
@@ -1363,15 +1352,15 @@ cciss_scsi_proc_info(struct Scsi_Host *sh,
1363 *start = buffer + offset; 1352 *start = buffer + offset;
1364 return(datalen); 1353 return(datalen);
1365 } else /* User is writing to /proc/scsi/cciss*?/?* ... */ 1354 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1366 return cciss_scsi_user_command(cntl_num, sh->host_no, 1355 return cciss_scsi_user_command(h, sh->host_no,
1367 buffer, length); 1356 buffer, length);
1368} 1357}
1369 1358
1370/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci 1359/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1371 dma mapping and fills in the scatter gather entries of the 1360 dma mapping and fills in the scatter gather entries of the
1372 cciss command, cp. */ 1361 cciss command, c. */
1373 1362
1374static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp, 1363static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
1375 struct scsi_cmnd *cmd) 1364 struct scsi_cmnd *cmd)
1376{ 1365{
1377 unsigned int len; 1366 unsigned int len;
@@ -1385,7 +1374,7 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1385 1374
1386 chained = 0; 1375 chained = 0;
1387 sg_index = 0; 1376 sg_index = 0;
1388 curr_sg = cp->SG; 1377 curr_sg = c->SG;
1389 request_nsgs = scsi_dma_map(cmd); 1378 request_nsgs = scsi_dma_map(cmd);
1390 if (request_nsgs) { 1379 if (request_nsgs) {
1391 scsi_for_each_sg(cmd, sg, request_nsgs, i) { 1380 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
@@ -1393,7 +1382,7 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1393 !chained && request_nsgs - i > 1) { 1382 !chained && request_nsgs - i > 1) {
1394 chained = 1; 1383 chained = 1;
1395 sg_index = 0; 1384 sg_index = 0;
1396 curr_sg = sa->cmd_sg_list[cp->cmdindex]; 1385 curr_sg = sa->cmd_sg_list[c->cmdindex];
1397 } 1386 }
1398 addr64 = (__u64) sg_dma_address(sg); 1387 addr64 = (__u64) sg_dma_address(sg);
1399 len = sg_dma_len(sg); 1388 len = sg_dma_len(sg);
@@ -1406,19 +1395,19 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1406 ++sg_index; 1395 ++sg_index;
1407 } 1396 }
1408 if (chained) 1397 if (chained)
1409 cciss_map_sg_chain_block(h, cp, 1398 cciss_map_sg_chain_block(h, c,
1410 sa->cmd_sg_list[cp->cmdindex], 1399 sa->cmd_sg_list[c->cmdindex],
1411 (request_nsgs - (h->max_cmd_sgentries - 1)) * 1400 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1412 sizeof(SGDescriptor_struct)); 1401 sizeof(SGDescriptor_struct));
1413 } 1402 }
1414 /* track how many SG entries we are using */ 1403 /* track how many SG entries we are using */
1415 if (request_nsgs > h->maxSG) 1404 if (request_nsgs > h->maxSG)
1416 h->maxSG = request_nsgs; 1405 h->maxSG = request_nsgs;
1417 cp->Header.SGTotal = (__u8) request_nsgs + chained; 1406 c->Header.SGTotal = (__u8) request_nsgs + chained;
1418 if (request_nsgs > h->max_cmd_sgentries) 1407 if (request_nsgs > h->max_cmd_sgentries)
1419 cp->Header.SGList = h->max_cmd_sgentries; 1408 c->Header.SGList = h->max_cmd_sgentries;
1420 else 1409 else
1421 cp->Header.SGList = cp->Header.SGTotal; 1410 c->Header.SGList = c->Header.SGTotal;
1422 return; 1411 return;
1423} 1412}
1424 1413
@@ -1426,18 +1415,17 @@ static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1426static int 1415static int
1427cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *)) 1416cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1428{ 1417{
1429 ctlr_info_t *c; 1418 ctlr_info_t *h;
1430 int ctlr, rc; 1419 int rc;
1431 unsigned char scsi3addr[8]; 1420 unsigned char scsi3addr[8];
1432 CommandList_struct *cp; 1421 CommandList_struct *c;
1433 unsigned long flags; 1422 unsigned long flags;
1434 1423
1435 // Get the ptr to our adapter structure (hba[i]) out of cmd->host. 1424 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1436 // We violate cmd->host privacy here. (Is there another way?) 1425 // We violate cmd->host privacy here. (Is there another way?)
1437 c = (ctlr_info_t *) cmd->device->host->hostdata[0]; 1426 h = (ctlr_info_t *) cmd->device->host->hostdata[0];
1438 ctlr = c->ctlr;
1439 1427
1440 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id, 1428 rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
1441 cmd->device->lun, scsi3addr); 1429 cmd->device->lun, scsi3addr);
1442 if (rc != 0) { 1430 if (rc != 0) {
1443 /* the scsi nexus does not match any that we presented... */ 1431 /* the scsi nexus does not match any that we presented... */
@@ -1449,18 +1437,13 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd
1449 return 0; 1437 return 0;
1450 } 1438 }
1451 1439
1452 /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1453 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1454 // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1455 // cmd->target, cmd->lun);
1456
1457 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and 1440 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1458 see what the device thinks of it. */ 1441 see what the device thinks of it. */
1459 1442
1460 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1443 spin_lock_irqsave(&h->lock, flags);
1461 cp = scsi_cmd_alloc(c); 1444 c = scsi_cmd_alloc(h);
1462 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1445 spin_unlock_irqrestore(&h->lock, flags);
1463 if (cp == NULL) { /* trouble... */ 1446 if (c == NULL) { /* trouble... */
1464 printk("scsi_cmd_alloc returned NULL!\n"); 1447 printk("scsi_cmd_alloc returned NULL!\n");
1465 /* FIXME: next 3 lines are -> BAD! <- */ 1448 /* FIXME: next 3 lines are -> BAD! <- */
1466 cmd->result = DID_NO_CONNECT << 16; 1449 cmd->result = DID_NO_CONNECT << 16;
@@ -1472,35 +1455,41 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd
1472 1455
1473 cmd->scsi_done = done; // save this for use by completion code 1456 cmd->scsi_done = done; // save this for use by completion code
1474 1457
1475 // save cp in case we have to abort it 1458 /* save c in case we have to abort it */
1476 cmd->host_scribble = (unsigned char *) cp; 1459 cmd->host_scribble = (unsigned char *) c;
1477 1460
1478 cp->cmd_type = CMD_SCSI; 1461 c->cmd_type = CMD_SCSI;
1479 cp->scsi_cmd = cmd; 1462 c->scsi_cmd = cmd;
1480 cp->Header.ReplyQueue = 0; // unused in simple mode 1463 c->Header.ReplyQueue = 0; /* unused in simple mode */
1481 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8); 1464 memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1482 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag 1465 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
1483 1466
1484 // Fill in the request block... 1467 // Fill in the request block...
1485 1468
1486 cp->Request.Timeout = 0; 1469 c->Request.Timeout = 0;
1487 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB)); 1470 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1488 BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB)); 1471 BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1489 cp->Request.CDBLen = cmd->cmd_len; 1472 c->Request.CDBLen = cmd->cmd_len;
1490 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len); 1473 memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1491 cp->Request.Type.Type = TYPE_CMD; 1474 c->Request.Type.Type = TYPE_CMD;
1492 cp->Request.Type.Attribute = ATTR_SIMPLE; 1475 c->Request.Type.Attribute = ATTR_SIMPLE;
1493 switch(cmd->sc_data_direction) 1476 switch(cmd->sc_data_direction)
1494 { 1477 {
1495 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break; 1478 case DMA_TO_DEVICE:
1496 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break; 1479 c->Request.Type.Direction = XFER_WRITE;
1497 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break; 1480 break;
1481 case DMA_FROM_DEVICE:
1482 c->Request.Type.Direction = XFER_READ;
1483 break;
1484 case DMA_NONE:
1485 c->Request.Type.Direction = XFER_NONE;
1486 break;
1498 case DMA_BIDIRECTIONAL: 1487 case DMA_BIDIRECTIONAL:
1499 // This can happen if a buggy application does a scsi passthru 1488 // This can happen if a buggy application does a scsi passthru
1500 // and sets both inlen and outlen to non-zero. ( see 1489 // and sets both inlen and outlen to non-zero. ( see
1501 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() ) 1490 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1502 1491
1503 cp->Request.Type.Direction = XFER_RSVD; 1492 c->Request.Type.Direction = XFER_RSVD;
1504 // This is technically wrong, and cciss controllers should 1493 // This is technically wrong, and cciss controllers should
1505 // reject it with CMD_INVALID, which is the most correct 1494 // reject it with CMD_INVALID, which is the most correct
1506 // response, but non-fibre backends appear to let it 1495 // response, but non-fibre backends appear to let it
@@ -1516,14 +1505,13 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd
1516 BUG(); 1505 BUG();
1517 break; 1506 break;
1518 } 1507 }
1519 cciss_scatter_gather(c, cp, cmd); 1508 cciss_scatter_gather(h, c, cmd);
1520 enqueue_cmd_and_start_io(c, cp); 1509 enqueue_cmd_and_start_io(h, c);
1521 /* the cmd'll come back via intr handler in complete_scsi_command() */ 1510 /* the cmd'll come back via intr handler in complete_scsi_command() */
1522 return 0; 1511 return 0;
1523} 1512}
1524 1513
1525static void 1514static void cciss_unregister_scsi(ctlr_info_t *h)
1526cciss_unregister_scsi(int ctlr)
1527{ 1515{
1528 struct cciss_scsi_adapter_data_t *sa; 1516 struct cciss_scsi_adapter_data_t *sa;
1529 struct cciss_scsi_cmd_stack_t *stk; 1517 struct cciss_scsi_cmd_stack_t *stk;
@@ -1531,59 +1519,59 @@ cciss_unregister_scsi(int ctlr)
1531 1519
1532 /* we are being forcibly unloaded, and may not refuse. */ 1520 /* we are being forcibly unloaded, and may not refuse. */
1533 1521
1534 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1522 spin_lock_irqsave(&h->lock, flags);
1535 sa = hba[ctlr]->scsi_ctlr; 1523 sa = h->scsi_ctlr;
1536 stk = &sa->cmd_stack; 1524 stk = &sa->cmd_stack;
1537 1525
1538 /* if we weren't ever actually registered, don't unregister */ 1526 /* if we weren't ever actually registered, don't unregister */
1539 if (sa->registered) { 1527 if (sa->registered) {
1540 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1528 spin_unlock_irqrestore(&h->lock, flags);
1541 scsi_remove_host(sa->scsi_host); 1529 scsi_remove_host(sa->scsi_host);
1542 scsi_host_put(sa->scsi_host); 1530 scsi_host_put(sa->scsi_host);
1543 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1531 spin_lock_irqsave(&h->lock, flags);
1544 } 1532 }
1545 1533
1546 /* set scsi_host to NULL so our detect routine will 1534 /* set scsi_host to NULL so our detect routine will
1547 find us on register */ 1535 find us on register */
1548 sa->scsi_host = NULL; 1536 sa->scsi_host = NULL;
1549 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1537 spin_unlock_irqrestore(&h->lock, flags);
1550 scsi_cmd_stack_free(ctlr); 1538 scsi_cmd_stack_free(h);
1551 kfree(sa); 1539 kfree(sa);
1552} 1540}
1553 1541
1554static int 1542static int cciss_engage_scsi(ctlr_info_t *h)
1555cciss_engage_scsi(int ctlr)
1556{ 1543{
1557 struct cciss_scsi_adapter_data_t *sa; 1544 struct cciss_scsi_adapter_data_t *sa;
1558 struct cciss_scsi_cmd_stack_t *stk; 1545 struct cciss_scsi_cmd_stack_t *stk;
1559 unsigned long flags; 1546 unsigned long flags;
1560 1547
1561 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1548 spin_lock_irqsave(&h->lock, flags);
1562 sa = hba[ctlr]->scsi_ctlr; 1549 sa = h->scsi_ctlr;
1563 stk = &sa->cmd_stack; 1550 stk = &sa->cmd_stack;
1564 1551
1565 if (sa->registered) { 1552 if (sa->registered) {
1566 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr); 1553 printk(KERN_INFO "cciss%d: SCSI subsystem already engaged.\n",
1567 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1554 h->ctlr);
1555 spin_unlock_irqrestore(&h->lock, flags);
1568 return -ENXIO; 1556 return -ENXIO;
1569 } 1557 }
1570 sa->registered = 1; 1558 sa->registered = 1;
1571 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1559 spin_unlock_irqrestore(&h->lock, flags);
1572 cciss_update_non_disk_devices(ctlr, -1); 1560 cciss_update_non_disk_devices(h, -1);
1573 cciss_scsi_detect(ctlr); 1561 cciss_scsi_detect(h);
1574 return 0; 1562 return 0;
1575} 1563}
1576 1564
1577static void 1565static void
1578cciss_seq_tape_report(struct seq_file *seq, int ctlr) 1566cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
1579{ 1567{
1580 unsigned long flags; 1568 unsigned long flags;
1581 1569
1582 CPQ_TAPE_LOCK(ctlr, flags); 1570 CPQ_TAPE_LOCK(h, flags);
1583 seq_printf(seq, 1571 seq_printf(seq,
1584 "Sequential access devices: %d\n\n", 1572 "Sequential access devices: %d\n\n",
1585 ccissscsi[ctlr].ndevices); 1573 ccissscsi[h->ctlr].ndevices);
1586 CPQ_TAPE_UNLOCK(ctlr, flags); 1574 CPQ_TAPE_UNLOCK(h, flags);
1587} 1575}
1588 1576
1589static int wait_for_device_to_become_ready(ctlr_info_t *h, 1577static int wait_for_device_to_become_ready(ctlr_info_t *h,
@@ -1615,7 +1603,7 @@ static int wait_for_device_to_become_ready(ctlr_info_t *h,
1615 waittime = waittime * 2; 1603 waittime = waittime * 2;
1616 1604
1617 /* Send the Test Unit Ready */ 1605 /* Send the Test Unit Ready */
1618 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0, 1606 rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
1619 lunaddr, TYPE_CMD); 1607 lunaddr, TYPE_CMD);
1620 if (rc == 0) 1608 if (rc == 0)
1621 rc = sendcmd_withirq_core(h, c, 0); 1609 rc = sendcmd_withirq_core(h, c, 0);
@@ -1672,26 +1660,25 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1672 int rc; 1660 int rc;
1673 CommandList_struct *cmd_in_trouble; 1661 CommandList_struct *cmd_in_trouble;
1674 unsigned char lunaddr[8]; 1662 unsigned char lunaddr[8];
1675 ctlr_info_t *c; 1663 ctlr_info_t *h;
1676 int ctlr;
1677 1664
1678 /* find the controller to which the command to be aborted was sent */ 1665 /* find the controller to which the command to be aborted was sent */
1679 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; 1666 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1680 if (c == NULL) /* paranoia */ 1667 if (h == NULL) /* paranoia */
1681 return FAILED; 1668 return FAILED;
1682 ctlr = c->ctlr; 1669 printk(KERN_WARNING
1683 printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr); 1670 "cciss%d: resetting tape drive or medium changer.\n", h->ctlr);
1684 /* find the command that's giving us trouble */ 1671 /* find the command that's giving us trouble */
1685 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble; 1672 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1686 if (cmd_in_trouble == NULL) /* paranoia */ 1673 if (cmd_in_trouble == NULL) /* paranoia */
1687 return FAILED; 1674 return FAILED;
1688 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8); 1675 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1689 /* send a reset to the SCSI LUN which the command was sent to */ 1676 /* send a reset to the SCSI LUN which the command was sent to */
1690 rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr, 1677 rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
1691 TYPE_MSG); 1678 TYPE_MSG);
1692 if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0) 1679 if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
1693 return SUCCESS; 1680 return SUCCESS;
1694 printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr); 1681 printk(KERN_WARNING "cciss%d: resetting device failed.\n", h->ctlr);
1695 return FAILED; 1682 return FAILED;
1696} 1683}
1697 1684
@@ -1700,22 +1687,20 @@ static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1700 int rc; 1687 int rc;
1701 CommandList_struct *cmd_to_abort; 1688 CommandList_struct *cmd_to_abort;
1702 unsigned char lunaddr[8]; 1689 unsigned char lunaddr[8];
1703 ctlr_info_t *c; 1690 ctlr_info_t *h;
1704 int ctlr;
1705 1691
1706 /* find the controller to which the command to be aborted was sent */ 1692 /* find the controller to which the command to be aborted was sent */
1707 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; 1693 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1708 if (c == NULL) /* paranoia */ 1694 if (h == NULL) /* paranoia */
1709 return FAILED; 1695 return FAILED;
1710 ctlr = c->ctlr; 1696 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", h->ctlr);
1711 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1712 1697
1713 /* find the command to be aborted */ 1698 /* find the command to be aborted */
1714 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble; 1699 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1715 if (cmd_to_abort == NULL) /* paranoia */ 1700 if (cmd_to_abort == NULL) /* paranoia */
1716 return FAILED; 1701 return FAILED;
1717 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8); 1702 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1718 rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag, 1703 rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
1719 0, 0, lunaddr, TYPE_MSG); 1704 0, 0, lunaddr, TYPE_MSG);
1720 if (rc == 0) 1705 if (rc == 0)
1721 return SUCCESS; 1706 return SUCCESS;
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-03 12:14:03 -0500