/*

   *    Disk Array driver for HP Smart Array controllers.
   *    (C) Copyright 2000, 2007 Hewlett-Packard Development Company, L.P.

   *
   *    This program is free software; you can redistribute it and/or modify
   *    it under the terms of the GNU General Public License as published by

   *    the Free Software Foundation; version 2 of the License.

   *
   *    This program is distributed in the hope that it will be useful,
   *    but WITHOUT ANY WARRANTY; without even the implied warranty of

   *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   *    General Public License for more details.

   *
   *    You should have received a copy of the GNU General Public License
   *    along with this program; if not, write to the Free Software

   *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   *    02111-1307, USA.

   *
   *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
   *
   */

  #include <linux/module.h>
  #include <linux/interrupt.h>
  #include <linux/types.h>
  #include <linux/pci.h>

  #include <linux/pci-aspm.h>

  #include <linux/kernel.h>
  #include <linux/slab.h>
  #include <linux/delay.h>
  #include <linux/major.h>
  #include <linux/fs.h>
  #include <linux/bio.h>
  #include <linux/blkpg.h>
  #include <linux/timer.h>
  #include <linux/proc_fs.h>

  #include <linux/seq_file.h>

  #include <linux/init.h>

  #include <linux/jiffies.h>

  #include <linux/hdreg.h>
  #include <linux/spinlock.h>
  #include <linux/compat.h>

  #include <linux/mutex.h>

  #include <linux/bitmap.h>

  #include <linux/io.h>

  #include <asm/uaccess.h>

  #include <linux/dma-mapping.h>

  #include <linux/blkdev.h>
  #include <linux/genhd.h>
  #include <linux/completion.h>

  #include <scsi/scsi.h>

  #include <scsi/sg.h>
  #include <scsi/scsi_ioctl.h>
  #include <linux/cdrom.h>

  #include <linux/scatterlist.h>

  #include <linux/kthread.h>

  
  #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))

  #define DRIVER_NAME "HP CISS Driver (v 3.6.26)"
  #define DRIVER_VERSION CCISS_DRIVER_VERSION(3, 6, 26)

  
  /* Embedded module documentation macros - see modules.h */
  MODULE_AUTHOR("Hewlett-Packard Company");

  MODULE_DESCRIPTION("Driver for HP Smart Array Controllers");

  MODULE_SUPPORTED_DEVICE("HP Smart Array Controllers");
  MODULE_VERSION("3.6.26");

  MODULE_LICENSE("GPL");

  static int cciss_tape_cmds = 6;
  module_param(cciss_tape_cmds, int, 0644);
  MODULE_PARM_DESC(cciss_tape_cmds,
  	"number of commands to allocate for tape devices (default: 6)");

  static int cciss_simple_mode;
  module_param(cciss_simple_mode, int, S_IRUGO|S_IWUSR);
  MODULE_PARM_DESC(cciss_simple_mode,
  	"Use 'simple mode' rather than 'performant mode'");

  static int cciss_allow_hpsa;
  module_param(cciss_allow_hpsa, int, S_IRUGO|S_IWUSR);
  MODULE_PARM_DESC(cciss_allow_hpsa,
  	"Prevent cciss driver from accessing hardware known to be "
  	" supported by the hpsa driver");

  static DEFINE_MUTEX(cciss_mutex);

  static struct proc_dir_entry *proc_cciss;

  #include "cciss_cmd.h"
  #include "cciss.h"
  #include <linux/cciss_ioctl.h>
  
  /* define the PCI info for the cards we can control */
  static const struct pci_device_id cciss_pci_device_id[] = {

  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,  0x0E11, 0x4070},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
  	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSA,     0x103C, 0x3225},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3235},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3211},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3212},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3213},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3214},
  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3215},

  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3237},

  	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x323D},

  	{0,}
  };

  MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);

  /*  board_id = Subsystem Device ID & Vendor ID
   *  product = Marketing Name for the board

   *  access = Address of the struct of function pointers

   */
  static struct board_type products[] = {

  	{0x40700E11, "Smart Array 5300", &SA5_access},
  	{0x40800E11, "Smart Array 5i", &SA5B_access},
  	{0x40820E11, "Smart Array 532", &SA5B_access},
  	{0x40830E11, "Smart Array 5312", &SA5B_access},
  	{0x409A0E11, "Smart Array 641", &SA5_access},
  	{0x409B0E11, "Smart Array 642", &SA5_access},
  	{0x409C0E11, "Smart Array 6400", &SA5_access},
  	{0x409D0E11, "Smart Array 6400 EM", &SA5_access},
  	{0x40910E11, "Smart Array 6i", &SA5_access},
  	{0x3225103C, "Smart Array P600", &SA5_access},

  	{0x3223103C, "Smart Array P800", &SA5_access},
  	{0x3234103C, "Smart Array P400", &SA5_access},

  	{0x3235103C, "Smart Array P400i", &SA5_access},
  	{0x3211103C, "Smart Array E200i", &SA5_access},
  	{0x3212103C, "Smart Array E200", &SA5_access},
  	{0x3213103C, "Smart Array E200i", &SA5_access},
  	{0x3214103C, "Smart Array E200i", &SA5_access},
  	{0x3215103C, "Smart Array E200i", &SA5_access},
  	{0x3237103C, "Smart Array E500", &SA5_access},

  	{0x3223103C, "Smart Array P800", &SA5_access},
  	{0x3234103C, "Smart Array P400", &SA5_access},

  	{0x323D103C, "Smart Array P700m", &SA5_access},

  };

  /* How long to wait (in milliseconds) for board to go into simple mode */

  #define MAX_CONFIG_WAIT 30000

  #define MAX_IOCTL_CONFIG_WAIT 1000
  
  /*define how many times we will try a command because of bus resets */
  #define MAX_CMD_RETRIES 3

  #define MAX_CTLR	32
  
  /* Originally cciss driver only supports 8 major numbers */
  #define MAX_CTLR_ORIG 	8

  static ctlr_info_t *hba[MAX_CTLR];

  static struct task_struct *cciss_scan_thread;
  static DEFINE_MUTEX(scan_mutex);
  static LIST_HEAD(scan_q);

  static void do_cciss_request(struct request_queue *q);

  static irqreturn_t do_cciss_intx(int irq, void *dev_id);
  static irqreturn_t do_cciss_msix_intr(int irq, void *dev_id);

  static int cciss_open(struct block_device *bdev, fmode_t mode);

  static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode);

  static void cciss_release(struct gendisk *disk, fmode_t mode);

  static int cciss_ioctl(struct block_device *bdev, fmode_t mode,

  		       unsigned int cmd, unsigned long arg);

  static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);

  static int cciss_revalidate(struct gendisk *disk);

  static int rebuild_lun_table(ctlr_info_t *h, int first_time, int via_ioctl);

  static int deregister_disk(ctlr_info_t *h, int drv_index,

  			   int clear_all, int via_ioctl);

  static void cciss_read_capacity(ctlr_info_t *h, int logvol,

  			sector_t *total_size, unsigned int *block_size);

  static void cciss_read_capacity_16(ctlr_info_t *h, int logvol,

  			sector_t *total_size, unsigned int *block_size);

  static void cciss_geometry_inquiry(ctlr_info_t *h, int logvol,

  			sector_t total_size,

  			unsigned int block_size, InquiryData_struct *inq_buff,

  				   drive_info_struct *drv);

  static void cciss_interrupt_mode(ctlr_info_t *);
  static int cciss_enter_simple_mode(struct ctlr_info *h);

  static void start_io(ctlr_info_t *h);

  static int sendcmd_withirq(ctlr_info_t *h, __u8 cmd, void *buff, size_t size,

  			__u8 page_code, unsigned char scsi3addr[],
  			int cmd_type);

  static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
  	int attempt_retry);
  static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c);

  static int add_to_scan_list(struct ctlr_info *h);

  static int scan_thread(void *data);
  static int check_for_unit_attention(ctlr_info_t *h, CommandList_struct *c);

  static void cciss_hba_release(struct device *dev);
  static void cciss_device_release(struct device *dev);

  static void cciss_free_gendisk(ctlr_info_t *h, int drv_index);

  static void cciss_free_drive_info(ctlr_info_t *h, int drv_index);

  static inline u32 next_command(ctlr_info_t *h);

  static int cciss_find_cfg_addrs(struct pci_dev *pdev, void __iomem *vaddr,
  				u32 *cfg_base_addr, u64 *cfg_base_addr_index,
  				u64 *cfg_offset);
  static int cciss_pci_find_memory_BAR(struct pci_dev *pdev,
  				     unsigned long *memory_bar);

  static inline u32 cciss_tag_discard_error_bits(ctlr_info_t *h, u32 tag);

  static int write_driver_ver_to_cfgtable(CfgTable_struct __iomem *cfgtable);

  /* performant mode helper functions */
  static void  calc_bucket_map(int *bucket, int num_buckets, int nsgs,
  				int *bucket_map);
  static void cciss_put_controller_into_performant_mode(ctlr_info_t *h);

  #ifdef CONFIG_PROC_FS

  static void cciss_procinit(ctlr_info_t *h);

  #else

  static void cciss_procinit(ctlr_info_t *h)

  {
  }
  #endif				/* CONFIG_PROC_FS */

  
  #ifdef CONFIG_COMPAT

  static int cciss_compat_ioctl(struct block_device *, fmode_t,
  			      unsigned, unsigned long);

  #endif

  static const struct block_device_operations cciss_fops = {

  	.owner = THIS_MODULE,

  	.open = cciss_unlocked_open,

  	.release = cciss_release,

  	.ioctl = cciss_ioctl,

  	.getgeo = cciss_getgeo,

  #ifdef CONFIG_COMPAT

  	.compat_ioctl = cciss_compat_ioctl,

  #endif

  	.revalidate_disk = cciss_revalidate,

  };

  /* set_performant_mode: Modify the tag for cciss performant
   * set bit 0 for pull model, bits 3-1 for block fetch
   * register number
   */
  static void set_performant_mode(ctlr_info_t *h, CommandList_struct *c)
  {

  	if (likely(h->transMethod & CFGTBL_Trans_Performant))

  		c->busaddr |= 1 | (h->blockFetchTable[c->Header.SGList] << 1);
  }

  /*
   * Enqueuing and dequeuing functions for cmdlists.
   */

  static inline void addQ(struct list_head *list, CommandList_struct *c)

  {

  	list_add_tail(&c->list, list);

  }

  static inline void removeQ(CommandList_struct *c)

  {

  	/*
  	 * After kexec/dump some commands might still
  	 * be in flight, which the firmware will try
  	 * to complete. Resetting the firmware doesn't work
  	 * with old fw revisions, so we have to mark
  	 * them off as 'stale' to prevent the driver from
  	 * falling over.
  	 */

  	if (WARN_ON(list_empty(&c->list))) {

  		c->cmd_type = CMD_MSG_STALE;

  		return;

  	}

  	list_del_init(&c->list);

  }

  static void enqueue_cmd_and_start_io(ctlr_info_t *h,
  	CommandList_struct *c)
  {
  	unsigned long flags;

  	set_performant_mode(h, c);

  	spin_lock_irqsave(&h->lock, flags);
  	addQ(&h->reqQ, c);
  	h->Qdepth++;

  	if (h->Qdepth > h->maxQsinceinit)
  		h->maxQsinceinit = h->Qdepth;

  	start_io(h);
  	spin_unlock_irqrestore(&h->lock, flags);
  }

  static void cciss_free_sg_chain_blocks(SGDescriptor_struct **cmd_sg_list,

  	int nr_cmds)
  {
  	int i;
  
  	if (!cmd_sg_list)
  		return;
  	for (i = 0; i < nr_cmds; i++) {

  		kfree(cmd_sg_list[i]);
  		cmd_sg_list[i] = NULL;

  	}
  	kfree(cmd_sg_list);
  }

  static SGDescriptor_struct **cciss_allocate_sg_chain_blocks(
  	ctlr_info_t *h, int chainsize, int nr_cmds)

  {
  	int j;

  	SGDescriptor_struct **cmd_sg_list;

  
  	if (chainsize <= 0)
  		return NULL;
  
  	cmd_sg_list = kmalloc(sizeof(*cmd_sg_list) * nr_cmds, GFP_KERNEL);
  	if (!cmd_sg_list)
  		return NULL;
  
  	/* Build up chain blocks for each command */
  	for (j = 0; j < nr_cmds; j++) {

  		/* Need a block of chainsized s/g elements. */

  		cmd_sg_list[j] = kmalloc((chainsize *
  			sizeof(*cmd_sg_list[j])), GFP_KERNEL);
  		if (!cmd_sg_list[j]) {

  			dev_err(&h->pdev->dev, "Cannot get memory "
  				"for s/g chains.
  ");
  			goto clean;
  		}
  	}
  	return cmd_sg_list;
  clean:
  	cciss_free_sg_chain_blocks(cmd_sg_list, nr_cmds);
  	return NULL;
  }

  static void cciss_unmap_sg_chain_block(ctlr_info_t *h, CommandList_struct *c)
  {
  	SGDescriptor_struct *chain_sg;
  	u64bit temp64;
  
  	if (c->Header.SGTotal <= h->max_cmd_sgentries)
  		return;
  
  	chain_sg = &c->SG[h->max_cmd_sgentries - 1];
  	temp64.val32.lower = chain_sg->Addr.lower;
  	temp64.val32.upper = chain_sg->Addr.upper;
  	pci_unmap_single(h->pdev, temp64.val, chain_sg->Len, PCI_DMA_TODEVICE);
  }
  
  static void cciss_map_sg_chain_block(ctlr_info_t *h, CommandList_struct *c,
  	SGDescriptor_struct *chain_block, int len)
  {
  	SGDescriptor_struct *chain_sg;
  	u64bit temp64;
  
  	chain_sg = &c->SG[h->max_cmd_sgentries - 1];
  	chain_sg->Ext = CCISS_SG_CHAIN;
  	chain_sg->Len = len;
  	temp64.val = pci_map_single(h->pdev, chain_block, len,
  				PCI_DMA_TODEVICE);
  	chain_sg->Addr.lower = temp64.val32.lower;
  	chain_sg->Addr.upper = temp64.val32.upper;
  }

  #include "cciss_scsi.c"		/* For SCSI tape support */

  static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
  	"UNKNOWN"
  };

  #define RAID_UNKNOWN (ARRAY_SIZE(raid_label)-1)

  #ifdef CONFIG_PROC_FS
  
  /*
   * Report information about this controller.
   */
  #define ENG_GIG 1000000000
  #define ENG_GIG_FACTOR (ENG_GIG/512)

  #define ENGAGE_SCSI	"engage scsi"

  static void cciss_seq_show_header(struct seq_file *seq)

  {

  	ctlr_info_t *h = seq->private;
  
  	seq_printf(seq, "%s: HP %s Controller
  "
  		"Board ID: 0x%08lx
  "
  		"Firmware Version: %c%c%c%c
  "
  		"IRQ: %d
  "
  		"Logical drives: %d
  "
  		"Current Q depth: %d
  "
  		"Current # commands on controller: %d
  "
  		"Max Q depth since init: %d
  "
  		"Max # commands on controller since init: %d
  "
  		"Max SG entries since init: %d
  ",
  		h->devname,
  		h->product_name,
  		(unsigned long)h->board_id,
  		h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],

  		h->firm_ver[3], (unsigned int)h->intr[h->intr_mode],

  		h->num_luns,
  		h->Qdepth, h->commands_outstanding,
  		h->maxQsinceinit, h->max_outstanding, h->maxSG);
  
  #ifdef CONFIG_CISS_SCSI_TAPE

  	cciss_seq_tape_report(seq, h);

  #endif /* CONFIG_CISS_SCSI_TAPE */
  }

  static void *cciss_seq_start(struct seq_file *seq, loff_t *pos)
  {
  	ctlr_info_t *h = seq->private;

  	unsigned long flags;

  
  	/* prevent displaying bogus info during configuration
  	 * or deconfiguration of a logical volume
  	 */

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring) {

  		spin_unlock_irqrestore(&h->lock, flags);

  		return ERR_PTR(-EBUSY);

  	}
  	h->busy_configuring = 1;

  	spin_unlock_irqrestore(&h->lock, flags);

  	if (*pos == 0)
  		cciss_seq_show_header(seq);
  
  	return pos;
  }
  
  static int cciss_seq_show(struct seq_file *seq, void *v)
  {
  	sector_t vol_sz, vol_sz_frac;
  	ctlr_info_t *h = seq->private;
  	unsigned ctlr = h->ctlr;
  	loff_t *pos = v;

  	drive_info_struct *drv = h->drv[*pos];

  
  	if (*pos > h->highest_lun)
  		return 0;

  	if (drv == NULL) /* it's possible for h->drv[] to have holes. */
  		return 0;

  	if (drv->heads == 0)
  		return 0;
  
  	vol_sz = drv->nr_blocks;
  	vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
  	vol_sz_frac *= 100;
  	sector_div(vol_sz_frac, ENG_GIG_FACTOR);

  	if (drv->raid_level < 0 || drv->raid_level > RAID_UNKNOWN)

  		drv->raid_level = RAID_UNKNOWN;
  	seq_printf(seq, "cciss/c%dd%d:"
  			"\t%4u.%02uGB\tRAID %s
  ",
  			ctlr, (int) *pos, (int)vol_sz, (int)vol_sz_frac,
  			raid_label[drv->raid_level]);
  	return 0;
  }
  
  static void *cciss_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  {
  	ctlr_info_t *h = seq->private;
  
  	if (*pos > h->highest_lun)
  		return NULL;
  	*pos += 1;
  
  	return pos;
  }
  
  static void cciss_seq_stop(struct seq_file *seq, void *v)
  {
  	ctlr_info_t *h = seq->private;
  
  	/* Only reset h->busy_configuring if we succeeded in setting
  	 * it during cciss_seq_start. */
  	if (v == ERR_PTR(-EBUSY))
  		return;

  	h->busy_configuring = 0;

  }

  static const struct seq_operations cciss_seq_ops = {

  	.start = cciss_seq_start,
  	.show  = cciss_seq_show,
  	.next  = cciss_seq_next,
  	.stop  = cciss_seq_stop,
  };
  
  static int cciss_seq_open(struct inode *inode, struct file *file)
  {
  	int ret = seq_open(file, &cciss_seq_ops);
  	struct seq_file *seq = file->private_data;
  
  	if (!ret)

  		seq->private = PDE_DATA(inode);

  
  	return ret;
  }
  
  static ssize_t
  cciss_proc_write(struct file *file, const char __user *buf,
  		 size_t length, loff_t *ppos)

  {

  	int err;
  	char *buffer;
  
  #ifndef CONFIG_CISS_SCSI_TAPE
  	return -EINVAL;

  #endif

  	if (!buf || length > PAGE_SIZE - 1)

  		return -EINVAL;

  
  	buffer = (char *)__get_free_page(GFP_KERNEL);
  	if (!buffer)
  		return -ENOMEM;
  
  	err = -EFAULT;
  	if (copy_from_user(buffer, buf, length))
  		goto out;
  	buffer[length] = '\0';
  
  #ifdef CONFIG_CISS_SCSI_TAPE
  	if (strncmp(ENGAGE_SCSI, buffer, sizeof ENGAGE_SCSI - 1) == 0) {
  		struct seq_file *seq = file->private_data;
  		ctlr_info_t *h = seq->private;

  		err = cciss_engage_scsi(h);

  		if (err == 0)

  			err = length;
  	} else
  #endif /* CONFIG_CISS_SCSI_TAPE */
  		err = -EINVAL;

  	/* might be nice to have "disengage" too, but it's not
  	   safely possible. (only 1 module use count, lock issues.) */

  
  out:
  	free_page((unsigned long)buffer);
  	return err;

  }

  static const struct file_operations cciss_proc_fops = {

  	.owner	 = THIS_MODULE,
  	.open    = cciss_seq_open,
  	.read    = seq_read,
  	.llseek  = seq_lseek,
  	.release = seq_release,
  	.write	 = cciss_proc_write,
  };

  static void cciss_procinit(ctlr_info_t *h)

  {
  	struct proc_dir_entry *pde;

  	if (proc_cciss == NULL)

  		proc_cciss = proc_mkdir("driver/cciss", NULL);

  	if (!proc_cciss)
  		return;

  	pde = proc_create_data(h->devname, S_IWUSR | S_IRUSR | S_IRGRP |

  					S_IROTH, proc_cciss,

  					&cciss_proc_fops, h);

  }

  #endif				/* CONFIG_PROC_FS */

  #define MAX_PRODUCT_NAME_LEN 19
  
  #define to_hba(n) container_of(n, struct ctlr_info, dev)
  #define to_drv(n) container_of(n, drive_info_struct, dev)

  /* List of controllers which cannot be hard reset on kexec with reset_devices */

  static u32 unresettable_controller[] = {
  	0x324a103C, /* Smart Array P712m */
  	0x324b103C, /* SmartArray P711m */
  	0x3223103C, /* Smart Array P800 */
  	0x3234103C, /* Smart Array P400 */
  	0x3235103C, /* Smart Array P400i */
  	0x3211103C, /* Smart Array E200i */
  	0x3212103C, /* Smart Array E200 */
  	0x3213103C, /* Smart Array E200i */
  	0x3214103C, /* Smart Array E200i */
  	0x3215103C, /* Smart Array E200i */
  	0x3237103C, /* Smart Array E500 */
  	0x323D103C, /* Smart Array P700m */
  	0x409C0E11, /* Smart Array 6400 */
  	0x409D0E11, /* Smart Array 6400 EM */
  };

  /* List of controllers which cannot even be soft reset */
  static u32 soft_unresettable_controller[] = {
  	0x409C0E11, /* Smart Array 6400 */
  	0x409D0E11, /* Smart Array 6400 EM */
  };
  
  static int ctlr_is_hard_resettable(u32 board_id)

  {
  	int i;
  
  	for (i = 0; i < ARRAY_SIZE(unresettable_controller); i++)

  		if (unresettable_controller[i] == board_id)

  			return 0;
  	return 1;
  }

  static int ctlr_is_soft_resettable(u32 board_id)
  {
  	int i;
  
  	for (i = 0; i < ARRAY_SIZE(soft_unresettable_controller); i++)
  		if (soft_unresettable_controller[i] == board_id)
  			return 0;
  	return 1;
  }
  
  static int ctlr_is_resettable(u32 board_id)
  {
  	return ctlr_is_hard_resettable(board_id) ||
  		ctlr_is_soft_resettable(board_id);
  }

  static ssize_t host_show_resettable(struct device *dev,
  				    struct device_attribute *attr,
  				    char *buf)
  {
  	struct ctlr_info *h = to_hba(dev);

  	return snprintf(buf, 20, "%d
  ", ctlr_is_resettable(h->board_id));

  }
  static DEVICE_ATTR(resettable, S_IRUGO, host_show_resettable, NULL);

  static ssize_t host_store_rescan(struct device *dev,
  				 struct device_attribute *attr,
  				 const char *buf, size_t count)
  {
  	struct ctlr_info *h = to_hba(dev);
  
  	add_to_scan_list(h);
  	wake_up_process(cciss_scan_thread);
  	wait_for_completion_interruptible(&h->scan_wait);
  
  	return count;
  }

  static DEVICE_ATTR(rescan, S_IWUSR, NULL, host_store_rescan);

  static ssize_t host_show_transport_mode(struct device *dev,
  				 struct device_attribute *attr,
  				 char *buf)
  {
  	struct ctlr_info *h = to_hba(dev);
  
  	return snprintf(buf, 20, "%s
  ",
  		h->transMethod & CFGTBL_Trans_Performant ?
  			"performant" : "simple");
  }
  static DEVICE_ATTR(transport_mode, S_IRUGO, host_show_transport_mode, NULL);

  static ssize_t dev_show_unique_id(struct device *dev,
  				 struct device_attribute *attr,
  				 char *buf)
  {
  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);
  	__u8 sn[16];
  	unsigned long flags;
  	int ret = 0;

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring)
  		ret = -EBUSY;
  	else
  		memcpy(sn, drv->serial_no, sizeof(sn));

  	spin_unlock_irqrestore(&h->lock, flags);

  
  	if (ret)
  		return ret;
  	else
  		return snprintf(buf, 16 * 2 + 2,
  				"%02X%02X%02X%02X%02X%02X%02X%02X"
  				"%02X%02X%02X%02X%02X%02X%02X%02X
  ",
  				sn[0], sn[1], sn[2], sn[3],
  				sn[4], sn[5], sn[6], sn[7],
  				sn[8], sn[9], sn[10], sn[11],
  				sn[12], sn[13], sn[14], sn[15]);
  }

  static DEVICE_ATTR(unique_id, S_IRUGO, dev_show_unique_id, NULL);

  
  static ssize_t dev_show_vendor(struct device *dev,
  			       struct device_attribute *attr,
  			       char *buf)
  {
  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);
  	char vendor[VENDOR_LEN + 1];
  	unsigned long flags;
  	int ret = 0;

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring)
  		ret = -EBUSY;
  	else
  		memcpy(vendor, drv->vendor, VENDOR_LEN + 1);

  	spin_unlock_irqrestore(&h->lock, flags);

  
  	if (ret)
  		return ret;
  	else
  		return snprintf(buf, sizeof(vendor) + 1, "%s
  ", drv->vendor);
  }

  static DEVICE_ATTR(vendor, S_IRUGO, dev_show_vendor, NULL);

  
  static ssize_t dev_show_model(struct device *dev,
  			      struct device_attribute *attr,
  			      char *buf)
  {
  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);
  	char model[MODEL_LEN + 1];
  	unsigned long flags;
  	int ret = 0;

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring)
  		ret = -EBUSY;
  	else
  		memcpy(model, drv->model, MODEL_LEN + 1);

  	spin_unlock_irqrestore(&h->lock, flags);

  
  	if (ret)
  		return ret;
  	else
  		return snprintf(buf, sizeof(model) + 1, "%s
  ", drv->model);
  }

  static DEVICE_ATTR(model, S_IRUGO, dev_show_model, NULL);

  
  static ssize_t dev_show_rev(struct device *dev,
  			    struct device_attribute *attr,
  			    char *buf)
  {
  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);
  	char rev[REV_LEN + 1];
  	unsigned long flags;
  	int ret = 0;

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring)
  		ret = -EBUSY;
  	else
  		memcpy(rev, drv->rev, REV_LEN + 1);

  	spin_unlock_irqrestore(&h->lock, flags);

  
  	if (ret)
  		return ret;
  	else
  		return snprintf(buf, sizeof(rev) + 1, "%s
  ", drv->rev);
  }

  static DEVICE_ATTR(rev, S_IRUGO, dev_show_rev, NULL);

  static ssize_t cciss_show_lunid(struct device *dev,
  				struct device_attribute *attr, char *buf)
  {

  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);

  	unsigned long flags;
  	unsigned char lunid[8];

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring) {

  		spin_unlock_irqrestore(&h->lock, flags);

  		return -EBUSY;
  	}
  	if (!drv->heads) {

  		spin_unlock_irqrestore(&h->lock, flags);

  		return -ENOTTY;
  	}
  	memcpy(lunid, drv->LunID, sizeof(lunid));

  	spin_unlock_irqrestore(&h->lock, flags);

  	return snprintf(buf, 20, "0x%02x%02x%02x%02x%02x%02x%02x%02x
  ",
  		lunid[0], lunid[1], lunid[2], lunid[3],
  		lunid[4], lunid[5], lunid[6], lunid[7]);
  }

  static DEVICE_ATTR(lunid, S_IRUGO, cciss_show_lunid, NULL);

  static ssize_t cciss_show_raid_level(struct device *dev,
  				     struct device_attribute *attr, char *buf)
  {

  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);

  	int raid;
  	unsigned long flags;

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring) {

  		spin_unlock_irqrestore(&h->lock, flags);

  		return -EBUSY;
  	}
  	raid = drv->raid_level;

  	spin_unlock_irqrestore(&h->lock, flags);

  	if (raid < 0 || raid > RAID_UNKNOWN)
  		raid = RAID_UNKNOWN;
  
  	return snprintf(buf, strlen(raid_label[raid]) + 7, "RAID %s
  ",
  			raid_label[raid]);
  }

  static DEVICE_ATTR(raid_level, S_IRUGO, cciss_show_raid_level, NULL);

  static ssize_t cciss_show_usage_count(struct device *dev,
  				      struct device_attribute *attr, char *buf)
  {

  	drive_info_struct *drv = to_drv(dev);
  	struct ctlr_info *h = to_hba(drv->dev.parent);

  	unsigned long flags;
  	int count;

  	spin_lock_irqsave(&h->lock, flags);

  	if (h->busy_configuring) {

  		spin_unlock_irqrestore(&h->lock, flags);

  		return -EBUSY;
  	}
  	count = drv->usage_count;

  	spin_unlock_irqrestore(&h->lock, flags);

  	return snprintf(buf, 20, "%d
  ", count);
  }

  static DEVICE_ATTR(usage_count, S_IRUGO, cciss_show_usage_count, NULL);

  static struct attribute *cciss_host_attrs[] = {
  	&dev_attr_rescan.attr,

  	&dev_attr_resettable.attr,

  	&dev_attr_transport_mode.attr,

  	NULL
  };
  
  static struct attribute_group cciss_host_attr_group = {
  	.attrs = cciss_host_attrs,
  };

  static const struct attribute_group *cciss_host_attr_groups[] = {

  	&cciss_host_attr_group,
  	NULL
  };
  
  static struct device_type cciss_host_type = {
  	.name		= "cciss_host",
  	.groups		= cciss_host_attr_groups,

  	.release	= cciss_hba_release,

  };

  static struct attribute *cciss_dev_attrs[] = {
  	&dev_attr_unique_id.attr,
  	&dev_attr_model.attr,
  	&dev_attr_vendor.attr,
  	&dev_attr_rev.attr,

  	&dev_attr_lunid.attr,

  	&dev_attr_raid_level.attr,

  	&dev_attr_usage_count.attr,

  	NULL
  };
  
  static struct attribute_group cciss_dev_attr_group = {
  	.attrs = cciss_dev_attrs,
  };

  static const struct attribute_group *cciss_dev_attr_groups[] = {

  	&cciss_dev_attr_group,
  	NULL
  };
  
  static struct device_type cciss_dev_type = {
  	.name		= "cciss_device",
  	.groups		= cciss_dev_attr_groups,

  	.release	= cciss_device_release,

  };
  
  static struct bus_type cciss_bus_type = {
  	.name		= "cciss",
  };

  /*
   * cciss_hba_release is called when the reference count
   * of h->dev goes to zero.
   */
  static void cciss_hba_release(struct device *dev)
  {
  	/*
  	 * nothing to do, but need this to avoid a warning
  	 * about not having a release handler from lib/kref.c.
  	 */
  }

  
  /*
   * Initialize sysfs entry for each controller.  This sets up and registers
   * the 'cciss#' directory for each individual controller under
   * /sys/bus/pci/devices/<dev>/.
   */
  static int cciss_create_hba_sysfs_entry(struct ctlr_info *h)
  {
  	device_initialize(&h->dev);
  	h->dev.type = &cciss_host_type;
  	h->dev.bus = &cciss_bus_type;
  	dev_set_name(&h->dev, "%s", h->devname);
  	h->dev.parent = &h->pdev->dev;
  
  	return device_add(&h->dev);
  }
  
  /*
   * Remove sysfs entries for an hba.
   */
  static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h)
  {
  	device_del(&h->dev);

  	put_device(&h->dev); /* final put. */
  }
  
  /* cciss_device_release is called when the reference count

   * of h->drv[x]dev goes to zero.

   */
  static void cciss_device_release(struct device *dev)
  {

  	drive_info_struct *drv = to_drv(dev);
  	kfree(drv);

  }
  
  /*
   * Initialize sysfs for each logical drive.  This sets up and registers
   * the 'c#d#' directory for each individual logical drive under
   * /sys/bus/pci/devices/<dev/ccis#/. We also create a link from
   * /sys/block/cciss!c#d# to this entry.
   */

  static long cciss_create_ld_sysfs_entry(struct ctlr_info *h,

  				       int drv_index)
  {

  	struct device *dev;

  	if (h->drv[drv_index]->device_initialized)

  		return 0;

  	dev = &h->drv[drv_index]->dev;

  	device_initialize(dev);
  	dev->type = &cciss_dev_type;
  	dev->bus = &cciss_bus_type;
  	dev_set_name(dev, "c%dd%d", h->ctlr, drv_index);
  	dev->parent = &h->dev;

  	h->drv[drv_index]->device_initialized = 1;

  	return device_add(dev);

  }
  
  /*
   * Remove sysfs entries for a logical drive.
   */

  static void cciss_destroy_ld_sysfs_entry(struct ctlr_info *h, int drv_index,
  	int ctlr_exiting)

  {

  	struct device *dev = &h->drv[drv_index]->dev;

  
  	/* special case for c*d0, we only destroy it on controller exit */
  	if (drv_index == 0 && !ctlr_exiting)
  		return;

  	device_del(dev);
  	put_device(dev); /* the "final" put. */

  	h->drv[drv_index] = NULL;

  }

  /*
   * For operations that cannot sleep, a command block is allocated at init,

   * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track

   * which ones are free or in use.

   */

  static CommandList_struct *cmd_alloc(ctlr_info_t *h)

  {
  	CommandList_struct *c;

  	int i;

  	u64bit temp64;
  	dma_addr_t cmd_dma_handle, err_dma_handle;

  	do {
  		i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
  		if (i == h->nr_cmds)

  			return NULL;

  	} while (test_and_set_bit(i, h->cmd_pool_bits) != 0);

  	c = h->cmd_pool + i;
  	memset(c, 0, sizeof(CommandList_struct));
  	cmd_dma_handle = h->cmd_pool_dhandle + i * sizeof(CommandList_struct);
  	c->err_info = h->errinfo_pool + i;
  	memset(c->err_info, 0, sizeof(ErrorInfo_struct));
  	err_dma_handle = h->errinfo_pool_dhandle
  	    + i * sizeof(ErrorInfo_struct);
  	h->nr_allocs++;

  	c->cmdindex = i;

  	INIT_LIST_HEAD(&c->list);

  	c->busaddr = (__u32) cmd_dma_handle;
  	temp64.val = (__u64) err_dma_handle;
  	c->ErrDesc.Addr.lower = temp64.val32.lower;
  	c->ErrDesc.Addr.upper = temp64.val32.upper;
  	c->ErrDesc.Len = sizeof(ErrorInfo_struct);

  	c->ctlr = h->ctlr;
  	return c;
  }

  /* allocate a command using pci_alloc_consistent, used for ioctls,
   * etc., not for the main i/o path.
   */
  static CommandList_struct *cmd_special_alloc(ctlr_info_t *h)
  {
  	CommandList_struct *c;
  	u64bit temp64;
  	dma_addr_t cmd_dma_handle, err_dma_handle;
  
  	c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
  		sizeof(CommandList_struct), &cmd_dma_handle);
  	if (c == NULL)
  		return NULL;
  	memset(c, 0, sizeof(CommandList_struct));
  
  	c->cmdindex = -1;
  
  	c->err_info = (ErrorInfo_struct *)
  	    pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
  		    &err_dma_handle);
  
  	if (c->err_info == NULL) {
  		pci_free_consistent(h->pdev,
  			sizeof(CommandList_struct), c, cmd_dma_handle);
  		return NULL;

  	}

  	memset(c->err_info, 0, sizeof(ErrorInfo_struct));

  	INIT_LIST_HEAD(&c->list);

  	c->busaddr = (__u32) cmd_dma_handle;

  	temp64.val = (__u64) err_dma_handle;

  	c->ErrDesc.Addr.lower = temp64.val32.lower;
  	c->ErrDesc.Addr.upper = temp64.val32.upper;
  	c->ErrDesc.Len = sizeof(ErrorInfo_struct);

  	c->ctlr = h->ctlr;
  	return c;

  }

  static void cmd_free(ctlr_info_t *h, CommandList_struct *c)

  {
  	int i;

  
  	i = c - h->cmd_pool;

  	clear_bit(i, h->cmd_pool_bits);

  	h->nr_frees++;
  }
  
  static void cmd_special_free(ctlr_info_t *h, CommandList_struct *c)
  {

  	u64bit temp64;

  	temp64.val32.lower = c->ErrDesc.Addr.lower;
  	temp64.val32.upper = c->ErrDesc.Addr.upper;
  	pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
  			    c->err_info, (dma_addr_t) temp64.val);

  	pci_free_consistent(h->pdev, sizeof(CommandList_struct), c,
  		(dma_addr_t) cciss_tag_discard_error_bits(h, (u32) c->busaddr));

  }
  
  static inline ctlr_info_t *get_host(struct gendisk *disk)
  {

  	return disk->queue->queuedata;

  }
  
  static inline drive_info_struct *get_drv(struct gendisk *disk)
  {
  	return disk->private_data;
  }
  
  /*
   * Open.  Make sure the device is really there.
   */

  static int cciss_open(struct block_device *bdev, fmode_t mode)

  {

  	ctlr_info_t *h = get_host(bdev->bd_disk);

  	drive_info_struct *drv = get_drv(bdev->bd_disk);

  	dev_dbg(&h->pdev->dev, "cciss_open %s
  ", bdev->bd_disk->disk_name);

  	if (drv->busy_configuring)

  		return -EBUSY;

  	/*
  	 * Root is allowed to open raw volume zero even if it's not configured
  	 * so array config can still work. Root is also allowed to open any
  	 * volume that has a LUN ID, so it can issue IOCTL to reread the
  	 * disk information.  I don't think I really like this
  	 * but I'm already using way to many device nodes to claim another one
  	 * for "raw controller".
  	 */

  	if (drv->heads == 0) {

  		if (MINOR(bdev->bd_dev) != 0) {	/* not node 0? */

  			/* if not node 0 make sure it is a partition = 0 */

  			if (MINOR(bdev->bd_dev) & 0x0f) {

  				return -ENXIO;

  				/* if it is, make sure we have a LUN ID */

  			} else if (memcmp(drv->LunID, CTLR_LUNID,
  				sizeof(drv->LunID))) {

  				return -ENXIO;
  			}
  		}
  		if (!capable(CAP_SYS_ADMIN))
  			return -EPERM;
  	}
  	drv->usage_count++;

  	h->usage_count++;

  	return 0;
  }

  static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode)
  {
  	int ret;

  	mutex_lock(&cciss_mutex);

  	ret = cciss_open(bdev, mode);

  	mutex_unlock(&cciss_mutex);

  
  	return ret;
  }

  /*
   * Close.  Sync first.
   */

  static void cciss_release(struct gendisk *disk, fmode_t mode)

  {

  	ctlr_info_t *h;

  	drive_info_struct *drv;

  	mutex_lock(&cciss_mutex);

  	h = get_host(disk);

  	drv = get_drv(disk);

  	dev_dbg(&h->pdev->dev, "cciss_release %s
  ", disk->disk_name);

  	drv->usage_count--;

  	h->usage_count--;

  	mutex_unlock(&cciss_mutex);

  }

  #ifdef CONFIG_COMPAT

  static int cciss_ioctl32_passthru(struct block_device *bdev, fmode_t mode,
  				  unsigned cmd, unsigned long arg);
  static int cciss_ioctl32_big_passthru(struct block_device *bdev, fmode_t mode,
  				      unsigned cmd, unsigned long arg);

  static int cciss_compat_ioctl(struct block_device *bdev, fmode_t mode,
  			      unsigned cmd, unsigned long arg)

  {
  	switch (cmd) {
  	case CCISS_GETPCIINFO:
  	case CCISS_GETINTINFO:
  	case CCISS_SETINTINFO:
  	case CCISS_GETNODENAME:
  	case CCISS_SETNODENAME:
  	case CCISS_GETHEARTBEAT:
  	case CCISS_GETBUSTYPES:
  	case CCISS_GETFIRMVER:
  	case CCISS_GETDRIVVER:
  	case CCISS_REVALIDVOLS:
  	case CCISS_DEREGDISK:
  	case CCISS_REGNEWDISK:
  	case CCISS_REGNEWD:
  	case CCISS_RESCANDISK:
  	case CCISS_GETLUNINFO:

  		return cciss_ioctl(bdev, mode, cmd, arg);

  
  	case CCISS_PASSTHRU32:

  		return cciss_ioctl32_passthru(bdev, mode, cmd, arg);

  	case CCISS_BIG_PASSTHRU32:

  		return cciss_ioctl32_big_passthru(bdev, mode, cmd, arg);

  
  	default:
  		return -ENOIOCTLCMD;
  	}
  }

  static int cciss_ioctl32_passthru(struct block_device *bdev, fmode_t mode,
  				  unsigned cmd, unsigned long arg)

  {
  	IOCTL32_Command_struct __user *arg32 =

  	    (IOCTL32_Command_struct __user *) arg;

  	IOCTL_Command_struct arg64;
  	IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
  	int err;
  	u32 cp;

  	memset(&arg64, 0, sizeof(arg64));

  	err = 0;

  	err |=
  	    copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
  			   sizeof(arg64.LUN_info));
  	err |=
  	    copy_from_user(&arg64.Request, &arg32->Request,
  			   sizeof(arg64.Request));
  	err |=
  	    copy_from_user(&arg64.error_info, &arg32->error_info,
  			   sizeof(arg64.error_info));

  	err |= get_user(arg64.buf_size, &arg32->buf_size);
  	err |= get_user(cp, &arg32->buf);
  	arg64.buf = compat_ptr(cp);
  	err |= copy_to_user(p, &arg64, sizeof(arg64));
  
  	if (err)
  		return -EFAULT;

  	err = cciss_ioctl(bdev, mode, CCISS_PASSTHRU, (unsigned long)p);

  	if (err)
  		return err;

  	err |=
  	    copy_in_user(&arg32->error_info, &p->error_info,
  			 sizeof(arg32->error_info));

  	if (err)
  		return -EFAULT;
  	return err;
  }

  static int cciss_ioctl32_big_passthru(struct block_device *bdev, fmode_t mode,
  				      unsigned cmd, unsigned long arg)

  {
  	BIG_IOCTL32_Command_struct __user *arg32 =

  	    (BIG_IOCTL32_Command_struct __user *) arg;

  	BIG_IOCTL_Command_struct arg64;

  	BIG_IOCTL_Command_struct __user *p =
  	    compat_alloc_user_space(sizeof(arg64));

  	int err;
  	u32 cp;

  	memset(&arg64, 0, sizeof(arg64));

  	err = 0;

  	err |=
  	    copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
  			   sizeof(arg64.LUN_info));
  	err |=
  	    copy_from_user(&arg64.Request, &arg32->Request,
  			   sizeof(arg64.Request));
  	err |=
  	    copy_from_user(&arg64.error_info, &arg32->error_info,
  			   sizeof(arg64.error_info));

  	err |= get_user(arg64.buf_size, &arg32->buf_size);
  	err |= get_user(arg64.malloc_size, &arg32->malloc_size);
  	err |= get_user(cp, &arg32->buf);
  	arg64.buf = compat_ptr(cp);
  	err |= copy_to_user(p, &arg64, sizeof(arg64));
  
  	if (err)

  		return -EFAULT;

  	err = cciss_ioctl(bdev, mode, CCISS_BIG_PASSTHRU, (unsigned long)p);

  	if (err)
  		return err;

  	err |=
  	    copy_in_user(&arg32->error_info, &p->error_info,
  			 sizeof(arg32->error_info));

  	if (err)
  		return -EFAULT;
  	return err;
  }
  #endif

  
  static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  {
  	drive_info_struct *drv = get_drv(bdev->bd_disk);
  
  	if (!drv->cylinders)
  		return -ENXIO;
  
  	geo->heads = drv->heads;
  	geo->sectors = drv->sectors;
  	geo->cylinders = drv->cylinders;
  	return 0;
  }

  static void check_ioctl_unit_attention(ctlr_info_t *h, CommandList_struct *c)

  {
  	if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
  			c->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION)

  		(void)check_for_unit_attention(h, c);

  }

  
  static int cciss_getpciinfo(ctlr_info_t *h, void __user *argp)

  {

  	cciss_pci_info_struct pciinfo;

  	if (!argp)
  		return -EINVAL;
  	pciinfo.domain = pci_domain_nr(h->pdev->bus);
  	pciinfo.bus = h->pdev->bus->number;
  	pciinfo.dev_fn = h->pdev->devfn;
  	pciinfo.board_id = h->board_id;
  	if (copy_to_user(argp, &pciinfo, sizeof(cciss_pci_info_struct)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_getintinfo(ctlr_info_t *h, void __user *argp)
  {
  	cciss_coalint_struct intinfo;

  	unsigned long flags;

  	if (!argp)
  		return -EINVAL;

  	spin_lock_irqsave(&h->lock, flags);

  	intinfo.delay = readl(&h->cfgtable->HostWrite.CoalIntDelay);
  	intinfo.count = readl(&h->cfgtable->HostWrite.CoalIntCount);

  	spin_unlock_irqrestore(&h->lock, flags);

  	if (copy_to_user
  	    (argp, &intinfo, sizeof(cciss_coalint_struct)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_setintinfo(ctlr_info_t *h, void __user *argp)
  {
  	cciss_coalint_struct intinfo;
  	unsigned long flags;
  	int i;

  	if (!argp)
  		return -EINVAL;
  	if (!capable(CAP_SYS_ADMIN))
  		return -EPERM;
  	if (copy_from_user(&intinfo, argp, sizeof(intinfo)))
  		return -EFAULT;
  	if ((intinfo.delay == 0) && (intinfo.count == 0))
  		return -EINVAL;
  	spin_lock_irqsave(&h->lock, flags);
  	/* Update the field, and then ring the doorbell */
  	writel(intinfo.delay, &(h->cfgtable->HostWrite.CoalIntDelay));
  	writel(intinfo.count, &(h->cfgtable->HostWrite.CoalIntCount));
  	writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
  
  	for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
  		if (!(readl(h->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
  			break;
  		udelay(1000); /* delay and try again */
  	}
  	spin_unlock_irqrestore(&h->lock, flags);
  	if (i >= MAX_IOCTL_CONFIG_WAIT)
  		return -EAGAIN;
  	return 0;
  }

  static int cciss_getnodename(ctlr_info_t *h, void __user *argp)
  {
  	NodeName_type NodeName;

  	unsigned long flags;

  	int i;

  	if (!argp)
  		return -EINVAL;

  	spin_lock_irqsave(&h->lock, flags);

  	for (i = 0; i < 16; i++)
  		NodeName[i] = readb(&h->cfgtable->ServerName[i]);

  	spin_unlock_irqrestore(&h->lock, flags);

  	if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_setnodename(ctlr_info_t *h, void __user *argp)
  {
  	NodeName_type NodeName;
  	unsigned long flags;
  	int i;

  	if (!argp)
  		return -EINVAL;
  	if (!capable(CAP_SYS_ADMIN))
  		return -EPERM;
  	if (copy_from_user(NodeName, argp, sizeof(NodeName_type)))
  		return -EFAULT;
  	spin_lock_irqsave(&h->lock, flags);
  	/* Update the field, and then ring the doorbell */
  	for (i = 0; i < 16; i++)
  		writeb(NodeName[i], &h->cfgtable->ServerName[i]);
  	writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
  	for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
  		if (!(readl(h->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
  			break;
  		udelay(1000); /* delay and try again */
  	}
  	spin_unlock_irqrestore(&h->lock, flags);
  	if (i >= MAX_IOCTL_CONFIG_WAIT)
  		return -EAGAIN;
  	return 0;
  }

  static int cciss_getheartbeat(ctlr_info_t *h, void __user *argp)
  {
  	Heartbeat_type heartbeat;

  	unsigned long flags;

  	if (!argp)
  		return -EINVAL;

  	spin_lock_irqsave(&h->lock, flags);

  	heartbeat = readl(&h->cfgtable->HeartBeat);

  	spin_unlock_irqrestore(&h->lock, flags);

  	if (copy_to_user(argp, &heartbeat, sizeof(Heartbeat_type)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_getbustypes(ctlr_info_t *h, void __user *argp)
  {
  	BusTypes_type BusTypes;

  	unsigned long flags;

  	if (!argp)
  		return -EINVAL;

  	spin_lock_irqsave(&h->lock, flags);

  	BusTypes = readl(&h->cfgtable->BusTypes);

  	spin_unlock_irqrestore(&h->lock, flags);

  	if (copy_to_user(argp, &BusTypes, sizeof(BusTypes_type)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_getfirmver(ctlr_info_t *h, void __user *argp)
  {
  	FirmwareVer_type firmware;
  
  	if (!argp)
  		return -EINVAL;
  	memcpy(firmware, h->firm_ver, 4);
  
  	if (copy_to_user
  	    (argp, firmware, sizeof(FirmwareVer_type)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_getdrivver(ctlr_info_t *h, void __user *argp)
  {
  	DriverVer_type DriverVer = DRIVER_VERSION;
  
  	if (!argp)
  		return -EINVAL;
  	if (copy_to_user(argp, &DriverVer, sizeof(DriverVer_type)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_getluninfo(ctlr_info_t *h,
  	struct gendisk *disk, void __user *argp)
  {
  	LogvolInfo_struct luninfo;
  	drive_info_struct *drv = get_drv(disk);
  
  	if (!argp)
  		return -EINVAL;
  	memcpy(&luninfo.LunID, drv->LunID, sizeof(luninfo.LunID));
  	luninfo.num_opens = drv->usage_count;
  	luninfo.num_parts = 0;
  	if (copy_to_user(argp, &luninfo, sizeof(LogvolInfo_struct)))
  		return -EFAULT;
  	return 0;
  }

  static int cciss_passthru(ctlr_info_t *h, void __user *argp)
  {
  	IOCTL_Command_struct iocommand;
  	CommandList_struct *c;
  	char *buff = NULL;
  	u64bit temp64;
  	DECLARE_COMPLETION_ONSTACK(wait);
  
  	if (!argp)
  		return -EINVAL;
  
  	if (!capable(CAP_SYS_RAWIO))
  		return -EPERM;
  
  	if (copy_from_user
  	    (&iocommand, argp, sizeof(IOCTL_Command_struct)))
  		return -EFAULT;
  	if ((iocommand.buf_size < 1) &&
  	    (iocommand.Request.Type.Direction != XFER_NONE)) {
  		return -EINVAL;
  	}
  	if (iocommand.buf_size > 0) {
  		buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
  		if (buff == NULL)
  			return -EFAULT;
  	}
  	if (iocommand.Request.Type.Direction == XFER_WRITE) {
  		/* Copy the data into the buffer we created */
  		if (copy_from_user(buff, iocommand.buf, iocommand.buf_size)) {
  			kfree(buff);
  			return -EFAULT;
  		}
  	} else {
  		memset(buff, 0, iocommand.buf_size);
  	}
  	c = cmd_special_alloc(h);
  	if (!c) {
  		kfree(buff);
  		return -ENOMEM;
  	}
  	/* Fill in the command type */
  	c->cmd_type = CMD_IOCTL_PEND;
  	/* Fill in Command Header */
  	c->Header.ReplyQueue = 0;   /* unused in simple mode */
  	if (iocommand.buf_size > 0) { /* buffer to fill */
  		c->Header.SGList = 1;
  		c->Header.SGTotal = 1;
  	} else { /* no buffers to fill */
  		c->Header.SGList = 0;
  		c->Header.SGTotal = 0;
  	}
  	c->Header.LUN = iocommand.LUN_info;
  	/* use the kernel address the cmd block for tag */
  	c->Header.Tag.lower = c->busaddr;
  
  	/* Fill in Request block */
  	c->Request = iocommand.Request;
  
  	/* Fill in the scatter gather information */
  	if (iocommand.buf_size > 0) {
  		temp64.val = pci_map_single(h->pdev, buff,
  			iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
  		c->SG[0].Addr.lower = temp64.val32.lower;
  		c->SG[0].Addr.upper = temp64.val32.upper;
  		c->SG[0].Len = iocommand.buf_size;
  		c->SG[0].Ext = 0;  /* we are not chaining */
  	}
  	c->waiting = &wait;
  
  	enqueue_cmd_and_start_io(h, c);
  	wait_for_completion(&wait);
  
  	/* unlock the buffers from DMA */
  	temp64.val32.lower = c->SG[0].Addr.lower;
  	temp64.val32.upper = c->SG[0].Addr.upper;
  	pci_unmap_single(h->pdev, (dma_addr_t) temp64.val, iocommand.buf_size,
  			 PCI_DMA_BIDIRECTIONAL);
  	check_ioctl_unit_attention(h, c);
  
  	/* Copy the error information out */
  	iocommand.error_info = *(c->err_info);
  	if (copy_to_user(argp, &iocommand, sizeof(IOCTL_Command_struct))) {
  		kfree(buff);
  		cmd_special_free(h, c);
  		return -EFAULT;
  	}
  
  	if (iocommand.Request.Type.Direction == XFER_READ) {
  		/* Copy the data out of the buffer we created */
  		if (copy_to_user(iocommand.buf, buff, iocommand.buf_size)) {

  			kfree(buff);

  			cmd_special_free(h, c);

  			return -EFAULT;

  		}

  	}
  	kfree(buff);
  	cmd_special_free(h, c);
  	return 0;
  }

  static int cciss_bigpassthru(ctlr_info_t *h, void __user *argp)
  {
  	BIG_IOCTL_Command_struct *ioc;
  	CommandList_struct *c;
  	unsigned char **buff = NULL;
  	int *buff_size = NULL;
  	u64bit temp64;
  	BYTE sg_used = 0;
  	int status = 0;
  	int i;
  	DECLARE_COMPLETION_ONSTACK(wait);
  	__u32 left;
  	__u32 sz;
  	BYTE __user *data_ptr;
  
  	if (!argp)
  		return -EINVAL;
  	if (!capable(CAP_SYS_RAWIO))
  		return -EPERM;

  	ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);

  	if (!ioc) {
  		status = -ENOMEM;
  		goto cleanup1;
  	}
  	if (copy_from_user(ioc, argp, sizeof(*ioc))) {
  		status = -EFAULT;
  		goto cleanup1;
  	}
  	if ((ioc->buf_size < 1) &&
  	    (ioc->Request.Type.Direction != XFER_NONE)) {
  		status = -EINVAL;
  		goto cleanup1;
  	}
  	/* Check kmalloc limits  using all SGs */
  	if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
  		status = -EINVAL;
  		goto cleanup1;
  	}
  	if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
  		status = -EINVAL;
  		goto cleanup1;
  	}
  	buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
  	if (!buff) {
  		status = -ENOMEM;
  		goto cleanup1;
  	}
  	buff_size = kmalloc(MAXSGENTRIES * sizeof(int), GFP_KERNEL);
  	if (!buff_size) {
  		status = -ENOMEM;
  		goto cleanup1;
  	}
  	left = ioc->buf_size;
  	data_ptr = ioc->buf;
  	while (left) {
  		sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
  		buff_size[sg_used] = sz;
  		buff[sg_used] = kmalloc(sz, GFP_KERNEL);
  		if (buff[sg_used] == NULL) {
  			status = -ENOMEM;
  			goto cleanup1;
  		}
  		if (ioc->Request.Type.Direction == XFER_WRITE) {
  			if (copy_from_user(buff[sg_used], data_ptr, sz)) {

  				status = -EFAULT;
  				goto cleanup1;
  			}

  		} else {
  			memset(buff[sg_used], 0, sz);
  		}
  		left -= sz;
  		data_ptr += sz;
  		sg_used++;
  	}
  	c = cmd_special_alloc(h);
  	if (!c) {
  		status = -ENOMEM;
  		goto cleanup1;
  	}
  	c->cmd_type = CMD_IOCTL_PEND;
  	c->Header.ReplyQueue = 0;

  	c->Header.SGList = sg_used;
  	c->Header.SGTotal = sg_used;

  	c->Header.LUN = ioc->LUN_info;
  	c->Header.Tag.lower = c->busaddr;
  
  	c->Request = ioc->Request;

  	for (i = 0; i < sg_used; i++) {
  		temp64.val = pci_map_single(h->pdev, buff[i], buff_size[i],

  				    PCI_DMA_BIDIRECTIONAL);

  		c->SG[i].Addr.lower = temp64.val32.lower;
  		c->SG[i].Addr.upper = temp64.val32.upper;
  		c->SG[i].Len = buff_size[i];
  		c->SG[i].Ext = 0;	/* we are not chaining */

  	}
  	c->waiting = &wait;
  	enqueue_cmd_and_start_io(h, c);
  	wait_for_completion(&wait);
  	/* unlock the buffers from DMA */
  	for (i = 0; i < sg_used; i++) {
  		temp64.val32.lower = c->SG[i].Addr.lower;
  		temp64.val32.upper = c->SG[i].Addr.upper;
  		pci_unmap_single(h->pdev,
  			(dma_addr_t) temp64.val, buff_size[i],
  			PCI_DMA_BIDIRECTIONAL);
  	}
  	check_ioctl_unit_attention(h, c);
  	/* Copy the error information out */
  	ioc->error_info = *(c->err_info);
  	if (copy_to_user(argp, ioc, sizeof(*ioc))) {
  		cmd_special_free(h, c);
  		status = -EFAULT;
  		goto cleanup1;
  	}
  	if (ioc->Request.Type.Direction == XFER_READ) {
  		/* Copy the data out of the buffer we created */
  		BYTE __user *ptr = ioc->buf;
  		for (i = 0; i < sg_used; i++) {
  			if (copy_to_user(ptr, buff[i], buff_size[i])) {

  				cmd_special_free(h, c);

  				status = -EFAULT;
  				goto cleanup1;
  			}

  			ptr += buff_size[i];

  		}

  	}
  	cmd_special_free(h, c);
  	status = 0;
  cleanup1:
  	if (buff) {
  		for (i = 0; i < sg_used; i++)
  			kfree(buff[i]);
  		kfree(buff);
  	}
  	kfree(buff_size);
  	kfree(ioc);
  	return status;
  }

  static int cciss_ioctl(struct block_device *bdev, fmode_t mode,

  	unsigned int cmd, unsigned long arg)

  {

  	struct gendisk *disk = bdev->bd_disk;

  	ctlr_info_t *h = get_host(disk);

  	void __user *argp = (void __user *)arg;

  	dev_dbg(&h->pdev->dev, "cciss_ioctl: Called with cmd=%x %lx
  ",
  		cmd, arg);

  	switch (cmd) {

  	case CCISS_GETPCIINFO:

  		return cciss_getpciinfo(h, argp);

  	case CCISS_GETINTINFO:

  		return cciss_getintinfo(h, argp);

  	case CCISS_SETINTINFO:

  		return cciss_setintinfo(h, argp);

  	case CCISS_GETNODENAME:

  		return cciss_getnodename(h, argp);

  	case CCISS_SETNODENAME:

  		return cciss_setnodename(h, argp);

  	case CCISS_GETHEARTBEAT:

  		return cciss_getheartbeat(h, argp);

  	case CCISS_GETBUSTYPES:

  		return cciss_getbustypes(h, argp);

  	case CCISS_GETFIRMVER:

  		return cciss_getfirmver(h, argp);

  	case CCISS_GETDRIVVER:

  		return cciss_getdrivver(h, argp);

  	case CCISS_DEREGDISK:
  	case CCISS_REGNEWD:

  	case CCISS_REVALIDVOLS:

  		return rebuild_lun_table(h, 0, 1);

  	case CCISS_GETLUNINFO:
  		return cciss_getluninfo(h, disk, argp);

  	case CCISS_PASSTHRU:

  		return cciss_passthru(h, argp);

  	case CCISS_BIG_PASSTHRU:
  		return cciss_bigpassthru(h, argp);

  	/* scsi_cmd_blk_ioctl handles these, below, though some are not */

  	/* very meaningful for cciss.  SG_IO is the main one people want. */
  
  	case SG_GET_VERSION_NUM:
  	case SG_SET_TIMEOUT:
  	case SG_GET_TIMEOUT:
  	case SG_GET_RESERVED_SIZE:
  	case SG_SET_RESERVED_SIZE:
  	case SG_EMULATED_HOST:
  	case SG_IO:
  	case SCSI_IOCTL_SEND_COMMAND:

  		return scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);

  	/* scsi_cmd_blk_ioctl would normally handle these, below, but */

  	/* they aren't a good fit for cciss, as CD-ROMs are */
  	/* not supported, and we don't have any bus/target/lun */
  	/* which we present to the kernel. */
  
  	case CDROM_SEND_PACKET:
  	case CDROMCLOSETRAY:
  	case CDROMEJECT:
  	case SCSI_IOCTL_GET_IDLUN:
  	case SCSI_IOCTL_GET_BUS_NUMBER:

  	default:
  		return -ENOTTY;
  	}

  }

  static void cciss_check_queues(ctlr_info_t *h)
  {
  	int start_queue = h->next_to_run;
  	int i;
  
  	/* check to see if we have maxed out the number of commands that can
  	 * be placed on the queue.  If so then exit.  We do this check here
  	 * in case the interrupt we serviced was from an ioctl and did not
  	 * free any new commands.
  	 */

  	if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)

  		return;
  
  	/* We have room on the queue for more commands.  Now we need to queue
  	 * them up.  We will also keep track of the next queue to run so
  	 * that every queue gets a chance to be started first.
  	 */
  	for (i = 0; i < h->highest_lun + 1; i++) {
  		int curr_queue = (start_queue + i) % (h->highest_lun + 1);
  		/* make sure the disk has been added and the drive is real
  		 * because this can be called from the middle of init_one.
  		 */

  		if (!h->drv[curr_queue])
  			continue;
  		if (!(h->drv[curr_queue]->queue) ||
  			!(h->drv[curr_queue]->heads))

  			continue;
  		blk_start_queue(h->gendisk[curr_queue]->queue);
  
  		/* check to see if we have maxed out the number of commands
  		 * that can be placed on the queue.
  		 */

  		if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {

  			if (curr_queue == start_queue) {
  				h->next_to_run =
  				    (start_queue + 1) % (h->highest_lun + 1);
  				break;
  			} else {
  				h->next_to_run = curr_queue;
  				break;
  			}

  		}
  	}
  }

  static void cciss_softirq_done(struct request *rq)
  {

  	CommandList_struct *c = rq->completion_data;
  	ctlr_info_t *h = hba[c->ctlr];
  	SGDescriptor_struct *curr_sg = c->SG;

  	u64bit temp64;

  	unsigned long flags;

  	int i, ddir;

  	int sg_index = 0;

  	if (c->Request.Type.Direction == XFER_READ)

  		ddir = PCI_DMA_FROMDEVICE;
  	else
  		ddir = PCI_DMA_TODEVICE;
  
  	/* command did not need to be retried */
  	/* unmap the DMA mapping for all the scatter gather elements */

  	for (i = 0; i < c->Header.SGList; i++) {

  		if (curr_sg[sg_index].Ext == CCISS_SG_CHAIN) {

  			cciss_unmap_sg_chain_block(h, c);

  			/* Point to the next block */

  			curr_sg = h->cmd_sg_list[c->cmdindex];

  			sg_index = 0;
  		}
  		temp64.val32.lower = curr_sg[sg_index].Addr.lower;
  		temp64.val32.upper = curr_sg[sg_index].Addr.upper;
  		pci_unmap_page(h->pdev, temp64.val, curr_sg[sg_index].Len,
  				ddir);
  		++sg_index;

  	}

  	dev_dbg(&h->pdev->dev, "Done with %p
  ", rq);

  	/* set the residual count for pc requests */

  	if (rq->cmd_type == REQ_TYPE_BLOCK_PC)

  		rq->resid_len = c->err_info->ResidualCnt;

  	blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);

  	spin_lock_irqsave(&h->lock, flags);

  	cmd_free(h, c);

  	cciss_check_queues(h);

  	spin_unlock_irqrestore(&h->lock, flags);
  }

  static inline void log_unit_to_scsi3addr(ctlr_info_t *h,
  	unsigned char scsi3addr[], uint32_t log_unit)

  {

  	memcpy(scsi3addr, h->drv[log_unit]->LunID,
  		sizeof(h->drv[log_unit]->LunID));

  }

  /* This function gets the SCSI vendor, model, and revision of a logical drive
   * via the inquiry page 0.  Model, vendor, and rev are set to empty strings if
   * they cannot be read.
   */

  static void cciss_get_device_descr(ctlr_info_t *h, int logvol,

  				   char *vendor, char *model, char *rev)
  {
  	int rc;
  	InquiryData_struct *inq_buf;

  	unsigned char scsi3addr[8];

  
  	*vendor = '\0';
  	*model = '\0';
  	*rev = '\0';
  
  	inq_buf = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL);
  	if (!inq_buf)
  		return;

  	log_unit_to_scsi3addr(h, scsi3addr, logvol);
  	rc = sendcmd_withirq(h, CISS_INQUIRY, inq_buf, sizeof(*inq_buf), 0,

  			scsi3addr, TYPE_CMD);

  	if (rc == IO_OK) {
  		memcpy(vendor, &inq_buf->data_byte[8], VENDOR_LEN);
  		vendor[VENDOR_LEN] = '\0';
  		memcpy(model, &inq_buf->data_byte[16], MODEL_LEN);
  		model[MODEL_LEN] = '\0';
  		memcpy(rev, &inq_buf->data_byte[32], REV_LEN);
  		rev[REV_LEN] = '\0';
  	}
  
  	kfree(inq_buf);
  	return;
  }

  /* This function gets the serial number of a logical drive via
   * inquiry page 0x83.  Serial no. is 16 bytes.  If the serial
   * number cannot be had, for whatever reason, 16 bytes of 0xff
   * are returned instead.
   */

  static void cciss_get_serial_no(ctlr_info_t *h, int logvol,

  				unsigned char *serial_no, int buflen)
  {
  #define PAGE_83_INQ_BYTES 64
  	int rc;
  	unsigned char *buf;

  	unsigned char scsi3addr[8];

  
  	if (buflen > 16)
  		buflen = 16;
  	memset(serial_no, 0xff, buflen);
  	buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
  	if (!buf)
  		return;
  	memset(serial_no, 0, buflen);

  	log_unit_to_scsi3addr(h, scsi3addr, logvol);
  	rc = sendcmd_withirq(h, CISS_INQUIRY, buf,

  		PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);

  	if (rc == IO_OK)
  		memcpy(serial_no, &buf[8], buflen);
  	kfree(buf);
  	return;
  }

  /*
   * cciss_add_disk sets up the block device queue for a logical drive
   */
  static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,

  				int drv_index)
  {
  	disk->queue = blk_init_queue(do_cciss_request, &h->lock);

  	if (!disk->queue)
  		goto init_queue_failure;

  	sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index);
  	disk->major = h->major;
  	disk->first_minor = drv_index << NWD_SHIFT;
  	disk->fops = &cciss_fops;

  	if (cciss_create_ld_sysfs_entry(h, drv_index))
  		goto cleanup_queue;
  	disk->private_data = h->drv[drv_index];
  	disk->driverfs_dev = &h->drv[drv_index]->dev;

  
  	/* Set up queue information */
  	blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
  
  	/* This is a hardware imposed limit. */

  	blk_queue_max_segments(disk->queue, h->maxsgentries);

  	blk_queue_max_hw_sectors(disk->queue, h->cciss_max_sectors);

  
  	blk_queue_softirq_done(disk->queue, cciss_softirq_done);
  
  	disk->queue->queuedata = h;

  	blk_queue_logical_block_size(disk->queue,

  				     h->drv[drv_index]->block_size);

  
  	/* Make sure all queue data is written out before */

  	/* setting h->drv[drv_index]->queue, as setting this */

  	/* allows the interrupt handler to start the queue */
  	wmb();

  	h->drv[drv_index]->queue = disk->queue;

  	add_disk(disk);

  	return 0;
  
  cleanup_queue:
  	blk_cleanup_queue(disk->queue);
  	disk->queue = NULL;

  init_queue_failure:

  	return -1;

  }

  /* This function will check the usage_count of the drive to be updated/added.

   * If the usage_count is zero and it is a heretofore unknown drive, or,
   * the drive's capacity, geometry, or serial number has changed,
   * then the drive information will be updated and the disk will be
   * re-registered with the kernel.  If these conditions don't hold,
   * then it will be left alone for the next reboot.  The exception to this
   * is disk 0 which will always be left registered with the kernel since it
   * is also the controller node.  Any changes to disk 0 will show up on
   * the next reboot.

   */

  static void cciss_update_drive_info(ctlr_info_t *h, int drv_index,
  	int first_time, int via_ioctl)

  {

  	struct gendisk *disk;

  	InquiryData_struct *inq_buff = NULL;
  	unsigned int block_size;