| /* |
| * 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/kernel.h> |
| #include <linux/slab.h> |
| #include <linux/smp_lock.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 <asm/uaccess.h> |
| #include <asm/io.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.20)" |
| #define DRIVER_VERSION CCISS_DRIVER_VERSION(3, 6, 20) |
| |
| /* Embedded module documentation macros - see modules.h */ |
| MODULE_AUTHOR("Hewlett-Packard Company"); |
| MODULE_DESCRIPTION("Driver for HP Smart Array Controllers"); |
| MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400" |
| " SA6i P600 P800 P400 P400i E200 E200i E500 P700m" |
| " Smart Array G2 Series SAS/SATA Controllers"); |
| MODULE_VERSION("3.6.20"); |
| MODULE_LICENSE("GPL"); |
| |
| 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"); |
| |
| #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}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3241}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3243}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3245}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3247}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3249}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x324A}, |
| {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x324B}, |
| {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}, |
| {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}, |
| /* controllers below this line are also supported by the hpsa driver. */ |
| #define HPSA_BOUNDARY 0x3223103C |
| {0x3223103C, "Smart Array P800", &SA5_access}, |
| {0x3234103C, "Smart Array P400", &SA5_access}, |
| {0x323D103C, "Smart Array P700m", &SA5_access}, |
| {0x3241103C, "Smart Array P212", &SA5_access}, |
| {0x3243103C, "Smart Array P410", &SA5_access}, |
| {0x3245103C, "Smart Array P410i", &SA5_access}, |
| {0x3247103C, "Smart Array P411", &SA5_access}, |
| {0x3249103C, "Smart Array P812", &SA5_access}, |
| {0x324A103C, "Smart Array P712m", &SA5_access}, |
| {0x324B103C, "Smart Array P711m", &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_intr(int irq, void *dev_id); |
| static int cciss_open(struct block_device *bdev, fmode_t mode); |
| static int 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(int ctlr, int logvol, |
| sector_t *total_size, unsigned int *block_size); |
| static void cciss_read_capacity_16(int ctlr, int logvol, |
| sector_t *total_size, unsigned int *block_size); |
| static void cciss_geometry_inquiry(int ctlr, int logvol, |
| sector_t total_size, |
| unsigned int block_size, InquiryData_struct *inq_buff, |
| drive_info_struct *drv); |
| static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, |
| __u32); |
| static void start_io(ctlr_info_t *h); |
| static int sendcmd_withirq(__u8 cmd, int ctlr, 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 void fail_all_cmds(unsigned long ctlr); |
| 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); |
| |
| #ifdef CONFIG_PROC_FS |
| static void cciss_procinit(int i); |
| #else |
| static void cciss_procinit(int i) |
| { |
| } |
| #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_open, |
| .release = cciss_release, |
| .locked_ioctl = cciss_ioctl, |
| .getgeo = cciss_getgeo, |
| #ifdef CONFIG_COMPAT |
| .compat_ioctl = cciss_compat_ioctl, |
| #endif |
| .revalidate_disk = cciss_revalidate, |
| }; |
| |
| /* |
| * Enqueuing and dequeuing functions for cmdlists. |
| */ |
| static inline void addQ(struct hlist_head *list, CommandList_struct *c) |
| { |
| hlist_add_head(&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(hlist_unhashed(&c->list))) { |
| c->cmd_type = CMD_MSG_STALE; |
| return; |
| } |
| |
| hlist_del_init(&c->list); |
| } |
| |
| 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.\n"); |
| 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 (sizeof(raid_label) / sizeof(raid_label[0])-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 struct proc_dir_entry *proc_cciss; |
| |
| static void cciss_seq_show_header(struct seq_file *seq) |
| { |
| ctlr_info_t *h = seq->private; |
| |
| seq_printf(seq, "%s: HP %s Controller\n" |
| "Board ID: 0x%08lx\n" |
| "Firmware Version: %c%c%c%c\n" |
| "IRQ: %d\n" |
| "Logical drives: %d\n" |
| "Current Q depth: %d\n" |
| "Current # commands on controller: %d\n" |
| "Max Q depth since init: %d\n" |
| "Max # commands on controller since init: %d\n" |
| "Max SG entries since init: %d\n", |
| 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[SIMPLE_MODE_INT], |
| 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->ctlr); |
| #endif /* CONFIG_CISS_SCSI_TAPE */ |
| } |
| |
| static void *cciss_seq_start(struct seq_file *seq, loff_t *pos) |
| { |
| ctlr_info_t *h = seq->private; |
| unsigned ctlr = h->ctlr; |
| unsigned long flags; |
| |
| /* prevent displaying bogus info during configuration |
| * or deconfiguration of a logical volume |
| */ |
| spin_lock_irqsave(CCISS_LOCK(ctlr), flags); |
| if (h->busy_configuring) { |
| spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); |
| return ERR_PTR(-EBUSY); |
| } |
| h->busy_configuring = 1; |
| spin_unlock_irqrestore(CCISS_LOCK(ctlr), 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\n", |
| 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(inode)->data; |
| |
| 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->ctlr); |
| 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 __devinit cciss_procinit(int i) |
| { |
| struct proc_dir_entry *pde; |
| |
| if (proc_cciss == NULL) |
| proc_cciss = proc_mkdir("driver/cciss", NULL); |
| if (!proc_cciss) |
| return; |
| pde = proc_create_data(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP | |
| S_IROTH, proc_cciss, |
| &cciss_proc_fops, hba[i]); |
| } |
| #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) |
| |
| 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 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) |
| ret = -EBUSY; |
| else |
| memcpy(sn, drv->serial_no, sizeof(sn)); |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), 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\n", |
| 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) |
| ret = -EBUSY; |
| else |
| memcpy(vendor, drv->vendor, VENDOR_LEN + 1); |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| |
| if (ret) |
| return ret; |
| else |
| return snprintf(buf, sizeof(vendor) + 1, "%s\n", 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) |
| ret = -EBUSY; |
| else |
| memcpy(model, drv->model, MODEL_LEN + 1); |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| |
| if (ret) |
| return ret; |
| else |
| return snprintf(buf, sizeof(model) + 1, "%s\n", 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) |
| ret = -EBUSY; |
| else |
| memcpy(rev, drv->rev, REV_LEN + 1); |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| |
| if (ret) |
| return ret; |
| else |
| return snprintf(buf, sizeof(rev) + 1, "%s\n", 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) { |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return -EBUSY; |
| } |
| if (!drv->heads) { |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return -ENOTTY; |
| } |
| memcpy(lunid, drv->LunID, sizeof(lunid)); |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return snprintf(buf, 20, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
| 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) { |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return -EBUSY; |
| } |
| raid = drv->raid_level; |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| if (raid < 0 || raid > RAID_UNKNOWN) |
| raid = RAID_UNKNOWN; |
| |
| return snprintf(buf, strlen(raid_label[raid]) + 7, "RAID %s\n", |
| 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(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) { |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return -EBUSY; |
| } |
| count = drv->usage_count; |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return snprintf(buf, 20, "%d\n", count); |
| } |
| static DEVICE_ATTR(usage_count, S_IRUGO, cciss_show_usage_count, NULL); |
| |
| static struct attribute *cciss_host_attrs[] = { |
| &dev_attr_rescan.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. For operations that can wait for kmalloc |
| * to possible sleep, this routine can be called with get_from_pool set to 0. |
| * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was. |
| */ |
| static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool) |
| { |
| CommandList_struct *c; |
| int i; |
| u64bit temp64; |
| dma_addr_t cmd_dma_handle, err_dma_handle; |
| |
| if (!get_from_pool) { |
| 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)); |
| } else { /* get it out of the controllers pool */ |
| |
| 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 & (BITS_PER_LONG - 1), |
| h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0); |
| #ifdef CCISS_DEBUG |
| printk(KERN_DEBUG "cciss: using command buffer %d\n", i); |
| #endif |
| 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_HLIST_NODE(&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; |
| } |
| |
| /* |
| * Frees a command block that was previously allocated with cmd_alloc(). |
| */ |
| static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool) |
| { |
| int i; |
| u64bit temp64; |
| |
| if (!got_from_pool) { |
| 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) c->busaddr); |
| } else { |
| i = c - h->cmd_pool; |
| clear_bit(i & (BITS_PER_LONG - 1), |
| h->cmd_pool_bits + (i / BITS_PER_LONG)); |
| h->nr_frees++; |
| } |
| } |
| |
| 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 *host = get_host(bdev->bd_disk); |
| drive_info_struct *drv = get_drv(bdev->bd_disk); |
| |
| #ifdef CCISS_DEBUG |
| printk(KERN_DEBUG "cciss_open %s\n", bdev->bd_disk->disk_name); |
| #endif /* CCISS_DEBUG */ |
| |
| 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++; |
| host->usage_count++; |
| return 0; |
| } |
| |
| /* |
| * Close. Sync first. |
| */ |
| static int cciss_release(struct gendisk *disk, fmode_t mode) |
| { |
| ctlr_info_t *host = get_host(disk); |
| drive_info_struct *drv = get_drv(disk); |
| |
| #ifdef CCISS_DEBUG |
| printk(KERN_DEBUG "cciss_release %s\n", disk->disk_name); |
| #endif /* CCISS_DEBUG */ |
| |
| drv->usage_count--; |
| host->usage_count--; |
| return 0; |
| } |
| |
| #ifdef CONFIG_COMPAT |
| |
| static int do_ioctl(struct block_device *bdev, fmode_t mode, |
| unsigned cmd, unsigned long arg) |
| { |
| int ret; |
| lock_kernel(); |
| ret = cciss_ioctl(bdev, mode, cmd, arg); |
| unlock_kernel(); |
| return ret; |
| } |
| |
| 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 do_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; |
| |
| 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 = do_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; |
| |
| 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 = do_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 *host, CommandList_struct *c) |
| { |
| if (c->err_info->CommandStatus == CMD_TARGET_STATUS && |
| c->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) |
| (void)check_for_unit_attention(host, c); |
| } |
| /* |
| * ioctl |
| */ |
| 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 *host = get_host(disk); |
| drive_info_struct *drv = get_drv(disk); |
| int ctlr = host->ctlr; |
| void __user *argp = (void __user *)arg; |
| |
| #ifdef CCISS_DEBUG |
| printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg); |
| #endif /* CCISS_DEBUG */ |
| |
| switch (cmd) { |
| case CCISS_GETPCIINFO: |
| { |
| cciss_pci_info_struct pciinfo; |
| |
| if (!arg) |
| return -EINVAL; |
| pciinfo.domain = pci_domain_nr(host->pdev->bus); |
| pciinfo.bus = host->pdev->bus->number; |
| pciinfo.dev_fn = host->pdev->devfn; |
| pciinfo.board_id = host->board_id; |
| if (copy_to_user |
| (argp, &pciinfo, sizeof(cciss_pci_info_struct))) |
| return -EFAULT; |
| return 0; |
| } |
| case CCISS_GETINTINFO: |
| { |
| cciss_coalint_struct intinfo; |
| if (!arg) |
| return -EINVAL; |
| intinfo.delay = |
| readl(&host->cfgtable->HostWrite.CoalIntDelay); |
| intinfo.count = |
| readl(&host->cfgtable->HostWrite.CoalIntCount); |
| if (copy_to_user |
| (argp, &intinfo, sizeof(cciss_coalint_struct))) |
| return -EFAULT; |
| return 0; |
| } |
| case CCISS_SETINTINFO: |
| { |
| cciss_coalint_struct intinfo; |
| unsigned long flags; |
| int i; |
| |
| if (!arg) |
| return -EINVAL; |
| if (!capable(CAP_SYS_ADMIN)) |
| return -EPERM; |
| if (copy_from_user |
| (&intinfo, argp, sizeof(cciss_coalint_struct))) |
| return -EFAULT; |
| if ((intinfo.delay == 0) && (intinfo.count == 0)) |
| { |
| // printk("cciss_ioctl: delay and count cannot be 0\n"); |
| return -EINVAL; |
| } |
| spin_lock_irqsave(CCISS_LOCK(ctlr), flags); |
| /* Update the field, and then ring the doorbell */ |
| writel(intinfo.delay, |
| &(host->cfgtable->HostWrite.CoalIntDelay)); |
| writel(intinfo.count, |
| &(host->cfgtable->HostWrite.CoalIntCount)); |
| writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL); |
| |
| for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) { |
| if (!(readl(host->vaddr + SA5_DOORBELL) |
| & CFGTBL_ChangeReq)) |
| break; |
| /* delay and try again */ |
| udelay(1000); |
| } |
| spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); |
| if (i >= MAX_IOCTL_CONFIG_WAIT) |
| return -EAGAIN; |
| return 0; |
| } |
| case CCISS_GETNODENAME: |
| { |
| NodeName_type NodeName; |
| int i; |
| |
| if (!arg) |
| return -EINVAL; |
| for (i = 0; i < 16; i++) |
| NodeName[i] = |
| readb(&host->cfgtable->ServerName[i]); |
| if (copy_to_user(argp, NodeName, sizeof(NodeName_type))) |
| return -EFAULT; |
| return 0; |
| } |
| case CCISS_SETNODENAME: |
| { |
| NodeName_type NodeName; |
| unsigned long flags; |
| int i; |
| |
| if (!arg) |
| return -EINVAL; |
| if (!capable(CAP_SYS_ADMIN)) |
| return -EPERM; |
| |
| if (copy_from_user |
| (NodeName, argp, sizeof(NodeName_type))) |
| return -EFAULT; |
| |
| spin_lock_irqsave(CCISS_LOCK(ctlr), flags); |
| |
| /* Update the field, and then ring the doorbell */ |
| for (i = 0; i < 16; i++) |
| writeb(NodeName[i], |
| &host->cfgtable->ServerName[i]); |
| |
| writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL); |
| |
| for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) { |
| if (!(readl(host->vaddr + SA5_DOORBELL) |
| & CFGTBL_ChangeReq)) |
| break; |
| /* delay and try again */ |
| udelay(1000); |
| } |
| spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); |
| if (i >= MAX_IOCTL_CONFIG_WAIT) |
| return -EAGAIN; |
| return 0; |
| } |
| |
| case CCISS_GETHEARTBEAT: |
| { |
| Heartbeat_type heartbeat; |
| |
| if (!arg) |
| return -EINVAL; |
| heartbeat = readl(&host->cfgtable->HeartBeat); |
| if (copy_to_user |
| (argp, &heartbeat, sizeof(Heartbeat_type))) |
| return -EFAULT; |
| return 0; |
| } |
| case CCISS_GETBUSTYPES: |
| { |
| BusTypes_type BusTypes; |
| |
| if (!arg) |
| return -EINVAL; |
| BusTypes = readl(&host->cfgtable->BusTypes); |
| if (copy_to_user |
| (argp, &BusTypes, sizeof(BusTypes_type))) |
| return -EFAULT; |
| return 0; |
| } |
| case CCISS_GETFIRMVER: |
| { |
| FirmwareVer_type firmware; |
| |
| if (!arg) |
| return -EINVAL; |
| memcpy(firmware, host->firm_ver, 4); |
| |
| if (copy_to_user |
| (argp, firmware, sizeof(FirmwareVer_type))) |
| return -EFAULT; |
| return 0; |
| } |
| case CCISS_GETDRIVVER: |
| { |
| DriverVer_type DriverVer = DRIVER_VERSION; |
| |
| if (!arg) |
| return -EINVAL; |
| |
| if (copy_to_user |
| (argp, &DriverVer, sizeof(DriverVer_type))) |
| return -EFAULT; |
| return 0; |
| } |
| |
| case CCISS_DEREGDISK: |
| case CCISS_REGNEWD: |
| case CCISS_REVALIDVOLS: |
| return rebuild_lun_table(host, 0, 1); |
| |
| case CCISS_GETLUNINFO:{ |
| LogvolInfo_struct luninfo; |
| |
| 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; |
| } |
| case CCISS_PASSTHRU: |
| { |
| IOCTL_Command_struct iocommand; |
| CommandList_struct *c; |
| char *buff = NULL; |
| u64bit temp64; |
| unsigned long flags; |
| DECLARE_COMPLETION_ONSTACK(wait); |
| |
| if (!arg) |
| 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 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */ |
| /* Check kmalloc limits */ |
| if (iocommand.buf_size > 128000) |
| return -EINVAL; |
| #endif |
| 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); |
| } |
| if ((c = cmd_alloc(host, 0)) == NULL) { |
| 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(host->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; |
| |
| /* Put the request on the tail of the request queue */ |
| spin_lock_irqsave(CCISS_LOCK(ctlr), flags); |
| addQ(&host->reqQ, c); |
| host->Qdepth++; |
| start_io(host); |
| spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); |
| |
| 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(host->pdev, (dma_addr_t) temp64.val, |
| iocommand.buf_size, |
| PCI_DMA_BIDIRECTIONAL); |
| |
| check_ioctl_unit_attention(host, 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_free(host, c, 0); |
| 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_free(host, c, 0); |
| return -EFAULT; |
| } |
| } |
| kfree(buff); |
| cmd_free(host, c, 0); |
| return 0; |
| } |
| case CCISS_BIG_PASSTHRU:{ |
| BIG_IOCTL_Command_struct *ioc; |
| CommandList_struct *c; |
| unsigned char **buff = NULL; |
| int *buff_size = NULL; |
| u64bit temp64; |
| unsigned long flags; |
| BYTE sg_used = 0; |
| int status = 0; |
| int i; |
| DECLARE_COMPLETION_ONSTACK(wait); |
| __u32 left; |
| __u32 sz; |
| BYTE __user *data_ptr; |
| |
| if (!arg) |
| return -EINVAL; |
| if (!capable(CAP_SYS_RAWIO)) |
| return -EPERM; |
| ioc = (BIG_IOCTL_Command_struct *) |
| 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++; |
| } |
| if ((c = cmd_alloc(host, 0)) == NULL) { |
| status = -ENOMEM; |
| goto cleanup1; |
| } |
| c->cmd_type = CMD_IOCTL_PEND; |
| c->Header.ReplyQueue = 0; |
| |
| if (ioc->buf_size > 0) { |
| c->Header.SGList = sg_used; |
| c->Header.SGTotal = sg_used; |
| } else { |
| c->Header.SGList = 0; |
| c->Header.SGTotal = 0; |
| } |
| c->Header.LUN = ioc->LUN_info; |
| c->Header.Tag.lower = c->busaddr; |
| |
| c->Request = ioc->Request; |
| if (ioc->buf_size > 0) { |
| for (i = 0; i < sg_used; i++) { |
| temp64.val = |
| pci_map_single(host->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; |
| /* Put the request on the tail of the request queue */ |
| spin_lock_irqsave(CCISS_LOCK(ctlr), flags); |
| addQ(&host->reqQ, c); |
| host->Qdepth++; |
| start_io(host); |
| spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); |
| 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(host->pdev, |
| (dma_addr_t) temp64.val, buff_size[i], |
| PCI_DMA_BIDIRECTIONAL); |
| } |
| check_ioctl_unit_attention(host, c); |
| /* Copy the error information out */ |
| ioc->error_info = *(c->err_info); |
| if (copy_to_user(argp, ioc, sizeof(*ioc))) { |
| cmd_free(host, c, 0); |
| 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_free(host, c, 0); |
| status = -EFAULT; |
| goto cleanup1; |
| } |
| ptr += buff_size[i]; |
| } |
| } |
| cmd_free(host, c, 0); |
| status = 0; |
| cleanup1: |
| if (buff) { |
| for (i = 0; i < sg_used; i++) |
| kfree(buff[i]); |
| kfree(buff); |
| } |
| kfree(buff_size); |
| kfree(ioc); |
| return status; |
| } |
| |
| /* scsi_cmd_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_ioctl(disk->queue, disk, mode, cmd, argp); |
| |
| /* scsi_cmd_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 *cmd = rq->completion_data; |
| ctlr_info_t *h = hba[cmd->ctlr]; |
| SGDescriptor_struct *curr_sg = cmd->SG; |
| unsigned long flags; |
| u64bit temp64; |
| int i, ddir; |
| int sg_index = 0; |
| |
| if (cmd->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 < cmd->Header.SGList; i++) { |
| if (curr_sg[sg_index].Ext == CCISS_SG_CHAIN) { |
| cciss_unmap_sg_chain_block(h, cmd); |
| /* Point to the next block */ |
| curr_sg = h->cmd_sg_list[cmd->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; |
| } |
| |
| #ifdef CCISS_DEBUG |
| printk("Done with %p\n", rq); |
| #endif /* CCISS_DEBUG */ |
| |
| /* set the residual count for pc requests */ |
| if (blk_pc_request(rq)) |
| rq->resid_len = cmd->err_info->ResidualCnt; |
| |
| blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO); |
| |
| spin_lock_irqsave(&h->lock, flags); |
| cmd_free(h, cmd, 1); |
| 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(int ctlr, 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(hba[ctlr], scsi3addr, logvol); |
| rc = sendcmd_withirq(CISS_INQUIRY, ctlr, 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(int ctlr, 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(hba[ctlr], scsi3addr, logvol); |
| rc = sendcmd_withirq(CISS_INQUIRY, ctlr, 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(int ctlr, int drv_index, int first_time, |
| int via_ioctl) |
| { |
| ctlr_info_t *h = hba[ctlr]; |
| struct gendisk *disk; |
| InquiryData_struct *inq_buff = NULL; |
| unsigned int block_size; |
| sector_t total_size; |
| unsigned long flags = 0; |
| int ret = 0; |
| drive_info_struct *drvinfo; |
| |
| /* Get information about the disk and modify the driver structure */ |
| inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); |
| drvinfo = kzalloc(sizeof(*drvinfo), GFP_KERNEL); |
| if (inq_buff == NULL || drvinfo == NULL) |
| goto mem_msg; |
| |
| /* testing to see if 16-byte CDBs are already being used */ |
| if (h->cciss_read == CCISS_READ_16) { |
| cciss_read_capacity_16(h->ctlr, drv_index, |
| &total_size, &block_size); |
| |
| } else { |
| cciss_read_capacity(ctlr, drv_index, &total_size, &block_size); |
| /* if read_capacity returns all F's this volume is >2TB */ |
| /* in size so we switch to 16-byte CDB's for all */ |
| /* read/write ops */ |
| if (total_size == 0xFFFFFFFFULL) { |
| cciss_read_capacity_16(ctlr, drv_index, |
| &total_size, &block_size); |
| h->cciss_read = CCISS_READ_16; |
| h->cciss_write = CCISS_WRITE_16; |
| } else { |
| h->cciss_read = CCISS_READ_10; |
| h->cciss_write = CCISS_WRITE_10; |
| } |
| } |
| |
| cciss_geometry_inquiry(ctlr, drv_index, total_size, block_size, |
| inq_buff, drvinfo); |
| drvinfo->block_size = block_size; |
| drvinfo->nr_blocks = total_size + 1; |
| |
| cciss_get_device_descr(ctlr, drv_index, drvinfo->vendor, |
| drvinfo->model, drvinfo->rev); |
| cciss_get_serial_no(ctlr, drv_index, drvinfo->serial_no, |
| sizeof(drvinfo->serial_no)); |
| /* Save the lunid in case we deregister the disk, below. */ |
| memcpy(drvinfo->LunID, h->drv[drv_index]->LunID, |
| sizeof(drvinfo->LunID)); |
| |
| /* Is it the same disk we already know, and nothing's changed? */ |
| if (h->drv[drv_index]->raid_level != -1 && |
| ((memcmp(drvinfo->serial_no, |
| h->drv[drv_index]->serial_no, 16) == 0) && |
| drvinfo->block_size == h->drv[drv_index]->block_size && |
| drvinfo->nr_blocks == h->drv[drv_index]->nr_blocks && |
| drvinfo->heads == h->drv[drv_index]->heads && |
| drvinfo->sectors == h->drv[drv_index]->sectors && |
| drvinfo->cylinders == h->drv[drv_index]->cylinders)) |
| /* The disk is unchanged, nothing to update */ |
| goto freeret; |
| |
| /* If we get here it's not the same disk, or something's changed, |
| * so we need to * deregister it, and re-register it, if it's not |
| * in use. |
| * If the disk already exists then deregister it before proceeding |
| * (unless it's the first disk (for the controller node). |
| */ |
| if (h->drv[drv_index]->raid_level != -1 && drv_index != 0) { |
| printk(KERN_WARNING "disk %d has changed.\n", drv_index); |
| spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); |
| h->drv[drv_index]->busy_configuring = 1; |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| |
| /* deregister_disk sets h->drv[drv_index]->queue = NULL |
| * which keeps the interrupt handler from starting |
| * the queue. |
| */ |
| ret = deregister_disk(h, drv_index, 0, via_ioctl); |
| } |
| |
| /* If the disk is in use return */ |
| if (ret) |
| goto freeret; |
| |
| /* Save the new information from cciss_geometry_inquiry |
| * and serial number inquiry. If the disk was deregistered |
| * above, then h->drv[drv_index] will be NULL. |
| */ |
| if (h->drv[drv_index] == NULL) { |
| drvinfo->device_initialized = 0; |
| h->drv[drv_index] = drvinfo; |
| drvinfo = NULL; /* so it won't be freed below. */ |
| } else { |
| /* special case for cxd0 */ |
| h->drv[drv_index]->block_size = drvinfo->block_size; |
| h->drv[drv_index]->nr_blocks = drvinfo->nr_blocks; |
| h->drv[drv_index]->heads = drvinfo->heads; |
| h->drv[drv_index]->sectors = drvinfo->sectors; |
| h->drv[drv_index]->cylinders = drvinfo->cylinders; |
| h->drv[drv_index]->raid_level = drvinfo->raid_level; |
| memcpy(h->drv[drv_index]->serial_no, drvinfo->serial_no, 16); |
| memcpy(h->drv[drv_index]->vendor, drvinfo->vendor, |
| VENDOR_LEN + 1); |
| memcpy(h->drv[drv_index]->model, drvinfo->model, MODEL_LEN + 1); |
| memcpy(h->drv[drv_index]->rev, drvinfo->rev, REV_LEN + 1); |
| } |
| |
| ++h->num_luns; |
| disk = h->gendisk[drv_index]; |
| set_capacity(disk, h->drv[drv_index]->nr_blocks); |
| |
| /* If it's not disk 0 (drv_index != 0) |
| * or if it was disk 0, but there was previously |
| * no actual corresponding configured logical drive |
| * (raid_leve == -1) then we want to update the |
| * logical drive's information. |
| */ |
| if (drv_index || first_time) { |
| if (cciss_add_disk(h, disk, drv_index) != 0) { |
| cciss_free_gendisk(h, drv_index); |
| cciss_free_drive_info(h, drv_index); |
| printk(KERN_WARNING "cciss:%d could not update " |
| "disk %d\n", h->ctlr, drv_index); |
| --h->num_luns; |
| } |
| } |
| |
| freeret: |
| kfree(inq_buff); |
| kfree(drvinfo); |
| return; |
| mem_msg: |
| printk(KERN_ERR "cciss: out of memory\n"); |
| goto freeret; |
| } |
| |
| /* This function will find the first index of the controllers drive array |
| * that has a null drv pointer and allocate the drive info struct and |
| * will return that index This is where new drives will be added. |
| * If the index to be returned is greater than the highest_lun index for |
| * the controller then highest_lun is set * to this new index. |
| * If there are no available indexes or if tha allocation fails, then -1 |
| * is returned. * "controller_node" is used to know if this is a real |
| * logical drive, or just the controller node, which determines if this |
| * counts towards highest_lun. |
| */ |
| static int cciss_alloc_drive_info(ctlr_info_t *h, int controller_node) |
| { |
| int i; |
| drive_info_struct *drv; |
| |
| /* Search for an empty slot for our drive info */ |
| for (i = 0; i < CISS_MAX_LUN; i++) { |
| |
| /* if not cxd0 case, and it's occupied, skip it. */ |
| if (h->drv[i] && i != 0) |
| continue; |
| /* |
| * If it's cxd0 case, and drv is alloc'ed already, and a |
| * disk is configured there, skip it. |
| */ |
| if (i == 0 && h->drv[i] && h->drv[i]->raid_level != -1) |
| continue; |
| |
| /* |
| * We've found an empty slot. Update highest_lun |
| * provided this isn't just the fake cxd0 controller node. |
| */ |
| if (i > h->highest_lun && !controller_node) |
| h->highest_lun = i; |
| |
| /* If adding a real disk at cxd0, and it's already alloc'ed */ |
| if (i == 0 && h->drv[i] != NULL) |
| return i; |
| |
| /* |
| * Found an empty slot, not already alloc'ed. Allocate it. |
| * Mark it with raid_level == -1, so we know it's new later on. |
| */ |
| drv = kzalloc(sizeof(*drv), GFP_KERNEL); |
| if (!drv) |
| return -1; |
| drv->raid_level = -1; /* so we know it's new */ |
| h->drv[i] = drv; |
| return i; |
| } |
| return -1; |
| } |
| |
| static void cciss_free_drive_info(ctlr_info_t *h, int drv_index) |
| { |
| kfree(h->drv[drv_index]); |
| h->drv[drv_index] = NULL; |
| } |
| |
| static void cciss_free_gendisk(ctlr_info_t *h, int drv_index) |
| { |
| put_disk(h->gendisk[drv_index]); |
| h->gendisk[drv_index] = NULL; |
| } |
| |
| /* cciss_add_gendisk finds a free hba[]->drv structure |
| * and allocates a gendisk if needed, and sets the lunid |
| * in the drvinfo structure. It returns the index into |
| * the ->drv[] array, or -1 if none are free. |
| * is_controller_node indicates whether highest_lun should |
| * count this disk, or if it's only being added to provide |
| * a means to talk to the controller in case no logical |
| * drives have yet been configured. |
| */ |
| static int cciss_add_gendisk(ctlr_info_t *h, unsigned char lunid[], |
| int controller_node) |
| { |
| int drv_index; |
| |
| drv_index = cciss_alloc_drive_info(h, controller_node); |
| if (drv_index == -1) |
| return -1; |
| |
| /*Check if the gendisk needs to be allocated */ |
| if (!h->gendisk[drv_index]) { |
| h->gendisk[drv_index] = |
| alloc_disk(1 << NWD_SHIFT); |
| if (!h->gendisk[drv_index]) { |
| printk(KERN_ERR "cciss%d: could not " |
| "allocate a new disk %d\n", |
| h->ctlr, drv_index); |
| goto err_free_drive_info; |
| } |
| } |
| memcpy(h->drv[drv_index]->LunID, lunid, |
| sizeof(h->drv[drv_index]->LunID)); |
| if (cciss_create_ld_sysfs_entry(h, drv_index)) |
| goto err_free_disk; |
| /* Don't need to mark this busy because nobody */ |
| /* else knows about this disk yet to contend */ |
| /* for access to it. */ |
| h->drv[drv_index]->busy_configuring = 0; |
| wmb(); |
| return drv_index; |
| |
| err_free_disk: |
| cciss_free_gendisk(h, drv_index); |
| err_free_drive_info: |
| cciss_free_drive_info(h, drv_index); |
| return -1; |
| } |
| |
| /* This is for the special case of a controller which |
| * has no logical drives. In this case, we still need |
| * to register a disk so the controller can be accessed |
| * by the Array Config Utility. |
| */ |
| static void cciss_add_controller_node(ctlr_info_t *h) |
| { |
| struct gendisk *disk; |
| int drv_index; |
| |
| if (h->gendisk[0] != NULL) /* already did this? Then bail. */ |
| return; |
| |
| drv_index = cciss_add_gendisk(h, CTLR_LUNID, 1); |
| if (drv_index == -1) |
| goto error; |
| h->drv[drv_index]->block_size = 512; |
| h->drv[drv_index]->nr_blocks = 0; |
| h->drv[drv_index]->heads = 0; |
| h->drv[drv_index]->sectors = 0; |
| h->drv[drv_index]->cylinders = 0; |
| h->drv[drv_index]->raid_level = -1; |
| memset(h->drv[drv_index]->serial_no, 0, 16); |
| disk = h->gendisk[drv_index]; |
| if (cciss_add_disk(h, disk, drv_index) == 0) |
| return; |
| cciss_free_gendisk(h, drv_index); |
| cciss_free_drive_info(h, drv_index); |
| error: |
| printk(KERN_WARNING "cciss%d: could not " |
| "add disk 0.\n", h->ctlr); |
| return; |
| } |
| |
| /* This function will add and remove logical drives from the Logical |
| * drive array of the controller and maintain persistency of ordering |
| * so that mount points are preserved until the next reboot. This allows |
| * for the removal of logical drives in the middle of the drive array |
| * without a re-ordering of those drives. |
| * INPUT |
| * h = The controller to perform the operations on |
| */ |
| static int rebuild_lun_table(ctlr_info_t *h, int first_time, |
| int via_ioctl) |
| { |
| int ctlr = h->ctlr; |
| int num_luns; |
| ReportLunData_struct *ld_buff = NULL; |
| int return_code; |
| int listlength = 0; |
| int i; |
| int drv_found; |
| int drv_index = 0; |
| unsigned char lunid[8] = CTLR_LUNID; |
| unsigned long flags; |
| |
| if (!capable(CAP_SYS_RAWIO)) |
| return -EPERM; |
| |
| /* Set busy_configuring flag for this operation */ |
| spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); |
| if (h->busy_configuring) { |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return -EBUSY; |
| } |
| h->busy_configuring = 1; |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| |
| ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL); |
| if (ld_buff == NULL) |
| goto mem_msg; |
| |
| return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff, |
| sizeof(ReportLunData_struct), |
| 0, CTLR_LUNID, TYPE_CMD); |
| |
| if (return_code == IO_OK) |
| listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength); |
| else { /* reading number of logical volumes failed */ |
| printk(KERN_WARNING "cciss: report logical volume" |
| " command failed\n"); |
| listlength = 0; |
| goto freeret; |
| } |
| |
| num_luns = listlength / 8; /* 8 bytes per entry */ |
| if (num_luns > CISS_MAX_LUN) { |
| num_luns = CISS_MAX_LUN; |
| printk(KERN_WARNING "cciss: more luns configured" |
| " on controller than can be handled by" |
| " this driver.\n"); |
| } |
| |
| if (num_luns == 0) |
| cciss_add_controller_node(h); |
| |
| /* Compare controller drive array to driver's drive array |
| * to see if any drives are missing on the controller due |
| * to action of Array Config Utility (user deletes drive) |
| * and deregister logical drives which have disappeared. |
| */ |
| for (i = 0; i <= h->highest_lun; i++) { |
| int j; |
| drv_found = 0; |
| |
| /* skip holes in the array from already deleted drives */ |
| if (h->drv[i] == NULL) |
| continue; |
| |
| for (j = 0; j < num_luns; j++) { |
| memcpy(lunid, &ld_buff->LUN[j][0], sizeof(lunid)); |
| if (memcmp(h->drv[i]->LunID, lunid, |
| sizeof(lunid)) == 0) { |
| drv_found = 1; |
| break; |
| } |
| } |
| if (!drv_found) { |
| /* Deregister it from the OS, it's gone. */ |
| spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); |
| h->drv[i]->busy_configuring = 1; |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| return_code = deregister_disk(h, i, 1, via_ioctl); |
| if (h->drv[i] != NULL) |
| h->drv[i]->busy_configuring = 0; |
| } |
| } |
| |
| /* Compare controller drive array to driver's drive array. |
| * Check for updates in the drive information and any new drives |
| * on the controller due to ACU adding logical drives, or changing |
| * a logical drive's size, etc. Reregister any new/changed drives |
| */ |
| for (i = 0; i < num_luns; i++) { |
| int j; |
| |
| drv_found = 0; |
| |
| memcpy(lunid, &ld_buff->LUN[i][0], sizeof(lunid)); |
| /* Find if the LUN is already in the drive array |
| * of the driver. If so then update its info |
| * if not in use. If it does not exist then find |
| * the first free index and add it. |
| */ |
| for (j = 0; j <= h->highest_lun; j++) { |
| if (h->drv[j] != NULL && |
| memcmp(h->drv[j]->LunID, lunid, |
| sizeof(h->drv[j]->LunID)) == 0) { |
| drv_index = j; |
| drv_found = 1; |
| break; |
| } |
| } |
| |
| /* check if the drive was found already in the array */ |
| if (!drv_found) { |
| drv_index = cciss_add_gendisk(h, lunid, 0); |
| if (drv_index == -1) |
| goto freeret; |
| } |
| cciss_update_drive_info(ctlr, drv_index, first_time, |
| via_ioctl); |
| } /* end for */ |
| |
| freeret: |
| kfree(ld_buff); |
| h->busy_configuring = 0; |
| /* We return -1 here to tell the ACU that we have registered/updated |
| * all of the drives that we can and to keep it from calling us |
| * additional times. |
| */ |
| return -1; |
| mem_msg: |
| printk(KERN_ERR "cciss: out of memory\n"); |
| h->busy_configuring = 0; |
| goto freeret; |
| } |
| |
| static void cciss_clear_drive_info(drive_info_struct *drive_info) |
| { |
| /* zero out the disk size info */ |
| drive_info->nr_blocks = 0; |
| drive_info->block_size = 0; |
| drive_info->heads = 0; |
| drive_info->sectors = 0; |
| drive_info->cylinders = 0; |
| drive_info->raid_level = -1; |
| memset(drive_info->serial_no, 0, sizeof(drive_info->serial_no)); |
| memset(drive_info->model, 0, sizeof(drive_info->model)); |
| memset(drive_info->rev, 0, sizeof(drive_info->rev)); |
| memset(drive_info->vendor, 0, sizeof(drive_info->vendor)); |
| /* |
| * don't clear the LUNID though, we need to remember which |
| * one this one is. |
| */ |
| } |
| |
| /* This function will deregister the disk and it's queue from the |
| * kernel. It must be called with the controller lock held and the |
| * drv structures busy_configuring flag set. It's parameters are: |
| * |
| * disk = This is the disk to be deregistered |
| * drv = This is the drive_info_struct associated with the disk to be |
| * deregistered. It contains information about the disk used |
| * by the driver. |
| * clear_all = This flag determines whether or not the disk information |
| * is going to be completely cleared out and the highest_lun |
| * reset. Sometimes we want to clear out information about |
| * the disk in preparation for re-adding it. In this case |
| * the highest_lun should be left unchanged and the LunID |
| * should not be cleared. |
| * via_ioctl |
| * This indicates whether we've reached this path via ioctl. |
| * This affects the maximum usage count allowed for c0d0 to be messed with. |
| * If this path is reached via ioctl(), then the max_usage_count will |
| * be 1, as the process calling ioctl() has got to have the device open. |
| * If we get here via sysfs, then the max usage count will be zero. |
| */ |
| static int deregister_disk(ctlr_info_t *h, int drv_index, |
| int clear_all, int via_ioctl) |
| { |
| int i; |
| struct gendisk *disk; |
| drive_info_struct *drv; |
| int recalculate_highest_lun; |
| |
| if (!capable(CAP_SYS_RAWIO)) |
| return -EPERM; |
| |
| drv = h->drv[drv_index]; |
| disk = h->gendisk[drv_index]; |
| |
| /* make sure logical volume is NOT is use */ |
| if (clear_all || (h->gendisk[0] == disk)) { |
| if (drv->usage_count > via_ioctl) |
| return -EBUSY; |
| } else if (drv->usage_count > 0) |
| return -EBUSY; |
| |
| recalculate_highest_lun = (drv == h->drv[h->highest_lun]); |
| |
| /* invalidate the devices and deregister the disk. If it is disk |
| * zero do not deregister it but just zero out it's values. This |
| * allows us to delete disk zero but keep the controller registered. |
| */ |
| if (h->gendisk[0] != disk) { |
| struct request_queue *q = disk->queue; |
| if (disk->flags & GENHD_FL_UP) { |
| cciss_destroy_ld_sysfs_entry(h, drv_index, 0); |
| del_gendisk(disk); |
| } |
| if (q) |
| blk_cleanup_queue(q); |
| /* If clear_all is set then we are deleting the logical |
| * drive, not just refreshing its info. For drives |
| * other than disk 0 we will call put_disk. We do not |
| * do this for disk 0 as we need it to be able to |
| * configure the controller. |
| */ |
| if (clear_all){ |
| /* This isn't pretty, but we need to find the |
| * disk in our array and NULL our the pointer. |
| * This is so that we will call alloc_disk if |
| * this index is used again later. |
| */ |
| for (i=0; i < CISS_MAX_LUN; i++){ |
| if (h->gendisk[i] == disk) { |
| h->gendisk[i] = NULL; |
| break; |
| } |
| } |
| put_disk(disk); |
| } |
| } else { |
| set_capacity(disk, 0); |
| cciss_clear_drive_info(drv); |
| } |
| |
| --h->num_luns; |
| |
| /* if it was the last disk, find the new hightest lun */ |
| if (clear_all && recalculate_highest_lun) { |
| int newhighest = -1; |
| for (i = 0; i <= h->highest_lun; i++) { |
| /* if the disk has size > 0, it is available */ |
| if (h->drv[i] && h->drv[i]->heads) |
| newhighest = i; |
| } |
| h->highest_lun = newhighest; |
| } |
| return 0; |
| } |
| |
| static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, |
| size_t size, __u8 page_code, unsigned char *scsi3addr, |
| int cmd_type) |
| { |
| ctlr_info_t *h = hba[ctlr]; |
| u64bit buff_dma_handle; |
| int status = IO_OK; |
| |
| c->cmd_type = CMD_IOCTL_PEND; |
| c->Header.ReplyQueue = 0; |
| if (buff != NULL) { |
| c->Header.SGList = 1; |
| c->Header.SGTotal = 1; |
| } else { |
| c->Header.SGList = 0; |
| c->Header.SGTotal = 0; |
| } |
| c->Header.Tag.lower = c->busaddr; |
| memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8); |
| |
| c->Request.Type.Type = cmd_type; |
| if (cmd_type == TYPE_CMD) { |
| switch (cmd) { |
| case CISS_INQUIRY: |
| /* are we trying to read a vital product page */ |
| if (page_code != 0) { |
| c->Request.CDB[1] = 0x01; |
| c->Request.CDB[2] = page_code; |
| } |
| c->Request.CDBLen = 6; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_READ; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = CISS_INQUIRY; |
| c->Request.CDB[4] = size & 0xFF; |
| break; |
| case CISS_REPORT_LOG: |
| case CISS_REPORT_PHYS: |
| /* Talking to controller so It's a physical command |
| mode = 00 target = 0. Nothing to write. |
| */ |
| c->Request.CDBLen = 12; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_READ; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = cmd; |
| c->Request.CDB[6] = (size >> 24) & 0xFF; /* MSB */ |
| c->Request.CDB[7] = (size >> 16) & 0xFF; |
| c->Request.CDB[8] = (size >> 8) & 0xFF; |
| c->Request.CDB[9] = size & 0xFF; |
| break; |
| |
| case CCISS_READ_CAPACITY: |
| c->Request.CDBLen = 10; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_READ; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = cmd; |
| break; |
| case CCISS_READ_CAPACITY_16: |
| c->Request.CDBLen = 16; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_READ; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = cmd; |
| c->Request.CDB[1] = 0x10; |
| c->Request.CDB[10] = (size >> 24) & 0xFF; |
| c->Request.CDB[11] = (size >> 16) & 0xFF; |
| c->Request.CDB[12] = (size >> 8) & 0xFF; |
| c->Request.CDB[13] = size & 0xFF; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = cmd; |
| break; |
| case CCISS_CACHE_FLUSH: |
| c->Request.CDBLen = 12; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_WRITE; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = BMIC_WRITE; |
| c->Request.CDB[6] = BMIC_CACHE_FLUSH; |
| break; |
| case TEST_UNIT_READY: |
| c->Request.CDBLen = 6; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_NONE; |
| c->Request.Timeout = 0; |
| break; |
| default: |
| printk(KERN_WARNING |
| "cciss%d: Unknown Command 0x%c\n", ctlr, cmd); |
| return IO_ERROR; |
| } |
| } else if (cmd_type == TYPE_MSG) { |
| switch (cmd) { |
| case 0: /* ABORT message */ |
| c->Request.CDBLen = 12; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_WRITE; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = cmd; /* abort */ |
| c->Request.CDB[1] = 0; /* abort a command */ |
| /* buff contains the tag of the command to abort */ |
| memcpy(&c->Request.CDB[4], buff, 8); |
| break; |
| case 1: /* RESET message */ |
| c->Request.CDBLen = 16; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_NONE; |
| c->Request.Timeout = 0; |
| memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB)); |
| c->Request.CDB[0] = cmd; /* reset */ |
| c->Request.CDB[1] = 0x03; /* reset a target */ |
| break; |
| case 3: /* No-Op message */ |
| c->Request.CDBLen = 1; |
| c->Request.Type.Attribute = ATTR_SIMPLE; |
| c->Request.Type.Direction = XFER_WRITE; |
| c->Request.Timeout = 0; |
| c->Request.CDB[0] = cmd; |
| break; |
| default: |
| printk(KERN_WARNING |
| "cciss%d: unknown message type %d\n", ctlr, cmd); |
| return IO_ERROR; |
| } |
| } else { |
| printk(KERN_WARNING |
| "cciss%d: unknown command type %d\n", ctlr, cmd_type); |
| return IO_ERROR; |
| } |
| /* Fill in the scatter gather information */ |
| if (size > 0) { |
| buff_dma_handle.val = (__u64) pci_map_single(h->pdev, |
| buff, size, |
| PCI_DMA_BIDIRECTIONAL); |
| c->SG[0].Addr.lower = buff_dma_handle.val32.lower; |
| c->SG[0].Addr.upper = buff_dma_handle.val32.upper; |
| c->SG[0].Len = size; |
| c->SG[0].Ext = 0; /* we are not chaining */ |
| } |
| return status; |
| } |
| |
| static int check_target_status(ctlr_info_t *h, CommandList_struct *c) |
| { |
| switch (c->err_info->ScsiStatus) { |
| case SAM_STAT_GOOD: |
| return IO_OK; |
| case SAM_STAT_CHECK_CONDITION: |
| switch (0xf & c->err_info->SenseInfo[2]) { |
| case 0: return IO_OK; /* no sense */ |
| case 1: return IO_OK; /* recovered error */ |
| default: |
| if (check_for_unit_attention(h, c)) |
| return IO_NEEDS_RETRY; |
| printk(KERN_WARNING "cciss%d: cmd 0x%02x " |
| "check condition, sense key = 0x%02x\n", |
| h->ctlr, c->Request.CDB[0], |
| c->err_info->SenseInfo[2]); |
| } |
| break; |
| default: |
| printk(KERN_WARNING "cciss%d: cmd 0x%02x" |
| "scsi status = 0x%02x\n", h->ctlr, |
| c->Request.CDB[0], c->err_info->ScsiStatus); |
| break; |
| } |
| return IO_ERROR; |
| } |
| |
| static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c) |
| { |
| int return_status = IO_OK; |
| |
| if (c->err_info->CommandStatus == CMD_SUCCESS) |
| return IO_OK; |
| |
| switch (c->err_info->CommandStatus) { |
| case CMD_TARGET_STATUS: |
| return_status = check_target_status(h, c); |
| break; |
| case CMD_DATA_UNDERRUN: |
| case CMD_DATA_OVERRUN: |
| /* expected for inquiry and report lun commands */ |
| break; |
| case CMD_INVALID: |
| printk(KERN_WARNING "cciss: cmd 0x%02x is " |
| "reported invalid\n", c->Request.CDB[0]); |
| return_status = IO_ERROR; |
| break; |
| case CMD_PROTOCOL_ERR: |
| printk(KERN_WARNING "cciss: cmd 0x%02x has " |
| "protocol error \n", c->Request.CDB[0]); |
| return_status = IO_ERROR; |
| break; |
| case CMD_HARDWARE_ERR: |
| printk(KERN_WARNING "cciss: cmd 0x%02x had " |
| " hardware error\n", c->Request.CDB[0]); |
| return_status = IO_ERROR; |
| break; |
| case CMD_CONNECTION_LOST: |
| printk(KERN_WARNING "cciss: cmd 0x%02x had " |
| "connection lost\n", c->Request.CDB[0]); |
| return_status = IO_ERROR; |
| break; |
| case CMD_ABORTED: |
| printk(KERN_WARNING "cciss: cmd 0x%02x was " |
| "aborted\n", c->Request.CDB[0]); |
| return_status = IO_ERROR; |
| break; |
| case CMD_ABORT_FAILED: |
| printk(KERN_WARNING "cciss: cmd 0x%02x reports " |
| "abort failed\n", c->Request.CDB[0]); |
| return_status = IO_ERROR; |
| break; |
| case CMD_UNSOLICITED_ABORT: |
| printk(KERN_WARNING |
| "cciss%d: unsolicited abort 0x%02x\n", h->ctlr, |
| c->Request.CDB[0]); |
| return_status = IO_NEEDS_RETRY; |
| break; |
| default: |
| printk(KERN_WARNING "cciss: cmd 0x%02x returned " |
| "unknown status %x\n", c->Request.CDB[0], |
| c->err_info->CommandStatus); |
| return_status = IO_ERROR; |
| } |
| return return_status; |
| } |
| |
| static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c, |
| int attempt_retry) |
| { |
| DECLARE_COMPLETION_ONSTACK(wait); |
| u64bit buff_dma_handle; |
| unsigned long flags; |
| int return_status = IO_OK; |
| |
| resend_cmd2: |
| c->waiting = &wait; |
| /* Put the request on the tail of the queue and send it */ |
| spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); |
| addQ(&h->reqQ, c); |
| h->Qdepth++; |
| start_io(h); |
| spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
| |
| wait_for_completion(&wait); |
| |
| if (c->err_info->CommandStatus == 0 || !attempt_retry) |
| goto command_done; |
| |
| return_status = process_sendcmd_error(h, c); |
| |
| if (return_status == IO_NEEDS_RETRY && |
| c->retry_count < MAX_CMD_RETRIES) { |
| printk(KERN_WARNING "cciss%d: retrying 0x%02x\n", h->ctlr, |
| c->Request.CDB[0]); |
| c->retry_count++; |
| /* erase the old error information */ |
| memset(c->err_info, 0, sizeof(ErrorInfo_struct)); |
| return_status = IO_OK; |
| INIT_COMPLETION(wait); |
| goto resend_cmd2; |
| } |
| |
| command_done: |
| /* unlock the buffers from DMA */ |
| buff_dma_handle.val32.lower = c->SG[0].Addr.lower; |
| buff_dma_handle.val32.upper = c->SG[0].Addr.upper; |
| pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val, |
| c->SG[0].Len, PCI_DMA_BIDIRECTIONAL); |
| return return_status; |
| } |
| |
| static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size, |
| __u8 page_code, unsigned char scsi3addr[], |
| int cmd_type) |
| { |
| ctlr_info_t *h = hba[ctlr]; |
| CommandList_struct *c; |
| int return_status; |
| |
| c = cmd_alloc(h, 0); |
| if (!c) |
| return -ENOMEM; |
| return_status = fill_cmd(c, cmd, ctlr, buff, size, page_code, |
| scsi3addr, cmd_type); |
| if (return_status == IO_OK) |
| return_status = sendcmd_withirq_core(h, c, 1); |
| |
| cmd_free(h, c, 0); |
| return return_status; |
| } |
| |
| static void cciss_geometry_inquiry(int ctlr, int logvol, |
| sector_t total_size, |
| unsigned int block_size, |
| InquiryData_struct *inq_buff, |
| drive_info_struct *drv) |
| { |
| int return_code; |
| unsigned long t; |
| unsigned char scsi3addr[8]; |
| |
| memset(inq_buff, 0, sizeof(InquiryData_struct)); |
| log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); |
| return_code = sendcmd_withirq(CISS_INQUIRY, ctlr, inq_buff, |
| sizeof(*inq_buff), 0xC1, scsi3addr, TYPE_CMD); |
| if (return_code == IO_OK) { |
| if (inq_buff->data_byte[8] == 0xFF) { |
| printk(KERN_WARNING |
| "cciss: reading geometry failed, volume " |
| "does not support reading geometry\n"); |
| drv->heads = 255; |
| drv->sectors = 32; /* Sectors per track */ |
| drv->cylinders = total_size + 1; |
| drv->raid_level = RAID_UNKNOWN; |
| } else { |
| drv->heads = inq_buff->data_byte[6]; |
| drv->sectors = inq_buff->data_byte[7]; |
| drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8; |
| drv->cylinders += inq_buff->data_byte[5]; |
| drv->raid_level = inq_buff->data_byte[8]; |
| } |
| drv->block_size = block_size; |
| drv->nr_blocks = total_size + 1; |
| t = drv->heads * drv->sectors; |
| if (t > 1) { |
| sector_t real_size = total_size + 1; |
| unsigned long rem = sector_div(real_size, t); |
| if (rem) |
| real_size++; |
| drv->cylinders = real_size; |
| } |
| } else { /* Get geometry failed */ |
| printk(KERN_WARNING "cciss: reading geometry failed\n"); |
| } |
| } |
| |
| static void |
| cciss_read_capacity(int ctlr, int logvol, sector_t *total_size, |
| unsigned int *block_size) |
| { |
| ReadCapdata_struct *buf; |
| int return_code; |
| unsigned char scsi3addr[8]; |
| |
| buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL); |
| if (!buf) { |
| printk(KERN_WARNING "cciss: out of memory\n"); |
| return; |
| } |
| |
| log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); |
| return_code = sendcmd_withirq(CCISS_READ_CAPACITY, ctlr, buf, |
| sizeof(ReadCapdata_struct), 0, scsi3addr, TYPE_CMD); |
| if (return_code == IO_OK) { |
| *total_size = be32_to_cpu(*(__be32 *) buf->total_size); |
| *block_size = be32_to_cpu(*(__be32 *) buf->block_size); |
| } else { /* read capacity command failed */ |
| printk(KERN_WARNING "cciss: read capacity failed\n"); |
| *total_size = 0; |
| *block_size = BLOCK_SIZE; |
| } |
| kfree(buf); |
| } |
| |
| static void cciss_read_capacity_16(int ctlr, int logvol, |
| sector_t *total_size, unsigned int *block_size) |
| { |
| ReadCapdata_struct_16 *buf; |
| int return_code; |
| unsigned char scsi3addr[8]; |
| |
| buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL); |
| if (!buf) { |
| printk(KERN_WARNING "cciss: out of memory\n"); |
| return; |
| } |
| |
| log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol); |
| return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16, |
| ctlr, buf, sizeof(ReadCapdata_struct_16), |
| 0, scsi3addr, TYPE_CMD); |
| if (return_code == IO_OK) { |
| *total_size = be64_to_cpu(*(__be64 *) buf->total_size); |
| *block_size = be32_to_cpu(*(__be32 *) buf->block_size); |
| } else { /* read capacity command failed */ |
| printk(KERN_WARNING "cciss: read capacity failed\n"); |
| *total_size = 0; |
| *block_size = BLOCK_SIZE; |
| } |
| printk(KERN_INFO " blocks= %llu block_size= %d\n", |
| (unsigned long long)*total_size+1, *block_size); |
| kfree(buf); |
| } |
| |
| static int cciss_revalidate(struct gendisk *disk) |
| { |
| ctlr_info_t *h = get_host(disk); |
| drive_info_struct *drv = get_drv(disk); |
| int logvol; |
| int FOUND = 0; |
| unsigned int block_size; |
| sector_t total_size; |
| InquiryData_struct *inq_buff = NULL; |
| |
| for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) { |
| if (memcmp(h->drv[logvol]->LunID, drv->LunID, |
| sizeof(drv->LunID)) == 0) { |
| FOUND = 1; |
| break; |
| } |
| } |
| |
| if (!FOUND) |
| return 1; |
| |
| inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); |
| if (inq_buff == NULL) { |
| printk(KERN_WARNING "cciss: out of memory\n"); |
| return 1; |
| } |
| if (h->cciss_read == CCISS_READ_10) { |
| cciss_read_capacity(h->ctlr, logvol, |
| &total_size, &block_size); |
| } else { |
| cciss_read_capacity_16(h->ctlr, logvol, |
| &total_size, &block_size); |
| } |
| cciss_geometry_inquiry(h->ctlr, logvol, total_size, block_size, |
| inq_buff, drv); |
| |
| blk_queue_logical_block_size(drv->queue, drv->block_size); |
| set_capacity(disk, drv->nr_blocks); |
| |
| kfree(inq_buff); |
| return 0; |
| } |
| |
|