2 * Disk Array driver for HP Smart Array controllers.
3 * (C) Copyright 2000, 2007 Hewlett-Packard Development Company, L.P.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
23 #include <linux/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/types.h>
26 #include <linux/pci.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/delay.h>
30 #include <linux/major.h>
32 #include <linux/bio.h>
33 #include <linux/blkpg.h>
34 #include <linux/timer.h>
35 #include <linux/proc_fs.h>
36 #include <linux/seq_file.h>
37 #include <linux/init.h>
38 #include <linux/hdreg.h>
39 #include <linux/spinlock.h>
40 #include <linux/compat.h>
41 #include <linux/blktrace_api.h>
42 #include <asm/uaccess.h>
45 #include <linux/dma-mapping.h>
46 #include <linux/blkdev.h>
47 #include <linux/genhd.h>
48 #include <linux/completion.h>
49 #include <scsi/scsi.h>
51 #include <scsi/scsi_ioctl.h>
52 #include <linux/cdrom.h>
53 #include <linux/scatterlist.h>
55 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
56 #define DRIVER_NAME "HP CISS Driver (v 3.6.20)"
57 #define DRIVER_VERSION CCISS_DRIVER_VERSION(3, 6, 20)
59 /* Embedded module documentation macros - see modules.h */
60 MODULE_AUTHOR("Hewlett-Packard Company");
61 MODULE_DESCRIPTION("Driver for HP Smart Array Controllers");
62 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
63 " SA6i P600 P800 P400 P400i E200 E200i E500 P700m"
64 " Smart Array G2 Series SAS/SATA Controllers");
65 MODULE_VERSION("3.6.20");
66 MODULE_LICENSE("GPL");
68 #include "cciss_cmd.h"
70 #include <linux/cciss_ioctl.h>
72 /* define the PCI info for the cards we can control */
73 static const struct pci_device_id cciss_pci_device_id[] = {
74 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS, 0x0E11, 0x4070},
75 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
76 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
77 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
78 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
79 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
80 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
81 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
82 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
83 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA, 0x103C, 0x3225},
84 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3223},
85 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3234},
86 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3235},
87 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3211},
88 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3212},
89 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3213},
90 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3214},
91 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3215},
92 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3237},
93 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x323D},
94 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3241},
95 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3243},
96 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3245},
97 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3247},
98 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSE, 0x103C, 0x3249},
99 {PCI_VENDOR_ID_HP, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
100 PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
104 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
106 /* board_id = Subsystem Device ID & Vendor ID
107 * product = Marketing Name for the board
108 * access = Address of the struct of function pointers
110 static struct board_type products[] = {
111 {0x40700E11, "Smart Array 5300", &SA5_access},
112 {0x40800E11, "Smart Array 5i", &SA5B_access},
113 {0x40820E11, "Smart Array 532", &SA5B_access},
114 {0x40830E11, "Smart Array 5312", &SA5B_access},
115 {0x409A0E11, "Smart Array 641", &SA5_access},
116 {0x409B0E11, "Smart Array 642", &SA5_access},
117 {0x409C0E11, "Smart Array 6400", &SA5_access},
118 {0x409D0E11, "Smart Array 6400 EM", &SA5_access},
119 {0x40910E11, "Smart Array 6i", &SA5_access},
120 {0x3225103C, "Smart Array P600", &SA5_access},
121 {0x3223103C, "Smart Array P800", &SA5_access},
122 {0x3234103C, "Smart Array P400", &SA5_access},
123 {0x3235103C, "Smart Array P400i", &SA5_access},
124 {0x3211103C, "Smart Array E200i", &SA5_access},
125 {0x3212103C, "Smart Array E200", &SA5_access},
126 {0x3213103C, "Smart Array E200i", &SA5_access},
127 {0x3214103C, "Smart Array E200i", &SA5_access},
128 {0x3215103C, "Smart Array E200i", &SA5_access},
129 {0x3237103C, "Smart Array E500", &SA5_access},
130 {0x323D103C, "Smart Array P700m", &SA5_access},
131 {0x3241103C, "Smart Array P212", &SA5_access},
132 {0x3243103C, "Smart Array P410", &SA5_access},
133 {0x3245103C, "Smart Array P410i", &SA5_access},
134 {0x3247103C, "Smart Array P411", &SA5_access},
135 {0x3249103C, "Smart Array P812", &SA5_access},
136 {0xFFFF103C, "Unknown Smart Array", &SA5_access},
139 /* How long to wait (in milliseconds) for board to go into simple mode */
140 #define MAX_CONFIG_WAIT 30000
141 #define MAX_IOCTL_CONFIG_WAIT 1000
143 /*define how many times we will try a command because of bus resets */
144 #define MAX_CMD_RETRIES 3
148 /* Originally cciss driver only supports 8 major numbers */
149 #define MAX_CTLR_ORIG 8
151 static ctlr_info_t *hba[MAX_CTLR];
153 static void do_cciss_request(struct request_queue *q);
154 static irqreturn_t do_cciss_intr(int irq, void *dev_id);
155 static int cciss_open(struct inode *inode, struct file *filep);
156 static int cciss_release(struct inode *inode, struct file *filep);
157 static int cciss_ioctl(struct inode *inode, struct file *filep,
158 unsigned int cmd, unsigned long arg);
159 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
161 static int cciss_revalidate(struct gendisk *disk);
162 static int rebuild_lun_table(ctlr_info_t *h, int first_time);
163 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
166 static void cciss_read_capacity(int ctlr, int logvol, int withirq,
167 sector_t *total_size, unsigned int *block_size);
168 static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
169 sector_t *total_size, unsigned int *block_size);
170 static void cciss_geometry_inquiry(int ctlr, int logvol,
171 int withirq, sector_t total_size,
172 unsigned int block_size, InquiryData_struct *inq_buff,
173 drive_info_struct *drv);
174 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
176 static void start_io(ctlr_info_t *h);
177 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
178 unsigned int use_unit_num, unsigned int log_unit,
179 __u8 page_code, unsigned char *scsi3addr, int cmd_type);
180 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
181 unsigned int use_unit_num, unsigned int log_unit,
182 __u8 page_code, int cmd_type);
184 static void fail_all_cmds(unsigned long ctlr);
186 #ifdef CONFIG_PROC_FS
187 static void cciss_procinit(int i);
189 static void cciss_procinit(int i)
192 #endif /* CONFIG_PROC_FS */
195 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
198 static struct block_device_operations cciss_fops = {
199 .owner = THIS_MODULE,
201 .release = cciss_release,
202 .ioctl = cciss_ioctl,
203 .getgeo = cciss_getgeo,
205 .compat_ioctl = cciss_compat_ioctl,
207 .revalidate_disk = cciss_revalidate,
211 * Enqueuing and dequeuing functions for cmdlists.
213 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
217 c->next = c->prev = c;
219 c->prev = (*Qptr)->prev;
221 (*Qptr)->prev->next = c;
226 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
227 CommandList_struct *c)
229 if (c && c->next != c) {
232 c->prev->next = c->next;
233 c->next->prev = c->prev;
240 #include "cciss_scsi.c" /* For SCSI tape support */
242 #define RAID_UNKNOWN 6
244 #ifdef CONFIG_PROC_FS
247 * Report information about this controller.
249 #define ENG_GIG 1000000000
250 #define ENG_GIG_FACTOR (ENG_GIG/512)
251 #define ENGAGE_SCSI "engage scsi"
252 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
256 static struct proc_dir_entry *proc_cciss;
258 static void cciss_seq_show_header(struct seq_file *seq)
260 ctlr_info_t *h = seq->private;
262 seq_printf(seq, "%s: HP %s Controller\n"
263 "Board ID: 0x%08lx\n"
264 "Firmware Version: %c%c%c%c\n"
266 "Logical drives: %d\n"
267 "Current Q depth: %d\n"
268 "Current # commands on controller: %d\n"
269 "Max Q depth since init: %d\n"
270 "Max # commands on controller since init: %d\n"
271 "Max SG entries since init: %d\n",
274 (unsigned long)h->board_id,
275 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
276 h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
278 h->Qdepth, h->commands_outstanding,
279 h->maxQsinceinit, h->max_outstanding, h->maxSG);
281 #ifdef CONFIG_CISS_SCSI_TAPE
282 cciss_seq_tape_report(seq, h->ctlr);
283 #endif /* CONFIG_CISS_SCSI_TAPE */
286 static void *cciss_seq_start(struct seq_file *seq, loff_t *pos)
288 ctlr_info_t *h = seq->private;
289 unsigned ctlr = h->ctlr;
292 /* prevent displaying bogus info during configuration
293 * or deconfiguration of a logical volume
295 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
296 if (h->busy_configuring) {
297 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
298 return ERR_PTR(-EBUSY);
300 h->busy_configuring = 1;
301 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
304 cciss_seq_show_header(seq);
309 static int cciss_seq_show(struct seq_file *seq, void *v)
311 sector_t vol_sz, vol_sz_frac;
312 ctlr_info_t *h = seq->private;
313 unsigned ctlr = h->ctlr;
315 drive_info_struct *drv = &h->drv[*pos];
317 if (*pos > h->highest_lun)
323 vol_sz = drv->nr_blocks;
324 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
326 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
328 if (drv->raid_level > 5)
329 drv->raid_level = RAID_UNKNOWN;
330 seq_printf(seq, "cciss/c%dd%d:"
331 "\t%4u.%02uGB\tRAID %s\n",
332 ctlr, (int) *pos, (int)vol_sz, (int)vol_sz_frac,
333 raid_label[drv->raid_level]);
337 static void *cciss_seq_next(struct seq_file *seq, void *v, loff_t *pos)
339 ctlr_info_t *h = seq->private;
341 if (*pos > h->highest_lun)
348 static void cciss_seq_stop(struct seq_file *seq, void *v)
350 ctlr_info_t *h = seq->private;
352 /* Only reset h->busy_configuring if we succeeded in setting
353 * it during cciss_seq_start. */
354 if (v == ERR_PTR(-EBUSY))
357 h->busy_configuring = 0;
360 static struct seq_operations cciss_seq_ops = {
361 .start = cciss_seq_start,
362 .show = cciss_seq_show,
363 .next = cciss_seq_next,
364 .stop = cciss_seq_stop,
367 static int cciss_seq_open(struct inode *inode, struct file *file)
369 int ret = seq_open(file, &cciss_seq_ops);
370 struct seq_file *seq = file->private_data;
373 seq->private = PDE(inode)->data;
379 cciss_proc_write(struct file *file, const char __user *buf,
380 size_t length, loff_t *ppos)
385 #ifndef CONFIG_CISS_SCSI_TAPE
389 if (!buf || length > PAGE_SIZE - 1)
392 buffer = (char *)__get_free_page(GFP_KERNEL);
397 if (copy_from_user(buffer, buf, length))
399 buffer[length] = '\0';
401 #ifdef CONFIG_CISS_SCSI_TAPE
402 if (strncmp(ENGAGE_SCSI, buffer, sizeof ENGAGE_SCSI - 1) == 0) {
403 struct seq_file *seq = file->private_data;
404 ctlr_info_t *h = seq->private;
407 rc = cciss_engage_scsi(h->ctlr);
413 #endif /* CONFIG_CISS_SCSI_TAPE */
415 /* might be nice to have "disengage" too, but it's not
416 safely possible. (only 1 module use count, lock issues.) */
419 free_page((unsigned long)buffer);
423 static struct file_operations cciss_proc_fops = {
424 .owner = THIS_MODULE,
425 .open = cciss_seq_open,
428 .release = seq_release,
429 .write = cciss_proc_write,
432 static void __devinit cciss_procinit(int i)
434 struct proc_dir_entry *pde;
436 if (proc_cciss == NULL)
437 proc_cciss = proc_mkdir("driver/cciss", NULL);
440 pde = proc_create_data(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP |
442 &cciss_proc_fops, hba[i]);
444 #endif /* CONFIG_PROC_FS */
447 * For operations that cannot sleep, a command block is allocated at init,
448 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
449 * which ones are free or in use. For operations that can wait for kmalloc
450 * to possible sleep, this routine can be called with get_from_pool set to 0.
451 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
453 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
455 CommandList_struct *c;
458 dma_addr_t cmd_dma_handle, err_dma_handle;
460 if (!get_from_pool) {
461 c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
462 sizeof(CommandList_struct), &cmd_dma_handle);
465 memset(c, 0, sizeof(CommandList_struct));
469 c->err_info = (ErrorInfo_struct *)
470 pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
473 if (c->err_info == NULL) {
474 pci_free_consistent(h->pdev,
475 sizeof(CommandList_struct), c, cmd_dma_handle);
478 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
479 } else { /* get it out of the controllers pool */
482 i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
485 } while (test_and_set_bit
486 (i & (BITS_PER_LONG - 1),
487 h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
489 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
492 memset(c, 0, sizeof(CommandList_struct));
493 cmd_dma_handle = h->cmd_pool_dhandle
494 + i * sizeof(CommandList_struct);
495 c->err_info = h->errinfo_pool + i;
496 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
497 err_dma_handle = h->errinfo_pool_dhandle
498 + i * sizeof(ErrorInfo_struct);
504 c->busaddr = (__u32) cmd_dma_handle;
505 temp64.val = (__u64) err_dma_handle;
506 c->ErrDesc.Addr.lower = temp64.val32.lower;
507 c->ErrDesc.Addr.upper = temp64.val32.upper;
508 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
515 * Frees a command block that was previously allocated with cmd_alloc().
517 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
522 if (!got_from_pool) {
523 temp64.val32.lower = c->ErrDesc.Addr.lower;
524 temp64.val32.upper = c->ErrDesc.Addr.upper;
525 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
526 c->err_info, (dma_addr_t) temp64.val);
527 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
528 c, (dma_addr_t) c->busaddr);
531 clear_bit(i & (BITS_PER_LONG - 1),
532 h->cmd_pool_bits + (i / BITS_PER_LONG));
537 static inline ctlr_info_t *get_host(struct gendisk *disk)
539 return disk->queue->queuedata;
542 static inline drive_info_struct *get_drv(struct gendisk *disk)
544 return disk->private_data;
548 * Open. Make sure the device is really there.
550 static int cciss_open(struct inode *inode, struct file *filep)
552 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
553 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
556 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
557 #endif /* CCISS_DEBUG */
559 if (host->busy_initializing || drv->busy_configuring)
562 * Root is allowed to open raw volume zero even if it's not configured
563 * so array config can still work. Root is also allowed to open any
564 * volume that has a LUN ID, so it can issue IOCTL to reread the
565 * disk information. I don't think I really like this
566 * but I'm already using way to many device nodes to claim another one
567 * for "raw controller".
569 if (drv->heads == 0) {
570 if (iminor(inode) != 0) { /* not node 0? */
571 /* if not node 0 make sure it is a partition = 0 */
572 if (iminor(inode) & 0x0f) {
574 /* if it is, make sure we have a LUN ID */
575 } else if (drv->LunID == 0) {
579 if (!capable(CAP_SYS_ADMIN))
590 static int cciss_release(struct inode *inode, struct file *filep)
592 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
593 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
596 printk(KERN_DEBUG "cciss_release %s\n",
597 inode->i_bdev->bd_disk->disk_name);
598 #endif /* CCISS_DEBUG */
607 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
611 ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);
616 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
618 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
621 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
624 case CCISS_GETPCIINFO:
625 case CCISS_GETINTINFO:
626 case CCISS_SETINTINFO:
627 case CCISS_GETNODENAME:
628 case CCISS_SETNODENAME:
629 case CCISS_GETHEARTBEAT:
630 case CCISS_GETBUSTYPES:
631 case CCISS_GETFIRMVER:
632 case CCISS_GETDRIVVER:
633 case CCISS_REVALIDVOLS:
634 case CCISS_DEREGDISK:
635 case CCISS_REGNEWDISK:
637 case CCISS_RESCANDISK:
638 case CCISS_GETLUNINFO:
639 return do_ioctl(f, cmd, arg);
641 case CCISS_PASSTHRU32:
642 return cciss_ioctl32_passthru(f, cmd, arg);
643 case CCISS_BIG_PASSTHRU32:
644 return cciss_ioctl32_big_passthru(f, cmd, arg);
651 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
654 IOCTL32_Command_struct __user *arg32 =
655 (IOCTL32_Command_struct __user *) arg;
656 IOCTL_Command_struct arg64;
657 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
663 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
664 sizeof(arg64.LUN_info));
666 copy_from_user(&arg64.Request, &arg32->Request,
667 sizeof(arg64.Request));
669 copy_from_user(&arg64.error_info, &arg32->error_info,
670 sizeof(arg64.error_info));
671 err |= get_user(arg64.buf_size, &arg32->buf_size);
672 err |= get_user(cp, &arg32->buf);
673 arg64.buf = compat_ptr(cp);
674 err |= copy_to_user(p, &arg64, sizeof(arg64));
679 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
683 copy_in_user(&arg32->error_info, &p->error_info,
684 sizeof(arg32->error_info));
690 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
693 BIG_IOCTL32_Command_struct __user *arg32 =
694 (BIG_IOCTL32_Command_struct __user *) arg;
695 BIG_IOCTL_Command_struct arg64;
696 BIG_IOCTL_Command_struct __user *p =
697 compat_alloc_user_space(sizeof(arg64));
703 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
704 sizeof(arg64.LUN_info));
706 copy_from_user(&arg64.Request, &arg32->Request,
707 sizeof(arg64.Request));
709 copy_from_user(&arg64.error_info, &arg32->error_info,
710 sizeof(arg64.error_info));
711 err |= get_user(arg64.buf_size, &arg32->buf_size);
712 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
713 err |= get_user(cp, &arg32->buf);
714 arg64.buf = compat_ptr(cp);
715 err |= copy_to_user(p, &arg64, sizeof(arg64));
720 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
724 copy_in_user(&arg32->error_info, &p->error_info,
725 sizeof(arg32->error_info));
732 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
734 drive_info_struct *drv = get_drv(bdev->bd_disk);
739 geo->heads = drv->heads;
740 geo->sectors = drv->sectors;
741 geo->cylinders = drv->cylinders;
748 static int cciss_ioctl(struct inode *inode, struct file *filep,
749 unsigned int cmd, unsigned long arg)
751 struct block_device *bdev = inode->i_bdev;
752 struct gendisk *disk = bdev->bd_disk;
753 ctlr_info_t *host = get_host(disk);
754 drive_info_struct *drv = get_drv(disk);
755 int ctlr = host->ctlr;
756 void __user *argp = (void __user *)arg;
759 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
760 #endif /* CCISS_DEBUG */
763 case CCISS_GETPCIINFO:
765 cciss_pci_info_struct pciinfo;
769 pciinfo.domain = pci_domain_nr(host->pdev->bus);
770 pciinfo.bus = host->pdev->bus->number;
771 pciinfo.dev_fn = host->pdev->devfn;
772 pciinfo.board_id = host->board_id;
774 (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
778 case CCISS_GETINTINFO:
780 cciss_coalint_struct intinfo;
784 readl(&host->cfgtable->HostWrite.CoalIntDelay);
786 readl(&host->cfgtable->HostWrite.CoalIntCount);
788 (argp, &intinfo, sizeof(cciss_coalint_struct)))
792 case CCISS_SETINTINFO:
794 cciss_coalint_struct intinfo;
800 if (!capable(CAP_SYS_ADMIN))
803 (&intinfo, argp, sizeof(cciss_coalint_struct)))
805 if ((intinfo.delay == 0) && (intinfo.count == 0))
807 // printk("cciss_ioctl: delay and count cannot be 0\n");
810 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
811 /* Update the field, and then ring the doorbell */
812 writel(intinfo.delay,
813 &(host->cfgtable->HostWrite.CoalIntDelay));
814 writel(intinfo.count,
815 &(host->cfgtable->HostWrite.CoalIntCount));
816 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
818 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
819 if (!(readl(host->vaddr + SA5_DOORBELL)
822 /* delay and try again */
825 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
826 if (i >= MAX_IOCTL_CONFIG_WAIT)
830 case CCISS_GETNODENAME:
832 NodeName_type NodeName;
837 for (i = 0; i < 16; i++)
839 readb(&host->cfgtable->ServerName[i]);
840 if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
844 case CCISS_SETNODENAME:
846 NodeName_type NodeName;
852 if (!capable(CAP_SYS_ADMIN))
856 (NodeName, argp, sizeof(NodeName_type)))
859 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
861 /* Update the field, and then ring the doorbell */
862 for (i = 0; i < 16; i++)
864 &host->cfgtable->ServerName[i]);
866 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
868 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
869 if (!(readl(host->vaddr + SA5_DOORBELL)
872 /* delay and try again */
875 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
876 if (i >= MAX_IOCTL_CONFIG_WAIT)
881 case CCISS_GETHEARTBEAT:
883 Heartbeat_type heartbeat;
887 heartbeat = readl(&host->cfgtable->HeartBeat);
889 (argp, &heartbeat, sizeof(Heartbeat_type)))
893 case CCISS_GETBUSTYPES:
895 BusTypes_type BusTypes;
899 BusTypes = readl(&host->cfgtable->BusTypes);
901 (argp, &BusTypes, sizeof(BusTypes_type)))
905 case CCISS_GETFIRMVER:
907 FirmwareVer_type firmware;
911 memcpy(firmware, host->firm_ver, 4);
914 (argp, firmware, sizeof(FirmwareVer_type)))
918 case CCISS_GETDRIVVER:
920 DriverVer_type DriverVer = DRIVER_VERSION;
926 (argp, &DriverVer, sizeof(DriverVer_type)))
931 case CCISS_DEREGDISK:
933 case CCISS_REVALIDVOLS:
934 return rebuild_lun_table(host, 0);
936 case CCISS_GETLUNINFO:{
937 LogvolInfo_struct luninfo;
939 luninfo.LunID = drv->LunID;
940 luninfo.num_opens = drv->usage_count;
941 luninfo.num_parts = 0;
942 if (copy_to_user(argp, &luninfo,
943 sizeof(LogvolInfo_struct)))
949 IOCTL_Command_struct iocommand;
950 CommandList_struct *c;
954 DECLARE_COMPLETION_ONSTACK(wait);
959 if (!capable(CAP_SYS_RAWIO))
963 (&iocommand, argp, sizeof(IOCTL_Command_struct)))
965 if ((iocommand.buf_size < 1) &&
966 (iocommand.Request.Type.Direction != XFER_NONE)) {
969 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
970 /* Check kmalloc limits */
971 if (iocommand.buf_size > 128000)
974 if (iocommand.buf_size > 0) {
975 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
979 if (iocommand.Request.Type.Direction == XFER_WRITE) {
980 /* Copy the data into the buffer we created */
982 (buff, iocommand.buf, iocommand.buf_size)) {
987 memset(buff, 0, iocommand.buf_size);
989 if ((c = cmd_alloc(host, 0)) == NULL) {
993 // Fill in the command type
994 c->cmd_type = CMD_IOCTL_PEND;
995 // Fill in Command Header
996 c->Header.ReplyQueue = 0; // unused in simple mode
997 if (iocommand.buf_size > 0) // buffer to fill
999 c->Header.SGList = 1;
1000 c->Header.SGTotal = 1;
1001 } else // no buffers to fill
1003 c->Header.SGList = 0;
1004 c->Header.SGTotal = 0;
1006 c->Header.LUN = iocommand.LUN_info;
1007 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
1009 // Fill in Request block
1010 c->Request = iocommand.Request;
1012 // Fill in the scatter gather information
1013 if (iocommand.buf_size > 0) {
1014 temp64.val = pci_map_single(host->pdev, buff,
1016 PCI_DMA_BIDIRECTIONAL);
1017 c->SG[0].Addr.lower = temp64.val32.lower;
1018 c->SG[0].Addr.upper = temp64.val32.upper;
1019 c->SG[0].Len = iocommand.buf_size;
1020 c->SG[0].Ext = 0; // we are not chaining
1024 /* Put the request on the tail of the request queue */
1025 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1026 addQ(&host->reqQ, c);
1029 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1031 wait_for_completion(&wait);
1033 /* unlock the buffers from DMA */
1034 temp64.val32.lower = c->SG[0].Addr.lower;
1035 temp64.val32.upper = c->SG[0].Addr.upper;
1036 pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
1038 PCI_DMA_BIDIRECTIONAL);
1040 /* Copy the error information out */
1041 iocommand.error_info = *(c->err_info);
1043 (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
1045 cmd_free(host, c, 0);
1049 if (iocommand.Request.Type.Direction == XFER_READ) {
1050 /* Copy the data out of the buffer we created */
1052 (iocommand.buf, buff, iocommand.buf_size)) {
1054 cmd_free(host, c, 0);
1059 cmd_free(host, c, 0);
1062 case CCISS_BIG_PASSTHRU:{
1063 BIG_IOCTL_Command_struct *ioc;
1064 CommandList_struct *c;
1065 unsigned char **buff = NULL;
1066 int *buff_size = NULL;
1068 unsigned long flags;
1072 DECLARE_COMPLETION_ONSTACK(wait);
1075 BYTE __user *data_ptr;
1079 if (!capable(CAP_SYS_RAWIO))
1081 ioc = (BIG_IOCTL_Command_struct *)
1082 kmalloc(sizeof(*ioc), GFP_KERNEL);
1087 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
1091 if ((ioc->buf_size < 1) &&
1092 (ioc->Request.Type.Direction != XFER_NONE)) {
1096 /* Check kmalloc limits using all SGs */
1097 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
1101 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1106 kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1111 buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
1117 left = ioc->buf_size;
1118 data_ptr = ioc->buf;
1121 ioc->malloc_size) ? ioc->
1123 buff_size[sg_used] = sz;
1124 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1125 if (buff[sg_used] == NULL) {
1129 if (ioc->Request.Type.Direction == XFER_WRITE) {
1131 (buff[sg_used], data_ptr, sz)) {
1136 memset(buff[sg_used], 0, sz);
1142 if ((c = cmd_alloc(host, 0)) == NULL) {
1146 c->cmd_type = CMD_IOCTL_PEND;
1147 c->Header.ReplyQueue = 0;
1149 if (ioc->buf_size > 0) {
1150 c->Header.SGList = sg_used;
1151 c->Header.SGTotal = sg_used;
1153 c->Header.SGList = 0;
1154 c->Header.SGTotal = 0;
1156 c->Header.LUN = ioc->LUN_info;
1157 c->Header.Tag.lower = c->busaddr;
1159 c->Request = ioc->Request;
1160 if (ioc->buf_size > 0) {
1162 for (i = 0; i < sg_used; i++) {
1164 pci_map_single(host->pdev, buff[i],
1166 PCI_DMA_BIDIRECTIONAL);
1167 c->SG[i].Addr.lower =
1169 c->SG[i].Addr.upper =
1171 c->SG[i].Len = buff_size[i];
1172 c->SG[i].Ext = 0; /* we are not chaining */
1176 /* Put the request on the tail of the request queue */
1177 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1178 addQ(&host->reqQ, c);
1181 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1182 wait_for_completion(&wait);
1183 /* unlock the buffers from DMA */
1184 for (i = 0; i < sg_used; i++) {
1185 temp64.val32.lower = c->SG[i].Addr.lower;
1186 temp64.val32.upper = c->SG[i].Addr.upper;
1187 pci_unmap_single(host->pdev,
1188 (dma_addr_t) temp64.val, buff_size[i],
1189 PCI_DMA_BIDIRECTIONAL);
1191 /* Copy the error information out */
1192 ioc->error_info = *(c->err_info);
1193 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1194 cmd_free(host, c, 0);
1198 if (ioc->Request.Type.Direction == XFER_READ) {
1199 /* Copy the data out of the buffer we created */
1200 BYTE __user *ptr = ioc->buf;
1201 for (i = 0; i < sg_used; i++) {
1203 (ptr, buff[i], buff_size[i])) {
1204 cmd_free(host, c, 0);
1208 ptr += buff_size[i];
1211 cmd_free(host, c, 0);
1215 for (i = 0; i < sg_used; i++)
1224 /* scsi_cmd_ioctl handles these, below, though some are not */
1225 /* very meaningful for cciss. SG_IO is the main one people want. */
1227 case SG_GET_VERSION_NUM:
1228 case SG_SET_TIMEOUT:
1229 case SG_GET_TIMEOUT:
1230 case SG_GET_RESERVED_SIZE:
1231 case SG_SET_RESERVED_SIZE:
1232 case SG_EMULATED_HOST:
1234 case SCSI_IOCTL_SEND_COMMAND:
1235 return scsi_cmd_ioctl(filep, disk->queue, disk, cmd, argp);
1237 /* scsi_cmd_ioctl would normally handle these, below, but */
1238 /* they aren't a good fit for cciss, as CD-ROMs are */
1239 /* not supported, and we don't have any bus/target/lun */
1240 /* which we present to the kernel. */
1242 case CDROM_SEND_PACKET:
1243 case CDROMCLOSETRAY:
1245 case SCSI_IOCTL_GET_IDLUN:
1246 case SCSI_IOCTL_GET_BUS_NUMBER:
1252 static void cciss_check_queues(ctlr_info_t *h)
1254 int start_queue = h->next_to_run;
1257 /* check to see if we have maxed out the number of commands that can
1258 * be placed on the queue. If so then exit. We do this check here
1259 * in case the interrupt we serviced was from an ioctl and did not
1260 * free any new commands.
1262 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
1265 /* We have room on the queue for more commands. Now we need to queue
1266 * them up. We will also keep track of the next queue to run so
1267 * that every queue gets a chance to be started first.
1269 for (i = 0; i < h->highest_lun + 1; i++) {
1270 int curr_queue = (start_queue + i) % (h->highest_lun + 1);
1271 /* make sure the disk has been added and the drive is real
1272 * because this can be called from the middle of init_one.
1274 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
1276 blk_start_queue(h->gendisk[curr_queue]->queue);
1278 /* check to see if we have maxed out the number of commands
1279 * that can be placed on the queue.
1281 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
1282 if (curr_queue == start_queue) {
1284 (start_queue + 1) % (h->highest_lun + 1);
1287 h->next_to_run = curr_queue;
1294 static void cciss_softirq_done(struct request *rq)
1296 CommandList_struct *cmd = rq->completion_data;
1297 ctlr_info_t *h = hba[cmd->ctlr];
1298 unsigned long flags;
1302 if (cmd->Request.Type.Direction == XFER_READ)
1303 ddir = PCI_DMA_FROMDEVICE;
1305 ddir = PCI_DMA_TODEVICE;
1307 /* command did not need to be retried */
1308 /* unmap the DMA mapping for all the scatter gather elements */
1309 for (i = 0; i < cmd->Header.SGList; i++) {
1310 temp64.val32.lower = cmd->SG[i].Addr.lower;
1311 temp64.val32.upper = cmd->SG[i].Addr.upper;
1312 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1316 printk("Done with %p\n", rq);
1317 #endif /* CCISS_DEBUG */
1319 if (blk_end_request(rq, (rq->errors == 0) ? 0 : -EIO, blk_rq_bytes(rq)))
1322 spin_lock_irqsave(&h->lock, flags);
1323 cmd_free(h, cmd, 1);
1324 cciss_check_queues(h);
1325 spin_unlock_irqrestore(&h->lock, flags);
1328 /* This function gets the serial number of a logical drive via
1329 * inquiry page 0x83. Serial no. is 16 bytes. If the serial
1330 * number cannot be had, for whatever reason, 16 bytes of 0xff
1331 * are returned instead.
1333 static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
1334 unsigned char *serial_no, int buflen)
1336 #define PAGE_83_INQ_BYTES 64
1342 memset(serial_no, 0xff, buflen);
1343 buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
1346 memset(serial_no, 0, buflen);
1348 rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
1349 PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
1351 rc = sendcmd(CISS_INQUIRY, ctlr, buf,
1352 PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
1354 memcpy(serial_no, &buf[8], buflen);
1359 static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
1362 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1363 sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index);
1364 disk->major = h->major;
1365 disk->first_minor = drv_index << NWD_SHIFT;
1366 disk->fops = &cciss_fops;
1367 disk->private_data = &h->drv[drv_index];
1369 /* Set up queue information */
1370 blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
1372 /* This is a hardware imposed limit. */
1373 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1375 /* This is a limit in the driver and could be eliminated. */
1376 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1378 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1380 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1382 disk->queue->queuedata = h;
1384 blk_queue_hardsect_size(disk->queue,
1385 h->drv[drv_index].block_size);
1387 /* Make sure all queue data is written out before */
1388 /* setting h->drv[drv_index].queue, as setting this */
1389 /* allows the interrupt handler to start the queue */
1391 h->drv[drv_index].queue = disk->queue;
1395 /* This function will check the usage_count of the drive to be updated/added.
1396 * If the usage_count is zero and it is a heretofore unknown drive, or,
1397 * the drive's capacity, geometry, or serial number has changed,
1398 * then the drive information will be updated and the disk will be
1399 * re-registered with the kernel. If these conditions don't hold,
1400 * then it will be left alone for the next reboot. The exception to this
1401 * is disk 0 which will always be left registered with the kernel since it
1402 * is also the controller node. Any changes to disk 0 will show up on
1405 static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
1407 ctlr_info_t *h = hba[ctlr];
1408 struct gendisk *disk;
1409 InquiryData_struct *inq_buff = NULL;
1410 unsigned int block_size;
1411 sector_t total_size;
1412 unsigned long flags = 0;
1414 drive_info_struct *drvinfo;
1415 int was_only_controller_node;
1417 /* Get information about the disk and modify the driver structure */
1418 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1419 drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL);
1420 if (inq_buff == NULL || drvinfo == NULL)
1423 /* See if we're trying to update the "controller node"
1424 * this will happen the when the first logical drive gets
1427 was_only_controller_node = (drv_index == 0 &&
1428 h->drv[0].raid_level == -1);
1430 /* testing to see if 16-byte CDBs are already being used */
1431 if (h->cciss_read == CCISS_READ_16) {
1432 cciss_read_capacity_16(h->ctlr, drv_index, 1,
1433 &total_size, &block_size);
1436 cciss_read_capacity(ctlr, drv_index, 1,
1437 &total_size, &block_size);
1439 /* if read_capacity returns all F's this volume is >2TB */
1440 /* in size so we switch to 16-byte CDB's for all */
1441 /* read/write ops */
1442 if (total_size == 0xFFFFFFFFULL) {
1443 cciss_read_capacity_16(ctlr, drv_index, 1,
1444 &total_size, &block_size);
1445 h->cciss_read = CCISS_READ_16;
1446 h->cciss_write = CCISS_WRITE_16;
1448 h->cciss_read = CCISS_READ_10;
1449 h->cciss_write = CCISS_WRITE_10;
1453 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1455 drvinfo->block_size = block_size;
1456 drvinfo->nr_blocks = total_size + 1;
1458 cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
1459 sizeof(drvinfo->serial_no));
1461 /* Is it the same disk we already know, and nothing's changed? */
1462 if (h->drv[drv_index].raid_level != -1 &&
1463 ((memcmp(drvinfo->serial_no,
1464 h->drv[drv_index].serial_no, 16) == 0) &&
1465 drvinfo->block_size == h->drv[drv_index].block_size &&
1466 drvinfo->nr_blocks == h->drv[drv_index].nr_blocks &&
1467 drvinfo->heads == h->drv[drv_index].heads &&
1468 drvinfo->sectors == h->drv[drv_index].sectors &&
1469 drvinfo->cylinders == h->drv[drv_index].cylinders))
1470 /* The disk is unchanged, nothing to update */
1473 /* If we get here it's not the same disk, or something's changed,
1474 * so we need to * deregister it, and re-register it, if it's not
1476 * If the disk already exists then deregister it before proceeding
1477 * (unless it's the first disk (for the controller node).
1479 if (h->drv[drv_index].raid_level != -1 && drv_index != 0) {
1480 printk(KERN_WARNING "disk %d has changed.\n", drv_index);
1481 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1482 h->drv[drv_index].busy_configuring = 1;
1483 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1485 /* deregister_disk sets h->drv[drv_index].queue = NULL
1486 * which keeps the interrupt handler from starting
1489 ret = deregister_disk(h->gendisk[drv_index],
1490 &h->drv[drv_index], 0);
1491 h->drv[drv_index].busy_configuring = 0;
1494 /* If the disk is in use return */
1498 /* Save the new information from cciss_geometry_inquiry
1499 * and serial number inquiry.
1501 h->drv[drv_index].block_size = drvinfo->block_size;
1502 h->drv[drv_index].nr_blocks = drvinfo->nr_blocks;
1503 h->drv[drv_index].heads = drvinfo->heads;
1504 h->drv[drv_index].sectors = drvinfo->sectors;
1505 h->drv[drv_index].cylinders = drvinfo->cylinders;
1506 h->drv[drv_index].raid_level = drvinfo->raid_level;
1507 memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
1510 disk = h->gendisk[drv_index];
1511 set_capacity(disk, h->drv[drv_index].nr_blocks);
1513 /* If it's not disk 0 (drv_index != 0)
1514 * or if it was disk 0, but there was previously
1515 * no actual corresponding configured logical drive
1516 * (raid_leve == -1) then we want to update the
1517 * logical drive's information.
1519 if (drv_index || first_time)
1520 cciss_add_disk(h, disk, drv_index);
1527 printk(KERN_ERR "cciss: out of memory\n");
1531 /* This function will find the first index of the controllers drive array
1532 * that has a -1 for the raid_level and will return that index. This is
1533 * where new drives will be added. If the index to be returned is greater
1534 * than the highest_lun index for the controller then highest_lun is set
1535 * to this new index. If there are no available indexes then -1 is returned.
1537 static int cciss_find_free_drive_index(int ctlr)
1541 for (i = 0; i < CISS_MAX_LUN; i++) {
1542 if (hba[ctlr]->drv[i].raid_level == -1) {
1543 if (i > hba[ctlr]->highest_lun)
1544 hba[ctlr]->highest_lun = i;
1551 /* cciss_add_gendisk finds a free hba[]->drv structure
1552 * and allocates a gendisk if needed, and sets the lunid
1553 * in the drvinfo structure. It returns the index into
1554 * the ->drv[] array, or -1 if none are free.
1555 * is_controller_node indicates whether highest_lun should
1556 * count this disk, or if it's only being added to provide
1557 * a means to talk to the controller in case no logical
1558 * drives have yet been configured.
1560 static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid)
1564 drv_index = cciss_find_free_drive_index(h->ctlr);
1565 if (drv_index == -1)
1567 /*Check if the gendisk needs to be allocated */
1568 if (!h->gendisk[drv_index]) {
1569 h->gendisk[drv_index] =
1570 alloc_disk(1 << NWD_SHIFT);
1571 if (!h->gendisk[drv_index]) {
1572 printk(KERN_ERR "cciss%d: could not "
1573 "allocate a new disk %d\n",
1574 h->ctlr, drv_index);
1578 h->drv[drv_index].LunID = lunid;
1580 /* Don't need to mark this busy because nobody */
1581 /* else knows about this disk yet to contend */
1582 /* for access to it. */
1583 h->drv[drv_index].busy_configuring = 0;
1588 /* This is for the special case of a controller which
1589 * has no logical drives. In this case, we still need
1590 * to register a disk so the controller can be accessed
1591 * by the Array Config Utility.
1593 static void cciss_add_controller_node(ctlr_info_t *h)
1595 struct gendisk *disk;
1598 if (h->gendisk[0] != NULL) /* already did this? Then bail. */
1601 drv_index = cciss_add_gendisk(h, 0);
1602 if (drv_index == -1) {
1603 printk(KERN_WARNING "cciss%d: could not "
1604 "add disk 0.\n", h->ctlr);
1607 h->drv[drv_index].block_size = 512;
1608 h->drv[drv_index].nr_blocks = 0;
1609 h->drv[drv_index].heads = 0;
1610 h->drv[drv_index].sectors = 0;
1611 h->drv[drv_index].cylinders = 0;
1612 h->drv[drv_index].raid_level = -1;
1613 memset(h->drv[drv_index].serial_no, 0, 16);
1614 disk = h->gendisk[drv_index];
1615 cciss_add_disk(h, disk, drv_index);
1618 /* This function will add and remove logical drives from the Logical
1619 * drive array of the controller and maintain persistency of ordering
1620 * so that mount points are preserved until the next reboot. This allows
1621 * for the removal of logical drives in the middle of the drive array
1622 * without a re-ordering of those drives.
1624 * h = The controller to perform the operations on
1626 static int rebuild_lun_table(ctlr_info_t *h, int first_time)
1630 ReportLunData_struct *ld_buff = NULL;
1637 unsigned long flags;
1639 if (!capable(CAP_SYS_RAWIO))
1642 /* Set busy_configuring flag for this operation */
1643 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1644 if (h->busy_configuring) {
1645 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1648 h->busy_configuring = 1;
1649 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1651 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1652 if (ld_buff == NULL)
1655 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1656 sizeof(ReportLunData_struct), 0,
1659 if (return_code == IO_OK)
1660 listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
1661 else { /* reading number of logical volumes failed */
1662 printk(KERN_WARNING "cciss: report logical volume"
1663 " command failed\n");
1668 num_luns = listlength / 8; /* 8 bytes per entry */
1669 if (num_luns > CISS_MAX_LUN) {
1670 num_luns = CISS_MAX_LUN;
1671 printk(KERN_WARNING "cciss: more luns configured"
1672 " on controller than can be handled by"
1677 cciss_add_controller_node(h);
1679 /* Compare controller drive array to driver's drive array
1680 * to see if any drives are missing on the controller due
1681 * to action of Array Config Utility (user deletes drive)
1682 * and deregister logical drives which have disappeared.
1684 for (i = 0; i <= h->highest_lun; i++) {
1687 for (j = 0; j < num_luns; j++) {
1688 memcpy(&lunid, &ld_buff->LUN[j][0], 4);
1689 lunid = le32_to_cpu(lunid);
1690 if (h->drv[i].LunID == lunid) {
1696 /* Deregister it from the OS, it's gone. */
1697 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1698 h->drv[i].busy_configuring = 1;
1699 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1700 return_code = deregister_disk(h->gendisk[i],
1702 h->drv[i].busy_configuring = 0;
1706 /* Compare controller drive array to driver's drive array.
1707 * Check for updates in the drive information and any new drives
1708 * on the controller due to ACU adding logical drives, or changing
1709 * a logical drive's size, etc. Reregister any new/changed drives
1711 for (i = 0; i < num_luns; i++) {
1716 memcpy(&lunid, &ld_buff->LUN[i][0], 4);
1717 lunid = le32_to_cpu(lunid);
1719 /* Find if the LUN is already in the drive array
1720 * of the driver. If so then update its info
1721 * if not in use. If it does not exist then find
1722 * the first free index and add it.
1724 for (j = 0; j <= h->highest_lun; j++) {
1725 if (h->drv[j].raid_level != -1 &&
1726 h->drv[j].LunID == lunid) {
1733 /* check if the drive was found already in the array */
1735 drv_index = cciss_add_gendisk(h, lunid);
1736 if (drv_index == -1)
1739 cciss_update_drive_info(ctlr, drv_index, first_time);
1744 h->busy_configuring = 0;
1745 /* We return -1 here to tell the ACU that we have registered/updated
1746 * all of the drives that we can and to keep it from calling us
1751 printk(KERN_ERR "cciss: out of memory\n");
1752 h->busy_configuring = 0;
1756 /* This function will deregister the disk and it's queue from the
1757 * kernel. It must be called with the controller lock held and the
1758 * drv structures busy_configuring flag set. It's parameters are:
1760 * disk = This is the disk to be deregistered
1761 * drv = This is the drive_info_struct associated with the disk to be
1762 * deregistered. It contains information about the disk used
1764 * clear_all = This flag determines whether or not the disk information
1765 * is going to be completely cleared out and the highest_lun
1766 * reset. Sometimes we want to clear out information about
1767 * the disk in preparation for re-adding it. In this case
1768 * the highest_lun should be left unchanged and the LunID
1769 * should not be cleared.
1771 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1775 ctlr_info_t *h = get_host(disk);
1777 if (!capable(CAP_SYS_RAWIO))
1780 /* make sure logical volume is NOT is use */
1781 if (clear_all || (h->gendisk[0] == disk)) {
1782 if (drv->usage_count > 1)
1784 } else if (drv->usage_count > 0)
1787 /* invalidate the devices and deregister the disk. If it is disk
1788 * zero do not deregister it but just zero out it's values. This
1789 * allows us to delete disk zero but keep the controller registered.
1791 if (h->gendisk[0] != disk) {
1792 struct request_queue *q = disk->queue;
1793 if (disk->flags & GENHD_FL_UP)
1796 blk_cleanup_queue(q);
1797 /* Set drv->queue to NULL so that we do not try
1798 * to call blk_start_queue on this queue in the
1803 /* If clear_all is set then we are deleting the logical
1804 * drive, not just refreshing its info. For drives
1805 * other than disk 0 we will call put_disk. We do not
1806 * do this for disk 0 as we need it to be able to
1807 * configure the controller.
1810 /* This isn't pretty, but we need to find the
1811 * disk in our array and NULL our the pointer.
1812 * This is so that we will call alloc_disk if
1813 * this index is used again later.
1815 for (i=0; i < CISS_MAX_LUN; i++){
1816 if (h->gendisk[i] == disk) {
1817 h->gendisk[i] = NULL;
1824 set_capacity(disk, 0);
1828 /* zero out the disk size info */
1830 drv->block_size = 0;
1834 drv->raid_level = -1; /* This can be used as a flag variable to
1835 * indicate that this element of the drive
1840 /* check to see if it was the last disk */
1841 if (drv == h->drv + h->highest_lun) {
1842 /* if so, find the new hightest lun */
1843 int i, newhighest = -1;
1844 for (i = 0; i <= h->highest_lun; i++) {
1845 /* if the disk has size > 0, it is available */
1846 if (h->drv[i].heads)
1849 h->highest_lun = newhighest;
1857 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
1858 1: address logical volume log_unit,
1859 2: periph device address is scsi3addr */
1860 unsigned int log_unit, __u8 page_code,
1861 unsigned char *scsi3addr, int cmd_type)
1863 ctlr_info_t *h = hba[ctlr];
1864 u64bit buff_dma_handle;
1867 c->cmd_type = CMD_IOCTL_PEND;
1868 c->Header.ReplyQueue = 0;
1870 c->Header.SGList = 1;
1871 c->Header.SGTotal = 1;
1873 c->Header.SGList = 0;
1874 c->Header.SGTotal = 0;
1876 c->Header.Tag.lower = c->busaddr;
1878 c->Request.Type.Type = cmd_type;
1879 if (cmd_type == TYPE_CMD) {
1882 /* If the logical unit number is 0 then, this is going
1883 to controller so It's a physical command
1884 mode = 0 target = 0. So we have nothing to write.
1885 otherwise, if use_unit_num == 1,
1886 mode = 1(volume set addressing) target = LUNID
1887 otherwise, if use_unit_num == 2,
1888 mode = 0(periph dev addr) target = scsi3addr */
1889 if (use_unit_num == 1) {
1890 c->Header.LUN.LogDev.VolId =
1891 h->drv[log_unit].LunID;
1892 c->Header.LUN.LogDev.Mode = 1;
1893 } else if (use_unit_num == 2) {
1894 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1896 c->Header.LUN.LogDev.Mode = 0;
1898 /* are we trying to read a vital product page */
1899 if (page_code != 0) {
1900 c->Request.CDB[1] = 0x01;
1901 c->Request.CDB[2] = page_code;
1903 c->Request.CDBLen = 6;
1904 c->Request.Type.Attribute = ATTR_SIMPLE;
1905 c->Request.Type.Direction = XFER_READ;
1906 c->Request.Timeout = 0;
1907 c->Request.CDB[0] = CISS_INQUIRY;
1908 c->Request.CDB[4] = size & 0xFF;
1910 case CISS_REPORT_LOG:
1911 case CISS_REPORT_PHYS:
1912 /* Talking to controller so It's a physical command
1913 mode = 00 target = 0. Nothing to write.
1915 c->Request.CDBLen = 12;
1916 c->Request.Type.Attribute = ATTR_SIMPLE;
1917 c->Request.Type.Direction = XFER_READ;
1918 c->Request.Timeout = 0;
1919 c->Request.CDB[0] = cmd;
1920 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1921 c->Request.CDB[7] = (size >> 16) & 0xFF;
1922 c->Request.CDB[8] = (size >> 8) & 0xFF;
1923 c->Request.CDB[9] = size & 0xFF;
1926 case CCISS_READ_CAPACITY:
1927 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1928 c->Header.LUN.LogDev.Mode = 1;
1929 c->Request.CDBLen = 10;
1930 c->Request.Type.Attribute = ATTR_SIMPLE;
1931 c->Request.Type.Direction = XFER_READ;
1932 c->Request.Timeout = 0;
1933 c->Request.CDB[0] = cmd;
1935 case CCISS_READ_CAPACITY_16:
1936 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1937 c->Header.LUN.LogDev.Mode = 1;
1938 c->Request.CDBLen = 16;
1939 c->Request.Type.Attribute = ATTR_SIMPLE;
1940 c->Request.Type.Direction = XFER_READ;
1941 c->Request.Timeout = 0;
1942 c->Request.CDB[0] = cmd;
1943 c->Request.CDB[1] = 0x10;
1944 c->Request.CDB[10] = (size >> 24) & 0xFF;
1945 c->Request.CDB[11] = (size >> 16) & 0xFF;
1946 c->Request.CDB[12] = (size >> 8) & 0xFF;
1947 c->Request.CDB[13] = size & 0xFF;
1948 c->Request.Timeout = 0;
1949 c->Request.CDB[0] = cmd;
1951 case CCISS_CACHE_FLUSH:
1952 c->Request.CDBLen = 12;
1953 c->Request.Type.Attribute = ATTR_SIMPLE;
1954 c->Request.Type.Direction = XFER_WRITE;
1955 c->Request.Timeout = 0;
1956 c->Request.CDB[0] = BMIC_WRITE;
1957 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1961 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1964 } else if (cmd_type == TYPE_MSG) {
1966 case 0: /* ABORT message */
1967 c->Request.CDBLen = 12;
1968 c->Request.Type.Attribute = ATTR_SIMPLE;
1969 c->Request.Type.Direction = XFER_WRITE;
1970 c->Request.Timeout = 0;
1971 c->Request.CDB[0] = cmd; /* abort */
1972 c->Request.CDB[1] = 0; /* abort a command */
1973 /* buff contains the tag of the command to abort */
1974 memcpy(&c->Request.CDB[4], buff, 8);
1976 case 1: /* RESET message */
1977 c->Request.CDBLen = 12;
1978 c->Request.Type.Attribute = ATTR_SIMPLE;
1979 c->Request.Type.Direction = XFER_WRITE;
1980 c->Request.Timeout = 0;
1981 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1982 c->Request.CDB[0] = cmd; /* reset */
1983 c->Request.CDB[1] = 0x04; /* reset a LUN */
1985 case 3: /* No-Op message */
1986 c->Request.CDBLen = 1;
1987 c->Request.Type.Attribute = ATTR_SIMPLE;
1988 c->Request.Type.Direction = XFER_WRITE;
1989 c->Request.Timeout = 0;
1990 c->Request.CDB[0] = cmd;
1994 "cciss%d: unknown message type %d\n", ctlr, cmd);
1999 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
2002 /* Fill in the scatter gather information */
2004 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
2006 PCI_DMA_BIDIRECTIONAL);
2007 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
2008 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
2009 c->SG[0].Len = size;
2010 c->SG[0].Ext = 0; /* we are not chaining */
2015 static int sendcmd_withirq(__u8 cmd,
2019 unsigned int use_unit_num,
2020 unsigned int log_unit, __u8 page_code, int cmd_type)
2022 ctlr_info_t *h = hba[ctlr];
2023 CommandList_struct *c;
2024 u64bit buff_dma_handle;
2025 unsigned long flags;
2027 DECLARE_COMPLETION_ONSTACK(wait);
2029 if ((c = cmd_alloc(h, 0)) == NULL)
2031 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2032 log_unit, page_code, NULL, cmd_type);
2033 if (return_status != IO_OK) {
2035 return return_status;
2040 /* Put the request on the tail of the queue and send it */
2041 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
2045 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
2047 wait_for_completion(&wait);
2049 if (c->err_info->CommandStatus != 0) { /* an error has occurred */
2050 switch (c->err_info->CommandStatus) {
2051 case CMD_TARGET_STATUS:
2052 printk(KERN_WARNING "cciss: cmd %p has "
2053 " completed with errors\n", c);
2054 if (c->err_info->ScsiStatus) {
2055 printk(KERN_WARNING "cciss: cmd %p "
2056 "has SCSI Status = %x\n",
2057 c, c->err_info->ScsiStatus);
2061 case CMD_DATA_UNDERRUN:
2062 case CMD_DATA_OVERRUN:
2063 /* expected for inquire and report lun commands */
2066 printk(KERN_WARNING "cciss: Cmd %p is "
2067 "reported invalid\n", c);
2068 return_status = IO_ERROR;
2070 case CMD_PROTOCOL_ERR:
2071 printk(KERN_WARNING "cciss: cmd %p has "
2072 "protocol error \n", c);
2073 return_status = IO_ERROR;
2075 case CMD_HARDWARE_ERR:
2076 printk(KERN_WARNING "cciss: cmd %p had "
2077 " hardware error\n", c);
2078 return_status = IO_ERROR;
2080 case CMD_CONNECTION_LOST:
2081 printk(KERN_WARNING "cciss: cmd %p had "
2082 "connection lost\n", c);
2083 return_status = IO_ERROR;
2086 printk(KERN_WARNING "cciss: cmd %p was "
2088 return_status = IO_ERROR;
2090 case CMD_ABORT_FAILED:
2091 printk(KERN_WARNING "cciss: cmd %p reports "
2092 "abort failed\n", c);
2093 return_status = IO_ERROR;
2095 case CMD_UNSOLICITED_ABORT:
2097 "cciss%d: unsolicited abort %p\n", ctlr, c);
2098 if (c->retry_count < MAX_CMD_RETRIES) {
2100 "cciss%d: retrying %p\n", ctlr, c);
2102 /* erase the old error information */
2103 memset(c->err_info, 0,
2104 sizeof(ErrorInfo_struct));
2105 return_status = IO_OK;
2106 INIT_COMPLETION(wait);
2109 return_status = IO_ERROR;
2112 printk(KERN_WARNING "cciss: cmd %p returned "
2113 "unknown status %x\n", c,
2114 c->err_info->CommandStatus);
2115 return_status = IO_ERROR;
2118 /* unlock the buffers from DMA */
2119 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2120 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2121 pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
2122 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2124 return return_status;
2127 static void cciss_geometry_inquiry(int ctlr, int logvol,
2128 int withirq, sector_t total_size,
2129 unsigned int block_size,
2130 InquiryData_struct *inq_buff,
2131 drive_info_struct *drv)
2136 memset(inq_buff, 0, sizeof(InquiryData_struct));
2138 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
2139 inq_buff, sizeof(*inq_buff), 1,
2140 logvol, 0xC1, TYPE_CMD);
2142 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
2143 sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
2145 if (return_code == IO_OK) {
2146 if (inq_buff->data_byte[8] == 0xFF) {
2148 "cciss: reading geometry failed, volume "
2149 "does not support reading geometry\n");
2151 drv->sectors = 32; // Sectors per track
2152 drv->cylinders = total_size + 1;
2153 drv->raid_level = RAID_UNKNOWN;
2155 drv->heads = inq_buff->data_byte[6];
2156 drv->sectors = inq_buff->data_byte[7];
2157 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
2158 drv->cylinders += inq_buff->data_byte[5];
2159 drv->raid_level = inq_buff->data_byte[8];
2161 drv->block_size = block_size;
2162 drv->nr_blocks = total_size + 1;
2163 t = drv->heads * drv->sectors;
2165 sector_t real_size = total_size + 1;
2166 unsigned long rem = sector_div(real_size, t);
2169 drv->cylinders = real_size;
2171 } else { /* Get geometry failed */
2172 printk(KERN_WARNING "cciss: reading geometry failed\n");
2174 printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n",
2175 drv->heads, drv->sectors, drv->cylinders);
2179 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
2180 unsigned int *block_size)
2182 ReadCapdata_struct *buf;
2185 buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
2187 printk(KERN_WARNING "cciss: out of memory\n");
2192 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
2193 ctlr, buf, sizeof(ReadCapdata_struct),
2194 1, logvol, 0, TYPE_CMD);
2196 return_code = sendcmd(CCISS_READ_CAPACITY,
2197 ctlr, buf, sizeof(ReadCapdata_struct),
2198 1, logvol, 0, NULL, TYPE_CMD);
2199 if (return_code == IO_OK) {
2200 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
2201 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2202 } else { /* read capacity command failed */
2203 printk(KERN_WARNING "cciss: read capacity failed\n");
2205 *block_size = BLOCK_SIZE;
2207 if (*total_size != 0)
2208 printk(KERN_INFO " blocks= %llu block_size= %d\n",
2209 (unsigned long long)*total_size+1, *block_size);
2214 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, unsigned int *block_size)
2216 ReadCapdata_struct_16 *buf;
2219 buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
2221 printk(KERN_WARNING "cciss: out of memory\n");
2226 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2227 ctlr, buf, sizeof(ReadCapdata_struct_16),
2228 1, logvol, 0, TYPE_CMD);
2231 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2232 ctlr, buf, sizeof(ReadCapdata_struct_16),
2233 1, logvol, 0, NULL, TYPE_CMD);
2235 if (return_code == IO_OK) {
2236 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
2237 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2238 } else { /* read capacity command failed */
2239 printk(KERN_WARNING "cciss: read capacity failed\n");
2241 *block_size = BLOCK_SIZE;
2243 printk(KERN_INFO " blocks= %llu block_size= %d\n",
2244 (unsigned long long)*total_size+1, *block_size);
2248 static int cciss_revalidate(struct gendisk *disk)
2250 ctlr_info_t *h = get_host(disk);
2251 drive_info_struct *drv = get_drv(disk);
2254 unsigned int block_size;
2255 sector_t total_size;
2256 InquiryData_struct *inq_buff = NULL;
2258 for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2259 if (h->drv[logvol].LunID == drv->LunID) {
2268 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2269 if (inq_buff == NULL) {
2270 printk(KERN_WARNING "cciss: out of memory\n");
2273 if (h->cciss_read == CCISS_READ_10) {
2274 cciss_read_capacity(h->ctlr, logvol, 1,
2275 &total_size, &block_size);
2277 cciss_read_capacity_16(h->ctlr, logvol, 1,
2278 &total_size, &block_size);
2280 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2283 blk_queue_hardsect_size(drv->queue, drv->block_size);
2284 set_capacity(disk, drv->nr_blocks);
2291 * Wait polling for a command to complete.
2292 * The memory mapped FIFO is polled for the completion.
2293 * Used only at init time, interrupts from the HBA are disabled.
2295 static unsigned long pollcomplete(int ctlr)
2300 /* Wait (up to 20 seconds) for a command to complete */
2302 for (i = 20 * HZ; i > 0; i--) {
2303 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2304 if (done == FIFO_EMPTY)
2305 schedule_timeout_uninterruptible(1);
2309 /* Invalid address to tell caller we ran out of time */
2313 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2315 /* We get in here if sendcmd() is polling for completions
2316 and gets some command back that it wasn't expecting --
2317 something other than that which it just sent down.
2318 Ordinarily, that shouldn't happen, but it can happen when
2319 the scsi tape stuff gets into error handling mode, and
2320 starts using sendcmd() to try to abort commands and
2321 reset tape drives. In that case, sendcmd may pick up
2322 completions of commands that were sent to logical drives
2323 through the block i/o system, or cciss ioctls completing, etc.
2324 In that case, we need to save those completions for later
2325 processing by the interrupt handler.
2328 #ifdef CONFIG_CISS_SCSI_TAPE
2329 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2331 /* If it's not the scsi tape stuff doing error handling, (abort */
2332 /* or reset) then we don't expect anything weird. */
2333 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2335 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2336 "Invalid command list address returned! (%lx)\n",
2338 /* not much we can do. */
2339 #ifdef CONFIG_CISS_SCSI_TAPE
2343 /* We've sent down an abort or reset, but something else
2345 if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2346 /* Uh oh. No room to save it for later... */
2347 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2348 "reject list overflow, command lost!\n", ctlr);
2351 /* Save it for later */
2352 srl->complete[srl->ncompletions] = complete;
2353 srl->ncompletions++;
2359 * Send a command to the controller, and wait for it to complete.
2360 * Only used at init time.
2362 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
2363 1: address logical volume log_unit,
2364 2: periph device address is scsi3addr */
2365 unsigned int log_unit,
2366 __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2368 CommandList_struct *c;
2370 unsigned long complete;
2371 ctlr_info_t *info_p = hba[ctlr];
2372 u64bit buff_dma_handle;
2373 int status, done = 0;
2375 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2376 printk(KERN_WARNING "cciss: unable to get memory");
2379 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2380 log_unit, page_code, scsi3addr, cmd_type);
2381 if (status != IO_OK) {
2382 cmd_free(info_p, c, 1);
2390 printk(KERN_DEBUG "cciss: turning intr off\n");
2391 #endif /* CCISS_DEBUG */
2392 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2394 /* Make sure there is room in the command FIFO */
2395 /* Actually it should be completely empty at this time */
2396 /* unless we are in here doing error handling for the scsi */
2397 /* tape side of the driver. */
2398 for (i = 200000; i > 0; i--) {
2399 /* if fifo isn't full go */
2400 if (!(info_p->access.fifo_full(info_p))) {
2405 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2406 " waiting!\n", ctlr);
2411 info_p->access.submit_command(info_p, c);
2414 complete = pollcomplete(ctlr);
2417 printk(KERN_DEBUG "cciss: command completed\n");
2418 #endif /* CCISS_DEBUG */
2420 if (complete == 1) {
2422 "cciss cciss%d: SendCmd Timeout out, "
2423 "No command list address returned!\n", ctlr);
2429 /* This will need to change for direct lookup completions */
2430 if ((complete & CISS_ERROR_BIT)
2431 && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2432 /* if data overrun or underun on Report command
2435 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2436 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2437 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2438 ((c->err_info->CommandStatus ==
2439 CMD_DATA_OVERRUN) ||
2440 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2442 complete = c->busaddr;
2444 if (c->err_info->CommandStatus ==
2445 CMD_UNSOLICITED_ABORT) {
2446 printk(KERN_WARNING "cciss%d: "
2447 "unsolicited abort %p\n",
2449 if (c->retry_count < MAX_CMD_RETRIES) {
2451 "cciss%d: retrying %p\n",
2454 /* erase the old error */
2456 memset(c->err_info, 0,
2458 (ErrorInfo_struct));
2462 "cciss%d: retried %p too "
2463 "many times\n", ctlr, c);
2467 } else if (c->err_info->CommandStatus ==
2470 "cciss%d: command could not be aborted.\n",
2475 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2476 " Error %x \n", ctlr,
2477 c->err_info->CommandStatus);
2478 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2480 " size %x\n num %x value %x\n",
2482 c->err_info->MoreErrInfo.Invalid_Cmd.
2484 c->err_info->MoreErrInfo.Invalid_Cmd.
2486 c->err_info->MoreErrInfo.Invalid_Cmd.
2492 /* This will need changing for direct lookup completions */
2493 if (complete != c->busaddr) {
2494 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2495 BUG(); /* we are pretty much hosed if we get here. */
2503 /* unlock the data buffer from DMA */
2504 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2505 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2506 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2507 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2508 #ifdef CONFIG_CISS_SCSI_TAPE
2509 /* if we saved some commands for later, process them now. */
2510 if (info_p->scsi_rejects.ncompletions > 0)
2511 do_cciss_intr(0, info_p);
2513 cmd_free(info_p, c, 1);
2518 * Map (physical) PCI mem into (virtual) kernel space
2520 static void __iomem *remap_pci_mem(ulong base, ulong size)
2522 ulong page_base = ((ulong) base) & PAGE_MASK;
2523 ulong page_offs = ((ulong) base) - page_base;
2524 void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2526 return page_remapped ? (page_remapped + page_offs) : NULL;
2530 * Takes jobs of the Q and sends them to the hardware, then puts it on
2531 * the Q to wait for completion.
2533 static void start_io(ctlr_info_t *h)
2535 CommandList_struct *c;
2537 while ((c = h->reqQ) != NULL) {
2538 /* can't do anything if fifo is full */
2539 if ((h->access.fifo_full(h))) {
2540 printk(KERN_WARNING "cciss: fifo full\n");
2544 /* Get the first entry from the Request Q */
2545 removeQ(&(h->reqQ), c);
2548 /* Tell the controller execute command */
2549 h->access.submit_command(h, c);
2551 /* Put job onto the completed Q */
2552 addQ(&(h->cmpQ), c);
2556 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2557 /* Zeros out the error record and then resends the command back */
2558 /* to the controller */
2559 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2561 /* erase the old error information */
2562 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2564 /* add it to software queue and then send it to the controller */
2565 addQ(&(h->reqQ), c);
2567 if (h->Qdepth > h->maxQsinceinit)
2568 h->maxQsinceinit = h->Qdepth;
2573 static inline unsigned int make_status_bytes(unsigned int scsi_status_byte,
2574 unsigned int msg_byte, unsigned int host_byte,
2575 unsigned int driver_byte)
2577 /* inverse of macros in scsi.h */
2578 return (scsi_status_byte & 0xff) |
2579 ((msg_byte & 0xff) << 8) |
2580 ((host_byte & 0xff) << 16) |
2581 ((driver_byte & 0xff) << 24);
2584 static inline int evaluate_target_status(CommandList_struct *cmd)
2586 unsigned char sense_key;
2587 unsigned char status_byte, msg_byte, host_byte, driver_byte;
2590 /* If we get in here, it means we got "target status", that is, scsi status */
2591 status_byte = cmd->err_info->ScsiStatus;
2592 driver_byte = DRIVER_OK;
2593 msg_byte = cmd->err_info->CommandStatus; /* correct? seems too device specific */
2595 if (blk_pc_request(cmd->rq))
2596 host_byte = DID_PASSTHROUGH;
2600 error_value = make_status_bytes(status_byte, msg_byte,
2601 host_byte, driver_byte);
2603 if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
2604 if (!blk_pc_request(cmd->rq))
2605 printk(KERN_WARNING "cciss: cmd %p "
2606 "has SCSI Status 0x%x\n",
2607 cmd, cmd->err_info->ScsiStatus);
2611 /* check the sense key */
2612 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2613 /* no status or recovered error */
2614 if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
2617 if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
2618 if (error_value != 0)
2619 printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
2620 " sense key = 0x%x\n", cmd, sense_key);
2624 /* SG_IO or similar, copy sense data back */
2625 if (cmd->rq->sense) {
2626 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
2627 cmd->rq->sense_len = cmd->err_info->SenseLen;
2628 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
2629 cmd->rq->sense_len);
2631 cmd->rq->sense_len = 0;
2636 /* checks the status of the job and calls complete buffers to mark all
2637 * buffers for the completed job. Note that this function does not need
2638 * to hold the hba/queue lock.
2640 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2644 struct request *rq = cmd->rq;
2649 rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT);
2651 if (cmd->err_info->CommandStatus == 0) /* no error has occurred */
2652 goto after_error_processing;
2654 switch (cmd->err_info->CommandStatus) {
2655 case CMD_TARGET_STATUS:
2656 rq->errors = evaluate_target_status(cmd);
2658 case CMD_DATA_UNDERRUN:
2659 if (blk_fs_request(cmd->rq)) {
2660 printk(KERN_WARNING "cciss: cmd %p has"
2661 " completed with data underrun "
2663 cmd->rq->data_len = cmd->err_info->ResidualCnt;
2666 case CMD_DATA_OVERRUN:
2667 if (blk_fs_request(cmd->rq))
2668 printk(KERN_WARNING "cciss: cmd %p has"
2669 " completed with data overrun "
2673 printk(KERN_WARNING "cciss: cmd %p is "
2674 "reported invalid\n", cmd);
2675 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2676 cmd->err_info->CommandStatus, DRIVER_OK,
2677 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2679 case CMD_PROTOCOL_ERR:
2680 printk(KERN_WARNING "cciss: cmd %p has "
2681 "protocol error \n", cmd);
2682 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2683 cmd->err_info->CommandStatus, DRIVER_OK,
2684 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2686 case CMD_HARDWARE_ERR:
2687 printk(KERN_WARNING "cciss: cmd %p had "
2688 " hardware error\n", cmd);
2689 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2690 cmd->err_info->CommandStatus, DRIVER_OK,
2691 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2693 case CMD_CONNECTION_LOST:
2694 printk(KERN_WARNING "cciss: cmd %p had "
2695 "connection lost\n", cmd);
2696 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2697 cmd->err_info->CommandStatus, DRIVER_OK,
2698 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2701 printk(KERN_WARNING "cciss: cmd %p was "
2703 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2704 cmd->err_info->CommandStatus, DRIVER_OK,
2705 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2707 case CMD_ABORT_FAILED:
2708 printk(KERN_WARNING "cciss: cmd %p reports "
2709 "abort failed\n", cmd);
2710 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2711 cmd->err_info->CommandStatus, DRIVER_OK,
2712 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2714 case CMD_UNSOLICITED_ABORT:
2715 printk(KERN_WARNING "cciss%d: unsolicited "
2716 "abort %p\n", h->ctlr, cmd);
2717 if (cmd->retry_count < MAX_CMD_RETRIES) {
2720 "cciss%d: retrying %p\n", h->ctlr, cmd);
2724 "cciss%d: %p retried too "
2725 "many times\n", h->ctlr, cmd);
2726 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2727 cmd->err_info->CommandStatus, DRIVER_OK,
2728 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2731 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2732 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2733 cmd->err_info->CommandStatus, DRIVER_OK,
2734 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2737 printk(KERN_WARNING "cciss: cmd %p returned "
2738 "unknown status %x\n", cmd,
2739 cmd->err_info->CommandStatus);
2740 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2741 cmd->err_info->CommandStatus, DRIVER_OK,
2742 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2745 after_error_processing:
2747 /* We need to return this command */
2749 resend_cciss_cmd(h, cmd);
2752 cmd->rq->completion_data = cmd;
2753 blk_complete_request(cmd->rq);
2757 * Get a request and submit it to the controller.
2759 static void do_cciss_request(struct request_queue *q)
2761 ctlr_info_t *h = q->queuedata;
2762 CommandList_struct *c;
2765 struct request *creq;
2767 struct scatterlist tmp_sg[MAXSGENTRIES];
2768 drive_info_struct *drv;
2771 /* We call start_io here in case there is a command waiting on the
2772 * queue that has not been sent.
2774 if (blk_queue_plugged(q))
2778 creq = elv_next_request(q);
2782 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2784 if ((c = cmd_alloc(h, 1)) == NULL)
2787 blkdev_dequeue_request(creq);
2789 spin_unlock_irq(q->queue_lock);
2791 c->cmd_type = CMD_RWREQ;
2794 /* fill in the request */
2795 drv = creq->rq_disk->private_data;
2796 c->Header.ReplyQueue = 0; // unused in simple mode
2797 /* got command from pool, so use the command block index instead */
2798 /* for direct lookups. */
2799 /* The first 2 bits are reserved for controller error reporting. */
2800 c->Header.Tag.lower = (c->cmdindex << 3);
2801 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2802 c->Header.LUN.LogDev.VolId = drv->LunID;
2803 c->Header.LUN.LogDev.Mode = 1;
2804 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2805 c->Request.Type.Type = TYPE_CMD; // It is a command.
2806 c->Request.Type.Attribute = ATTR_SIMPLE;
2807 c->Request.Type.Direction =
2808 (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
2809 c->Request.Timeout = 0; // Don't time out
2811 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2812 start_blk = creq->sector;
2814 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2815 (int)creq->nr_sectors);
2816 #endif /* CCISS_DEBUG */
2818 sg_init_table(tmp_sg, MAXSGENTRIES);
2819 seg = blk_rq_map_sg(q, creq, tmp_sg);
2821 /* get the DMA records for the setup */
2822 if (c->Request.Type.Direction == XFER_READ)
2823 dir = PCI_DMA_FROMDEVICE;
2825 dir = PCI_DMA_TODEVICE;
2827 for (i = 0; i < seg; i++) {
2828 c->SG[i].Len = tmp_sg[i].length;
2829 temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]),
2831 tmp_sg[i].length, dir);
2832 c->SG[i].Addr.lower = temp64.val32.lower;
2833 c->SG[i].Addr.upper = temp64.val32.upper;
2834 c->SG[i].Ext = 0; // we are not chaining
2836 /* track how many SG entries we are using */
2841 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2842 creq->nr_sectors, seg);
2843 #endif /* CCISS_DEBUG */
2845 c->Header.SGList = c->Header.SGTotal = seg;
2846 if (likely(blk_fs_request(creq))) {
2847 if(h->cciss_read == CCISS_READ_10) {
2848 c->Request.CDB[1] = 0;
2849 c->Request.CDB[2] = (start_blk >> 24) & 0xff; //MSB
2850 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2851 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2852 c->Request.CDB[5] = start_blk & 0xff;
2853 c->Request.CDB[6] = 0; // (sect >> 24) & 0xff; MSB
2854 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2855 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2856 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2858 u32 upper32 = upper_32_bits(start_blk);
2860 c->Request.CDBLen = 16;
2861 c->Request.CDB[1]= 0;
2862 c->Request.CDB[2]= (upper32 >> 24) & 0xff; //MSB
2863 c->Request.CDB[3]= (upper32 >> 16) & 0xff;
2864 c->Request.CDB[4]= (upper32 >> 8) & 0xff;
2865 c->Request.CDB[5]= upper32 & 0xff;
2866 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2867 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2868 c->Request.CDB[8]= (start_blk >> 8) & 0xff;
2869 c->Request.CDB[9]= start_blk & 0xff;
2870 c->Request.CDB[10]= (creq->nr_sectors >> 24) & 0xff;
2871 c->Request.CDB[11]= (creq->nr_sectors >> 16) & 0xff;
2872 c->Request.CDB[12]= (creq->nr_sectors >> 8) & 0xff;
2873 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2874 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2876 } else if (blk_pc_request(creq)) {
2877 c->Request.CDBLen = creq->cmd_len;
2878 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
2880 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
2884 spin_lock_irq(q->queue_lock);
2886 addQ(&(h->reqQ), c);
2888 if (h->Qdepth > h->maxQsinceinit)
2889 h->maxQsinceinit = h->Qdepth;
2895 /* We will already have the driver lock here so not need
2901 static inline unsigned long get_next_completion(ctlr_info_t *h)
2903 #ifdef CONFIG_CISS_SCSI_TAPE
2904 /* Any rejects from sendcmd() lying around? Process them first */
2905 if (h->scsi_rejects.ncompletions == 0)
2906 return h->access.command_completed(h);
2908 struct sendcmd_reject_list *srl;
2910 srl = &h->scsi_rejects;
2911 n = --srl->ncompletions;
2912 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2914 return srl->complete[n];
2917 return h->access.command_completed(h);
2921 static inline int interrupt_pending(ctlr_info_t *h)
2923 #ifdef CONFIG_CISS_SCSI_TAPE
2924 return (h->access.intr_pending(h)
2925 || (h->scsi_rejects.ncompletions > 0));
2927 return h->access.intr_pending(h);
2931 static inline long interrupt_not_for_us(ctlr_info_t *h)
2933 #ifdef CONFIG_CISS_SCSI_TAPE
2934 return (((h->access.intr_pending(h) == 0) ||
2935 (h->interrupts_enabled == 0))
2936 && (h->scsi_rejects.ncompletions == 0));
2938 return (((h->access.intr_pending(h) == 0) ||
2939 (h->interrupts_enabled == 0)));
2943 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2945 ctlr_info_t *h = dev_id;
2946 CommandList_struct *c;
2947 unsigned long flags;
2950 if (interrupt_not_for_us(h))
2953 * If there are completed commands in the completion queue,
2954 * we had better do something about it.
2956 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2957 while (interrupt_pending(h)) {
2958 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2962 if (a2 >= h->nr_cmds) {
2964 "cciss: controller cciss%d failed, stopping.\n",
2966 fail_all_cmds(h->ctlr);
2970 c = h->cmd_pool + a2;
2975 if ((c = h->cmpQ) == NULL) {
2977 "cciss: Completion of %08x ignored\n",
2981 while (c->busaddr != a) {
2988 * If we've found the command, take it off the
2989 * completion Q and free it
2991 if (c->busaddr == a) {
2992 removeQ(&h->cmpQ, c);
2993 if (c->cmd_type == CMD_RWREQ) {
2994 complete_command(h, c, 0);
2995 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2996 complete(c->waiting);
2998 # ifdef CONFIG_CISS_SCSI_TAPE
2999 else if (c->cmd_type == CMD_SCSI)
3000 complete_scsi_command(c, 0, a1);
3007 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
3012 * We cannot read the structure directly, for portability we must use
3014 * This is for debug only.
3017 static void print_cfg_table(CfgTable_struct *tb)
3022 printk("Controller Configuration information\n");
3023 printk("------------------------------------\n");
3024 for (i = 0; i < 4; i++)
3025 temp_name[i] = readb(&(tb->Signature[i]));
3026 temp_name[4] = '\0';
3027 printk(" Signature = %s\n", temp_name);
3028 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
3029 printk(" Transport methods supported = 0x%x\n",
3030 readl(&(tb->TransportSupport)));
3031 printk(" Transport methods active = 0x%x\n",
3032 readl(&(tb->TransportActive)));
3033 printk(" Requested transport Method = 0x%x\n",
3034 readl(&(tb->HostWrite.TransportRequest)));
3035 printk(" Coalesce Interrupt Delay = 0x%x\n",
3036 readl(&(tb->HostWrite.CoalIntDelay)));
3037 printk(" Coalesce Interrupt Count = 0x%x\n",
3038 readl(&(tb->HostWrite.CoalIntCount)));
3039 printk(" Max outstanding commands = 0x%d\n",
3040 readl(&(tb->CmdsOutMax)));
3041 printk(" Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
3042 for (i = 0; i < 16; i++)
3043 temp_name[i] = readb(&(tb->ServerName[i]));
3044 temp_name[16] = '\0';
3045 printk(" Server Name = %s\n", temp_name);
3046 printk(" Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
3048 #endif /* CCISS_DEBUG */
3050 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
3052 int i, offset, mem_type, bar_type;
3053 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
3056 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
3057 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
3058 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
3061 mem_type = pci_resource_flags(pdev, i) &
3062 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
3064 case PCI_BASE_ADDRESS_MEM_TYPE_32:
3065 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
3066 offset += 4; /* 32 bit */
3068 case PCI_BASE_ADDRESS_MEM_TYPE_64:
3071 default: /* reserved in PCI 2.2 */
3073 "Base address is invalid\n");
3078 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
3084 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
3085 * controllers that are capable. If not, we use IO-APIC mode.
3088 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
3089 struct pci_dev *pdev, __u32 board_id)
3091 #ifdef CONFIG_PCI_MSI
3093 struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
3097 /* Some boards advertise MSI but don't really support it */
3098 if ((board_id == 0x40700E11) ||
3099 (board_id == 0x40800E11) ||
3100 (board_id == 0x40820E11) || (board_id == 0x40830E11))
3101 goto default_int_mode;
3103 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
3104 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
3106 c->intr[0] = cciss_msix_entries[0].vector;
3107 c->intr[1] = cciss_msix_entries[1].vector;
3108 c->intr[2] = cciss_msix_entries[2].vector;
3109 c->intr[3] = cciss_msix_entries[3].vector;
3114 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
3115 "available\n", err);
3116 goto default_int_mode;
3118 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
3120 goto default_int_mode;
3123 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
3124 if (!pci_enable_msi(pdev)) {
3127 printk(KERN_WARNING "cciss: MSI init failed\n");
3131 #endif /* CONFIG_PCI_MSI */
3132 /* if we get here we're going to use the default interrupt mode */
3133 c->intr[SIMPLE_MODE_INT] = pdev->irq;
3137 static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
3139 ushort subsystem_vendor_id, subsystem_device_id, command;
3140 __u32 board_id, scratchpad = 0;
3142 __u32 cfg_base_addr;
3143 __u64 cfg_base_addr_index;
3146 /* check to see if controller has been disabled */
3147 /* BEFORE trying to enable it */
3148 (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
3149 if (!(command & 0x02)) {
3151 "cciss: controller appears to be disabled\n");
3155 err = pci_enable_device(pdev);
3157 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
3161 err = pci_request_regions(pdev, "cciss");
3163 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
3168 subsystem_vendor_id = pdev->subsystem_vendor;
3169 subsystem_device_id = pdev->subsystem_device;
3170 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
3171 subsystem_vendor_id);
3174 printk("command = %x\n", command);
3175 printk("irq = %x\n", pdev->irq);
3176 printk("board_id = %x\n", board_id);
3177 #endif /* CCISS_DEBUG */
3179 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
3180 * else we use the IO-APIC interrupt assigned to us by system ROM.
3182 cciss_interrupt_mode(c, pdev, board_id);
3185 * Memory base addr is first addr , the second points to the config
3189 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
3191 printk("address 0 = %x\n", c->paddr);
3192 #endif /* CCISS_DEBUG */
3193 c->vaddr = remap_pci_mem(c->paddr, 0x250);
3195 /* Wait for the board to become ready. (PCI hotplug needs this.)
3196 * We poll for up to 120 secs, once per 100ms. */
3197 for (i = 0; i < 1200; i++) {
3198 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
3199 if (scratchpad == CCISS_FIRMWARE_READY)
3201 set_current_state(TASK_INTERRUPTIBLE);
3202 schedule_timeout(HZ / 10); /* wait 100ms */
3204 if (scratchpad != CCISS_FIRMWARE_READY) {
3205 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
3207 goto err_out_free_res;
3210 /* get the address index number */
3211 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
3212 cfg_base_addr &= (__u32) 0x0000ffff;
3214 printk("cfg base address = %x\n", cfg_base_addr);
3215 #endif /* CCISS_DEBUG */
3216 cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
3218 printk("cfg base address index = %x\n", cfg_base_addr_index);
3219 #endif /* CCISS_DEBUG */
3220 if (cfg_base_addr_index == -1) {
3221 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
3223 goto err_out_free_res;
3226 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
3228 printk("cfg offset = %x\n", cfg_offset);
3229 #endif /* CCISS_DEBUG */
3230 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
3231 cfg_base_addr_index) +
3232 cfg_offset, sizeof(CfgTable_struct));
3233 c->board_id = board_id;
3236 print_cfg_table(c->cfgtable);
3237 #endif /* CCISS_DEBUG */
3239 /* Some controllers support Zero Memory Raid (ZMR).
3240 * When configured in ZMR mode the number of supported
3241 * commands drops to 64. So instead of just setting an
3242 * arbitrary value we make the driver a little smarter.
3243 * We read the config table to tell us how many commands
3244 * are supported on the controller then subtract 4 to
3245 * leave a little room for ioctl calls.
3247 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3248 for (i = 0; i < ARRAY_SIZE(products); i++) {
3249 if (board_id == products[i].board_id) {
3250 c->product_name = products[i].product_name;
3251 c->access = *(products[i].access);
3252 c->nr_cmds = c->max_commands - 4;
3256 if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
3257 (readb(&c->cfgtable->Signature[1]) != 'I') ||
3258 (readb(&c->cfgtable->Signature[2]) != 'S') ||
3259 (readb(&c->cfgtable->Signature[3]) != 'S')) {
3260 printk("Does not appear to be a valid CISS config table\n");
3262 goto err_out_free_res;
3264 /* We didn't find the controller in our list. We know the
3265 * signature is valid. If it's an HP device let's try to
3266 * bind to the device and fire it up. Otherwise we bail.
3268 if (i == ARRAY_SIZE(products)) {
3269 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
3270 c->product_name = products[i-1].product_name;
3271 c->access = *(products[i-1].access);
3272 c->nr_cmds = c->max_commands - 4;
3273 printk(KERN_WARNING "cciss: This is an unknown "
3274 "Smart Array controller.\n"
3275 "cciss: Please update to the latest driver "
3276 "available from www.hp.com.\n");
3278 printk(KERN_WARNING "cciss: Sorry, I don't know how"
3279 " to access the Smart Array controller %08lx\n"
3280 , (unsigned long)board_id);
3282 goto err_out_free_res;
3287 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
3289 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
3291 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
3295 /* Disabling DMA prefetch and refetch for the P600.
3296 * An ASIC bug may result in accesses to invalid memory addresses.
3297 * We've disabled prefetch for some time now. Testing with XEN
3298 * kernels revealed a bug in the refetch if dom0 resides on a P600.
3300 if(board_id == 0x3225103C) {
3303 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
3304 dma_prefetch |= 0x8000;
3305 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
3306 pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch);
3308 pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch);
3312 printk("Trying to put board into Simple mode\n");
3313 #endif /* CCISS_DEBUG */
3314 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3315 /* Update the field, and then ring the doorbell */
3316 writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
3317 writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
3319 /* under certain very rare conditions, this can take awhile.
3320 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
3321 * as we enter this code.) */
3322 for (i = 0; i < MAX_CONFIG_WAIT; i++) {
3323 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3325 /* delay and try again */
3326 set_current_state(TASK_INTERRUPTIBLE);
3327 schedule_timeout(10);
3331 printk(KERN_DEBUG "I counter got to %d %x\n", i,
3332 readl(c->vaddr + SA5_DOORBELL));
3333 #endif /* CCISS_DEBUG */
3335 print_cfg_table(c->cfgtable);
3336 #endif /* CCISS_DEBUG */
3338 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
3339 printk(KERN_WARNING "cciss: unable to get board into"
3342 goto err_out_free_res;
3348 * Deliberately omit pci_disable_device(): it does something nasty to
3349 * Smart Array controllers that pci_enable_device does not undo
3351 pci_release_regions(pdev);
3355 /* Function to find the first free pointer into our hba[] array
3356 * Returns -1 if no free entries are left.
3358 static int alloc_cciss_hba(void)
3362 for (i = 0; i < MAX_CTLR; i++) {
3366 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3373 printk(KERN_WARNING "cciss: This driver supports a maximum"
3374 " of %d controllers.\n", MAX_CTLR);
3377 printk(KERN_ERR "cciss: out of memory.\n");
3381 static void free_hba(int i)
3383 ctlr_info_t *p = hba[i];
3387 for (n = 0; n < CISS_MAX_LUN; n++)
3388 put_disk(p->gendisk[n]);
3393 * This is it. Find all the controllers and register them. I really hate
3394 * stealing all these major device numbers.
3395 * returns the number of block devices registered.
3397 static int __devinit cciss_init_one(struct pci_dev *pdev,
3398 const struct pci_device_id *ent)
3405 i = alloc_cciss_hba();
3409 hba[i]->busy_initializing = 1;
3411 if (cciss_pci_init(hba[i], pdev) != 0)
3414 sprintf(hba[i]->devname, "cciss%d", i);
3416 hba[i]->pdev = pdev;
3418 /* configure PCI DMA stuff */
3419 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3421 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3424 printk(KERN_ERR "cciss: no suitable DMA available\n");
3429 * register with the major number, or get a dynamic major number
3430 * by passing 0 as argument. This is done for greater than
3431 * 8 controller support.
3433 if (i < MAX_CTLR_ORIG)
3434 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3435 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3436 if (rc == -EBUSY || rc == -EINVAL) {
3438 "cciss: Unable to get major number %d for %s "
3439 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3442 if (i >= MAX_CTLR_ORIG)
3446 /* make sure the board interrupts are off */
3447 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3448 if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3449 IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3450 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3451 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3455 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3456 hba[i]->devname, pdev->device, pci_name(pdev),
3457 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3459 hba[i]->cmd_pool_bits =
3460 kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3461 1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3462 hba[i]->cmd_pool = (CommandList_struct *)
3463 pci_alloc_consistent(hba[i]->pdev,
3464 hba[i]->nr_cmds * sizeof(CommandList_struct),
3465 &(hba[i]->cmd_pool_dhandle));
3466 hba[i]->errinfo_pool = (ErrorInfo_struct *)
3467 pci_alloc_consistent(hba[i]->pdev,
3468 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3469 &(hba[i]->errinfo_pool_dhandle));
3470 if ((hba[i]->cmd_pool_bits == NULL)
3471 || (hba[i]->cmd_pool == NULL)
3472 || (hba[i]->errinfo_pool == NULL)) {
3473 printk(KERN_ERR "cciss: out of memory");
3476 #ifdef CONFIG_CISS_SCSI_TAPE
3477 hba[i]->scsi_rejects.complete =
3478 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3479 (hba[i]->nr_cmds + 5), GFP_KERNEL);
3480 if (hba[i]->scsi_rejects.complete == NULL) {
3481 printk(KERN_ERR "cciss: out of memory");
3485 spin_lock_init(&hba[i]->lock);
3487 /* Initialize the pdev driver private data.
3488 have it point to hba[i]. */
3489 pci_set_drvdata(pdev, hba[i]);
3490 /* command and error info recs zeroed out before
3492 memset(hba[i]->cmd_pool_bits, 0,
3493 ((hba[i]->nr_cmds + BITS_PER_LONG -
3494 1) / BITS_PER_LONG) * sizeof(unsigned long));
3496 hba[i]->num_luns = 0;
3497 hba[i]->highest_lun = -1;
3498 for (j = 0; j < CISS_MAX_LUN; j++) {
3499 hba[i]->drv[j].raid_level = -1;
3500 hba[i]->drv[j].queue = NULL;
3501 hba[i]->gendisk[j] = NULL;
3504 cciss_scsi_setup(i);
3506 /* Turn the interrupts on so we can service requests */
3507 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3511 hba[i]->cciss_max_sectors = 2048;
3513 hba[i]->busy_initializing = 0;
3515 rebuild_lun_table(hba[i], 1);
3519 #ifdef CONFIG_CISS_SCSI_TAPE
3520 kfree(hba[i]->scsi_rejects.complete);
3522 kfree(hba[i]->cmd_pool_bits);
3523 if (hba[i]->cmd_pool)
3524 pci_free_consistent(hba[i]->pdev,
3525 hba[i]->nr_cmds * sizeof(CommandList_struct),
3526 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3527 if (hba[i]->errinfo_pool)
3528 pci_free_consistent(hba[i]->pdev,
3529 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3530 hba[i]->errinfo_pool,
3531 hba[i]->errinfo_pool_dhandle);
3532 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3534 unregister_blkdev(hba[i]->major, hba[i]->devname);
3536 hba[i]->busy_initializing = 0;
3537 /* cleanup any queues that may have been initialized */
3538 for (j=0; j <= hba[i]->highest_lun; j++){
3539 drive_info_struct *drv = &(hba[i]->drv[j]);
3541 blk_cleanup_queue(drv->queue);
3544 * Deliberately omit pci_disable_device(): it does something nasty to
3545 * Smart Array controllers that pci_enable_device does not undo
3547 pci_release_regions(pdev);
3548 pci_set_drvdata(pdev, NULL);
3553 static void cciss_shutdown(struct pci_dev *pdev)
3555 ctlr_info_t *tmp_ptr;
3560 tmp_ptr = pci_get_drvdata(pdev);
3561 if (tmp_ptr == NULL)
3567 /* Turn board interrupts off and send the flush cache command */
3568 /* sendcmd will turn off interrupt, and send the flush...
3569 * To write all data in the battery backed cache to disks */
3570 memset(flush_buf, 0, 4);
3571 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3573 if (return_code == IO_OK) {
3574 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
3576 printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
3578 free_irq(hba[i]->intr[2], hba[i]);
3581 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3583 ctlr_info_t *tmp_ptr;
3586 if (pci_get_drvdata(pdev) == NULL) {
3587 printk(KERN_ERR "cciss: Unable to remove device \n");
3590 tmp_ptr = pci_get_drvdata(pdev);
3592 if (hba[i] == NULL) {
3593 printk(KERN_ERR "cciss: device appears to "
3594 "already be removed \n");
3598 remove_proc_entry(hba[i]->devname, proc_cciss);
3599 unregister_blkdev(hba[i]->major, hba[i]->devname);
3601 /* remove it from the disk list */
3602 for (j = 0; j < CISS_MAX_LUN; j++) {
3603 struct gendisk *disk = hba[i]->gendisk[j];
3605 struct request_queue *q = disk->queue;
3607 if (disk->flags & GENHD_FL_UP)
3610 blk_cleanup_queue(q);
3614 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3616 cciss_shutdown(pdev);
3618 #ifdef CONFIG_PCI_MSI
3619 if (hba[i]->msix_vector)
3620 pci_disable_msix(hba[i]->pdev);
3621 else if (hba[i]->msi_vector)
3622 pci_disable_msi(hba[i]->pdev);
3623 #endif /* CONFIG_PCI_MSI */
3625 iounmap(hba[i]->vaddr);
3627 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
3628 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3629 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3630 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3631 kfree(hba[i]->cmd_pool_bits);
3632 #ifdef CONFIG_CISS_SCSI_TAPE
3633 kfree(hba[i]->scsi_rejects.complete);
3636 * Deliberately omit pci_disable_device(): it does something nasty to
3637 * Smart Array controllers that pci_enable_device does not undo
3639 pci_release_regions(pdev);
3640 pci_set_drvdata(pdev, NULL);
3644 static struct pci_driver cciss_pci_driver = {
3646 .probe = cciss_init_one,
3647 .remove = __devexit_p(cciss_remove_one),
3648 .id_table = cciss_pci_device_id, /* id_table */
3649 .shutdown = cciss_shutdown,
3653 * This is it. Register the PCI driver information for the cards we control
3654 * the OS will call our registered routines when it finds one of our cards.
3656 static int __init cciss_init(void)
3658 printk(KERN_INFO DRIVER_NAME "\n");
3660 /* Register for our PCI devices */
3661 return pci_register_driver(&cciss_pci_driver);
3664 static void __exit cciss_cleanup(void)
3668 pci_unregister_driver(&cciss_pci_driver);
3669 /* double check that all controller entrys have been removed */
3670 for (i = 0; i < MAX_CTLR; i++) {
3671 if (hba[i] != NULL) {
3672 printk(KERN_WARNING "cciss: had to remove"
3673 " controller %d\n", i);
3674 cciss_remove_one(hba[i]->pdev);
3677 remove_proc_entry("driver/cciss", NULL);
3680 static void fail_all_cmds(unsigned long ctlr)
3682 /* If we get here, the board is apparently dead. */
3683 ctlr_info_t *h = hba[ctlr];
3684 CommandList_struct *c;
3685 unsigned long flags;
3687 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3688 h->alive = 0; /* the controller apparently died... */
3690 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3692 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3694 /* move everything off the request queue onto the completed queue */
3695 while ((c = h->reqQ) != NULL) {
3696 removeQ(&(h->reqQ), c);
3698 addQ(&(h->cmpQ), c);
3701 /* Now, fail everything on the completed queue with a HW error */
3702 while ((c = h->cmpQ) != NULL) {
3703 removeQ(&h->cmpQ, c);
3704 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3705 if (c->cmd_type == CMD_RWREQ) {
3706 complete_command(h, c, 0);
3707 } else if (c->cmd_type == CMD_IOCTL_PEND)
3708 complete(c->waiting);
3709 #ifdef CONFIG_CISS_SCSI_TAPE
3710 else if (c->cmd_type == CMD_SCSI)
3711 complete_scsi_command(c, 0, 0);
3714 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3718 module_init(cciss_init);
3719 module_exit(cciss_cleanup);