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, struct gendisk *del_disk);
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 cciss_getgeometry(int cntl_num);
175 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
177 static void start_io(ctlr_info_t *h);
178 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
179 unsigned int use_unit_num, unsigned int log_unit,
180 __u8 page_code, unsigned char *scsi3addr, int cmd_type);
181 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
182 unsigned int use_unit_num, unsigned int log_unit,
183 __u8 page_code, int cmd_type);
185 static void fail_all_cmds(unsigned long ctlr);
187 #ifdef CONFIG_PROC_FS
188 static void cciss_procinit(int i);
190 static void cciss_procinit(int i)
193 #endif /* CONFIG_PROC_FS */
196 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
199 static struct block_device_operations cciss_fops = {
200 .owner = THIS_MODULE,
202 .release = cciss_release,
203 .ioctl = cciss_ioctl,
204 .getgeo = cciss_getgeo,
206 .compat_ioctl = cciss_compat_ioctl,
208 .revalidate_disk = cciss_revalidate,
212 * Enqueuing and dequeuing functions for cmdlists.
214 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
218 c->next = c->prev = c;
220 c->prev = (*Qptr)->prev;
222 (*Qptr)->prev->next = c;
227 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
228 CommandList_struct *c)
230 if (c && c->next != c) {
233 c->prev->next = c->next;
234 c->next->prev = c->prev;
241 #include "cciss_scsi.c" /* For SCSI tape support */
243 #define RAID_UNKNOWN 6
245 #ifdef CONFIG_PROC_FS
248 * Report information about this controller.
250 #define ENG_GIG 1000000000
251 #define ENG_GIG_FACTOR (ENG_GIG/512)
252 #define ENGAGE_SCSI "engage scsi"
253 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
257 static struct proc_dir_entry *proc_cciss;
259 static void cciss_seq_show_header(struct seq_file *seq)
261 ctlr_info_t *h = seq->private;
263 seq_printf(seq, "%s: HP %s Controller\n"
264 "Board ID: 0x%08lx\n"
265 "Firmware Version: %c%c%c%c\n"
267 "Logical drives: %d\n"
268 "Current Q depth: %d\n"
269 "Current # commands on controller: %d\n"
270 "Max Q depth since init: %d\n"
271 "Max # commands on controller since init: %d\n"
272 "Max SG entries since init: %d\n",
275 (unsigned long)h->board_id,
276 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
277 h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
279 h->Qdepth, h->commands_outstanding,
280 h->maxQsinceinit, h->max_outstanding, h->maxSG);
282 #ifdef CONFIG_CISS_SCSI_TAPE
283 cciss_seq_tape_report(seq, h->ctlr);
284 #endif /* CONFIG_CISS_SCSI_TAPE */
287 static void *cciss_seq_start(struct seq_file *seq, loff_t *pos)
289 ctlr_info_t *h = seq->private;
290 unsigned ctlr = h->ctlr;
293 /* prevent displaying bogus info during configuration
294 * or deconfiguration of a logical volume
296 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
297 if (h->busy_configuring) {
298 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
299 return ERR_PTR(-EBUSY);
301 h->busy_configuring = 1;
302 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
305 cciss_seq_show_header(seq);
310 static int cciss_seq_show(struct seq_file *seq, void *v)
312 sector_t vol_sz, vol_sz_frac;
313 ctlr_info_t *h = seq->private;
314 unsigned ctlr = h->ctlr;
316 drive_info_struct *drv = &h->drv[*pos];
318 if (*pos > h->highest_lun)
324 vol_sz = drv->nr_blocks;
325 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
327 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
329 if (drv->raid_level > 5)
330 drv->raid_level = RAID_UNKNOWN;
331 seq_printf(seq, "cciss/c%dd%d:"
332 "\t%4u.%02uGB\tRAID %s\n",
333 ctlr, (int) *pos, (int)vol_sz, (int)vol_sz_frac,
334 raid_label[drv->raid_level]);
338 static void *cciss_seq_next(struct seq_file *seq, void *v, loff_t *pos)
340 ctlr_info_t *h = seq->private;
342 if (*pos > h->highest_lun)
349 static void cciss_seq_stop(struct seq_file *seq, void *v)
351 ctlr_info_t *h = seq->private;
353 /* Only reset h->busy_configuring if we succeeded in setting
354 * it during cciss_seq_start. */
355 if (v == ERR_PTR(-EBUSY))
358 h->busy_configuring = 0;
361 static struct seq_operations cciss_seq_ops = {
362 .start = cciss_seq_start,
363 .show = cciss_seq_show,
364 .next = cciss_seq_next,
365 .stop = cciss_seq_stop,
368 static int cciss_seq_open(struct inode *inode, struct file *file)
370 int ret = seq_open(file, &cciss_seq_ops);
371 struct seq_file *seq = file->private_data;
374 seq->private = PDE(inode)->data;
380 cciss_proc_write(struct file *file, const char __user *buf,
381 size_t length, loff_t *ppos)
386 #ifndef CONFIG_CISS_SCSI_TAPE
390 if (!buf || length > PAGE_SIZE - 1)
393 buffer = (char *)__get_free_page(GFP_KERNEL);
398 if (copy_from_user(buffer, buf, length))
400 buffer[length] = '\0';
402 #ifdef CONFIG_CISS_SCSI_TAPE
403 if (strncmp(ENGAGE_SCSI, buffer, sizeof ENGAGE_SCSI - 1) == 0) {
404 struct seq_file *seq = file->private_data;
405 ctlr_info_t *h = seq->private;
408 rc = cciss_engage_scsi(h->ctlr);
414 #endif /* CONFIG_CISS_SCSI_TAPE */
416 /* might be nice to have "disengage" too, but it's not
417 safely possible. (only 1 module use count, lock issues.) */
420 free_page((unsigned long)buffer);
424 static struct file_operations cciss_proc_fops = {
425 .owner = THIS_MODULE,
426 .open = cciss_seq_open,
429 .release = seq_release,
430 .write = cciss_proc_write,
433 static void __devinit cciss_procinit(int i)
435 struct proc_dir_entry *pde;
437 if (proc_cciss == NULL)
438 proc_cciss = proc_mkdir("driver/cciss", NULL);
441 pde = proc_create_data(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP |
443 &cciss_proc_fops, hba[i]);
445 #endif /* CONFIG_PROC_FS */
448 * For operations that cannot sleep, a command block is allocated at init,
449 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
450 * which ones are free or in use. For operations that can wait for kmalloc
451 * to possible sleep, this routine can be called with get_from_pool set to 0.
452 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
454 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
456 CommandList_struct *c;
459 dma_addr_t cmd_dma_handle, err_dma_handle;
461 if (!get_from_pool) {
462 c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
463 sizeof(CommandList_struct), &cmd_dma_handle);
466 memset(c, 0, sizeof(CommandList_struct));
470 c->err_info = (ErrorInfo_struct *)
471 pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
474 if (c->err_info == NULL) {
475 pci_free_consistent(h->pdev,
476 sizeof(CommandList_struct), c, cmd_dma_handle);
479 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
480 } else { /* get it out of the controllers pool */
483 i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
486 } while (test_and_set_bit
487 (i & (BITS_PER_LONG - 1),
488 h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
490 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
493 memset(c, 0, sizeof(CommandList_struct));
494 cmd_dma_handle = h->cmd_pool_dhandle
495 + i * sizeof(CommandList_struct);
496 c->err_info = h->errinfo_pool + i;
497 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
498 err_dma_handle = h->errinfo_pool_dhandle
499 + i * sizeof(ErrorInfo_struct);
505 c->busaddr = (__u32) cmd_dma_handle;
506 temp64.val = (__u64) err_dma_handle;
507 c->ErrDesc.Addr.lower = temp64.val32.lower;
508 c->ErrDesc.Addr.upper = temp64.val32.upper;
509 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
516 * Frees a command block that was previously allocated with cmd_alloc().
518 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
523 if (!got_from_pool) {
524 temp64.val32.lower = c->ErrDesc.Addr.lower;
525 temp64.val32.upper = c->ErrDesc.Addr.upper;
526 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
527 c->err_info, (dma_addr_t) temp64.val);
528 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
529 c, (dma_addr_t) c->busaddr);
532 clear_bit(i & (BITS_PER_LONG - 1),
533 h->cmd_pool_bits + (i / BITS_PER_LONG));
538 static inline ctlr_info_t *get_host(struct gendisk *disk)
540 return disk->queue->queuedata;
543 static inline drive_info_struct *get_drv(struct gendisk *disk)
545 return disk->private_data;
549 * Open. Make sure the device is really there.
551 static int cciss_open(struct inode *inode, struct file *filep)
553 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
554 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
557 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
558 #endif /* CCISS_DEBUG */
560 if (host->busy_initializing || drv->busy_configuring)
563 * Root is allowed to open raw volume zero even if it's not configured
564 * so array config can still work. Root is also allowed to open any
565 * volume that has a LUN ID, so it can issue IOCTL to reread the
566 * disk information. I don't think I really like this
567 * but I'm already using way to many device nodes to claim another one
568 * for "raw controller".
570 if (drv->heads == 0) {
571 if (iminor(inode) != 0) { /* not node 0? */
572 /* if not node 0 make sure it is a partition = 0 */
573 if (iminor(inode) & 0x0f) {
575 /* if it is, make sure we have a LUN ID */
576 } else if (drv->LunID == 0) {
580 if (!capable(CAP_SYS_ADMIN))
591 static int cciss_release(struct inode *inode, struct file *filep)
593 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
594 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
597 printk(KERN_DEBUG "cciss_release %s\n",
598 inode->i_bdev->bd_disk->disk_name);
599 #endif /* CCISS_DEBUG */
608 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
612 ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);
617 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
619 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
622 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
625 case CCISS_GETPCIINFO:
626 case CCISS_GETINTINFO:
627 case CCISS_SETINTINFO:
628 case CCISS_GETNODENAME:
629 case CCISS_SETNODENAME:
630 case CCISS_GETHEARTBEAT:
631 case CCISS_GETBUSTYPES:
632 case CCISS_GETFIRMVER:
633 case CCISS_GETDRIVVER:
634 case CCISS_REVALIDVOLS:
635 case CCISS_DEREGDISK:
636 case CCISS_REGNEWDISK:
638 case CCISS_RESCANDISK:
639 case CCISS_GETLUNINFO:
640 return do_ioctl(f, cmd, arg);
642 case CCISS_PASSTHRU32:
643 return cciss_ioctl32_passthru(f, cmd, arg);
644 case CCISS_BIG_PASSTHRU32:
645 return cciss_ioctl32_big_passthru(f, cmd, arg);
652 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
655 IOCTL32_Command_struct __user *arg32 =
656 (IOCTL32_Command_struct __user *) arg;
657 IOCTL_Command_struct arg64;
658 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
664 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
665 sizeof(arg64.LUN_info));
667 copy_from_user(&arg64.Request, &arg32->Request,
668 sizeof(arg64.Request));
670 copy_from_user(&arg64.error_info, &arg32->error_info,
671 sizeof(arg64.error_info));
672 err |= get_user(arg64.buf_size, &arg32->buf_size);
673 err |= get_user(cp, &arg32->buf);
674 arg64.buf = compat_ptr(cp);
675 err |= copy_to_user(p, &arg64, sizeof(arg64));
680 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
684 copy_in_user(&arg32->error_info, &p->error_info,
685 sizeof(arg32->error_info));
691 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
694 BIG_IOCTL32_Command_struct __user *arg32 =
695 (BIG_IOCTL32_Command_struct __user *) arg;
696 BIG_IOCTL_Command_struct arg64;
697 BIG_IOCTL_Command_struct __user *p =
698 compat_alloc_user_space(sizeof(arg64));
704 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
705 sizeof(arg64.LUN_info));
707 copy_from_user(&arg64.Request, &arg32->Request,
708 sizeof(arg64.Request));
710 copy_from_user(&arg64.error_info, &arg32->error_info,
711 sizeof(arg64.error_info));
712 err |= get_user(arg64.buf_size, &arg32->buf_size);
713 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
714 err |= get_user(cp, &arg32->buf);
715 arg64.buf = compat_ptr(cp);
716 err |= copy_to_user(p, &arg64, sizeof(arg64));
721 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
725 copy_in_user(&arg32->error_info, &p->error_info,
726 sizeof(arg32->error_info));
733 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
735 drive_info_struct *drv = get_drv(bdev->bd_disk);
740 geo->heads = drv->heads;
741 geo->sectors = drv->sectors;
742 geo->cylinders = drv->cylinders;
749 static int cciss_ioctl(struct inode *inode, struct file *filep,
750 unsigned int cmd, unsigned long arg)
752 struct block_device *bdev = inode->i_bdev;
753 struct gendisk *disk = bdev->bd_disk;
754 ctlr_info_t *host = get_host(disk);
755 drive_info_struct *drv = get_drv(disk);
756 int ctlr = host->ctlr;
757 void __user *argp = (void __user *)arg;
760 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
761 #endif /* CCISS_DEBUG */
764 case CCISS_GETPCIINFO:
766 cciss_pci_info_struct pciinfo;
770 pciinfo.domain = pci_domain_nr(host->pdev->bus);
771 pciinfo.bus = host->pdev->bus->number;
772 pciinfo.dev_fn = host->pdev->devfn;
773 pciinfo.board_id = host->board_id;
775 (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
779 case CCISS_GETINTINFO:
781 cciss_coalint_struct intinfo;
785 readl(&host->cfgtable->HostWrite.CoalIntDelay);
787 readl(&host->cfgtable->HostWrite.CoalIntCount);
789 (argp, &intinfo, sizeof(cciss_coalint_struct)))
793 case CCISS_SETINTINFO:
795 cciss_coalint_struct intinfo;
801 if (!capable(CAP_SYS_ADMIN))
804 (&intinfo, argp, sizeof(cciss_coalint_struct)))
806 if ((intinfo.delay == 0) && (intinfo.count == 0))
808 // printk("cciss_ioctl: delay and count cannot be 0\n");
811 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
812 /* Update the field, and then ring the doorbell */
813 writel(intinfo.delay,
814 &(host->cfgtable->HostWrite.CoalIntDelay));
815 writel(intinfo.count,
816 &(host->cfgtable->HostWrite.CoalIntCount));
817 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
819 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
820 if (!(readl(host->vaddr + SA5_DOORBELL)
823 /* delay and try again */
826 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
827 if (i >= MAX_IOCTL_CONFIG_WAIT)
831 case CCISS_GETNODENAME:
833 NodeName_type NodeName;
838 for (i = 0; i < 16; i++)
840 readb(&host->cfgtable->ServerName[i]);
841 if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
845 case CCISS_SETNODENAME:
847 NodeName_type NodeName;
853 if (!capable(CAP_SYS_ADMIN))
857 (NodeName, argp, sizeof(NodeName_type)))
860 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
862 /* Update the field, and then ring the doorbell */
863 for (i = 0; i < 16; i++)
865 &host->cfgtable->ServerName[i]);
867 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
869 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
870 if (!(readl(host->vaddr + SA5_DOORBELL)
873 /* delay and try again */
876 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
877 if (i >= MAX_IOCTL_CONFIG_WAIT)
882 case CCISS_GETHEARTBEAT:
884 Heartbeat_type heartbeat;
888 heartbeat = readl(&host->cfgtable->HeartBeat);
890 (argp, &heartbeat, sizeof(Heartbeat_type)))
894 case CCISS_GETBUSTYPES:
896 BusTypes_type BusTypes;
900 BusTypes = readl(&host->cfgtable->BusTypes);
902 (argp, &BusTypes, sizeof(BusTypes_type)))
906 case CCISS_GETFIRMVER:
908 FirmwareVer_type firmware;
912 memcpy(firmware, host->firm_ver, 4);
915 (argp, firmware, sizeof(FirmwareVer_type)))
919 case CCISS_GETDRIVVER:
921 DriverVer_type DriverVer = DRIVER_VERSION;
927 (argp, &DriverVer, sizeof(DriverVer_type)))
932 case CCISS_REVALIDVOLS:
933 return rebuild_lun_table(host, NULL);
935 case CCISS_GETLUNINFO:{
936 LogvolInfo_struct luninfo;
938 luninfo.LunID = drv->LunID;
939 luninfo.num_opens = drv->usage_count;
940 luninfo.num_parts = 0;
941 if (copy_to_user(argp, &luninfo,
942 sizeof(LogvolInfo_struct)))
946 case CCISS_DEREGDISK:
947 return rebuild_lun_table(host, disk);
950 return rebuild_lun_table(host, NULL);
954 IOCTL_Command_struct iocommand;
955 CommandList_struct *c;
959 DECLARE_COMPLETION_ONSTACK(wait);
964 if (!capable(CAP_SYS_RAWIO))
968 (&iocommand, argp, sizeof(IOCTL_Command_struct)))
970 if ((iocommand.buf_size < 1) &&
971 (iocommand.Request.Type.Direction != XFER_NONE)) {
974 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
975 /* Check kmalloc limits */
976 if (iocommand.buf_size > 128000)
979 if (iocommand.buf_size > 0) {
980 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
984 if (iocommand.Request.Type.Direction == XFER_WRITE) {
985 /* Copy the data into the buffer we created */
987 (buff, iocommand.buf, iocommand.buf_size)) {
992 memset(buff, 0, iocommand.buf_size);
994 if ((c = cmd_alloc(host, 0)) == NULL) {
998 // Fill in the command type
999 c->cmd_type = CMD_IOCTL_PEND;
1000 // Fill in Command Header
1001 c->Header.ReplyQueue = 0; // unused in simple mode
1002 if (iocommand.buf_size > 0) // buffer to fill
1004 c->Header.SGList = 1;
1005 c->Header.SGTotal = 1;
1006 } else // no buffers to fill
1008 c->Header.SGList = 0;
1009 c->Header.SGTotal = 0;
1011 c->Header.LUN = iocommand.LUN_info;
1012 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
1014 // Fill in Request block
1015 c->Request = iocommand.Request;
1017 // Fill in the scatter gather information
1018 if (iocommand.buf_size > 0) {
1019 temp64.val = pci_map_single(host->pdev, buff,
1021 PCI_DMA_BIDIRECTIONAL);
1022 c->SG[0].Addr.lower = temp64.val32.lower;
1023 c->SG[0].Addr.upper = temp64.val32.upper;
1024 c->SG[0].Len = iocommand.buf_size;
1025 c->SG[0].Ext = 0; // we are not chaining
1029 /* Put the request on the tail of the request queue */
1030 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1031 addQ(&host->reqQ, c);
1034 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1036 wait_for_completion(&wait);
1038 /* unlock the buffers from DMA */
1039 temp64.val32.lower = c->SG[0].Addr.lower;
1040 temp64.val32.upper = c->SG[0].Addr.upper;
1041 pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
1043 PCI_DMA_BIDIRECTIONAL);
1045 /* Copy the error information out */
1046 iocommand.error_info = *(c->err_info);
1048 (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
1050 cmd_free(host, c, 0);
1054 if (iocommand.Request.Type.Direction == XFER_READ) {
1055 /* Copy the data out of the buffer we created */
1057 (iocommand.buf, buff, iocommand.buf_size)) {
1059 cmd_free(host, c, 0);
1064 cmd_free(host, c, 0);
1067 case CCISS_BIG_PASSTHRU:{
1068 BIG_IOCTL_Command_struct *ioc;
1069 CommandList_struct *c;
1070 unsigned char **buff = NULL;
1071 int *buff_size = NULL;
1073 unsigned long flags;
1077 DECLARE_COMPLETION_ONSTACK(wait);
1080 BYTE __user *data_ptr;
1084 if (!capable(CAP_SYS_RAWIO))
1086 ioc = (BIG_IOCTL_Command_struct *)
1087 kmalloc(sizeof(*ioc), GFP_KERNEL);
1092 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
1096 if ((ioc->buf_size < 1) &&
1097 (ioc->Request.Type.Direction != XFER_NONE)) {
1101 /* Check kmalloc limits using all SGs */
1102 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
1106 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1111 kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1116 buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
1122 left = ioc->buf_size;
1123 data_ptr = ioc->buf;
1126 ioc->malloc_size) ? ioc->
1128 buff_size[sg_used] = sz;
1129 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1130 if (buff[sg_used] == NULL) {
1134 if (ioc->Request.Type.Direction == XFER_WRITE) {
1136 (buff[sg_used], data_ptr, sz)) {
1141 memset(buff[sg_used], 0, sz);
1147 if ((c = cmd_alloc(host, 0)) == NULL) {
1151 c->cmd_type = CMD_IOCTL_PEND;
1152 c->Header.ReplyQueue = 0;
1154 if (ioc->buf_size > 0) {
1155 c->Header.SGList = sg_used;
1156 c->Header.SGTotal = sg_used;
1158 c->Header.SGList = 0;
1159 c->Header.SGTotal = 0;
1161 c->Header.LUN = ioc->LUN_info;
1162 c->Header.Tag.lower = c->busaddr;
1164 c->Request = ioc->Request;
1165 if (ioc->buf_size > 0) {
1167 for (i = 0; i < sg_used; i++) {
1169 pci_map_single(host->pdev, buff[i],
1171 PCI_DMA_BIDIRECTIONAL);
1172 c->SG[i].Addr.lower =
1174 c->SG[i].Addr.upper =
1176 c->SG[i].Len = buff_size[i];
1177 c->SG[i].Ext = 0; /* we are not chaining */
1181 /* Put the request on the tail of the request queue */
1182 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1183 addQ(&host->reqQ, c);
1186 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1187 wait_for_completion(&wait);
1188 /* unlock the buffers from DMA */
1189 for (i = 0; i < sg_used; i++) {
1190 temp64.val32.lower = c->SG[i].Addr.lower;
1191 temp64.val32.upper = c->SG[i].Addr.upper;
1192 pci_unmap_single(host->pdev,
1193 (dma_addr_t) temp64.val, buff_size[i],
1194 PCI_DMA_BIDIRECTIONAL);
1196 /* Copy the error information out */
1197 ioc->error_info = *(c->err_info);
1198 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1199 cmd_free(host, c, 0);
1203 if (ioc->Request.Type.Direction == XFER_READ) {
1204 /* Copy the data out of the buffer we created */
1205 BYTE __user *ptr = ioc->buf;
1206 for (i = 0; i < sg_used; i++) {
1208 (ptr, buff[i], buff_size[i])) {
1209 cmd_free(host, c, 0);
1213 ptr += buff_size[i];
1216 cmd_free(host, c, 0);
1220 for (i = 0; i < sg_used; i++)
1229 /* scsi_cmd_ioctl handles these, below, though some are not */
1230 /* very meaningful for cciss. SG_IO is the main one people want. */
1232 case SG_GET_VERSION_NUM:
1233 case SG_SET_TIMEOUT:
1234 case SG_GET_TIMEOUT:
1235 case SG_GET_RESERVED_SIZE:
1236 case SG_SET_RESERVED_SIZE:
1237 case SG_EMULATED_HOST:
1239 case SCSI_IOCTL_SEND_COMMAND:
1240 return scsi_cmd_ioctl(filep, disk->queue, disk, cmd, argp);
1242 /* scsi_cmd_ioctl would normally handle these, below, but */
1243 /* they aren't a good fit for cciss, as CD-ROMs are */
1244 /* not supported, and we don't have any bus/target/lun */
1245 /* which we present to the kernel. */
1247 case CDROM_SEND_PACKET:
1248 case CDROMCLOSETRAY:
1250 case SCSI_IOCTL_GET_IDLUN:
1251 case SCSI_IOCTL_GET_BUS_NUMBER:
1257 static void cciss_check_queues(ctlr_info_t *h)
1259 int start_queue = h->next_to_run;
1262 /* check to see if we have maxed out the number of commands that can
1263 * be placed on the queue. If so then exit. We do this check here
1264 * in case the interrupt we serviced was from an ioctl and did not
1265 * free any new commands.
1267 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
1270 /* We have room on the queue for more commands. Now we need to queue
1271 * them up. We will also keep track of the next queue to run so
1272 * that every queue gets a chance to be started first.
1274 for (i = 0; i < h->highest_lun + 1; i++) {
1275 int curr_queue = (start_queue + i) % (h->highest_lun + 1);
1276 /* make sure the disk has been added and the drive is real
1277 * because this can be called from the middle of init_one.
1279 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
1281 blk_start_queue(h->gendisk[curr_queue]->queue);
1283 /* check to see if we have maxed out the number of commands
1284 * that can be placed on the queue.
1286 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
1287 if (curr_queue == start_queue) {
1289 (start_queue + 1) % (h->highest_lun + 1);
1292 h->next_to_run = curr_queue;
1299 static void cciss_softirq_done(struct request *rq)
1301 CommandList_struct *cmd = rq->completion_data;
1302 ctlr_info_t *h = hba[cmd->ctlr];
1303 unsigned long flags;
1307 if (cmd->Request.Type.Direction == XFER_READ)
1308 ddir = PCI_DMA_FROMDEVICE;
1310 ddir = PCI_DMA_TODEVICE;
1312 /* command did not need to be retried */
1313 /* unmap the DMA mapping for all the scatter gather elements */
1314 for (i = 0; i < cmd->Header.SGList; i++) {
1315 temp64.val32.lower = cmd->SG[i].Addr.lower;
1316 temp64.val32.upper = cmd->SG[i].Addr.upper;
1317 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1321 printk("Done with %p\n", rq);
1322 #endif /* CCISS_DEBUG */
1324 if (blk_end_request(rq, (rq->errors == 0) ? 0 : -EIO, blk_rq_bytes(rq)))
1327 spin_lock_irqsave(&h->lock, flags);
1328 cmd_free(h, cmd, 1);
1329 cciss_check_queues(h);
1330 spin_unlock_irqrestore(&h->lock, flags);
1333 /* This function gets the serial number of a logical drive via
1334 * inquiry page 0x83. Serial no. is 16 bytes. If the serial
1335 * number cannot be had, for whatever reason, 16 bytes of 0xff
1336 * are returned instead.
1338 static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
1339 unsigned char *serial_no, int buflen)
1341 #define PAGE_83_INQ_BYTES 64
1347 memset(serial_no, 0xff, buflen);
1348 buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
1351 memset(serial_no, 0, buflen);
1353 rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
1354 PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
1356 rc = sendcmd(CISS_INQUIRY, ctlr, buf,
1357 PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
1359 memcpy(serial_no, &buf[8], buflen);
1364 /* This function will check the usage_count of the drive to be updated/added.
1365 * If the usage_count is zero and it is a heretofore unknown drive, or,
1366 * the drive's capacity, geometry, or serial number has changed,
1367 * then the drive information will be updated and the disk will be
1368 * re-registered with the kernel. If these conditions don't hold,
1369 * then it will be left alone for the next reboot. The exception to this
1370 * is disk 0 which will always be left registered with the kernel since it
1371 * is also the controller node. Any changes to disk 0 will show up on
1374 static void cciss_update_drive_info(int ctlr, int drv_index)
1376 ctlr_info_t *h = hba[ctlr];
1377 struct gendisk *disk;
1378 InquiryData_struct *inq_buff = NULL;
1379 unsigned int block_size;
1380 sector_t total_size;
1381 unsigned long flags = 0;
1383 drive_info_struct *drvinfo;
1385 /* Get information about the disk and modify the driver structure */
1386 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1387 drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL);
1388 if (inq_buff == NULL || drvinfo == NULL)
1391 /* testing to see if 16-byte CDBs are already being used */
1392 if (h->cciss_read == CCISS_READ_16) {
1393 cciss_read_capacity_16(h->ctlr, drv_index, 1,
1394 &total_size, &block_size);
1397 cciss_read_capacity(ctlr, drv_index, 1,
1398 &total_size, &block_size);
1400 /* if read_capacity returns all F's this volume is >2TB */
1401 /* in size so we switch to 16-byte CDB's for all */
1402 /* read/write ops */
1403 if (total_size == 0xFFFFFFFFULL) {
1404 cciss_read_capacity_16(ctlr, drv_index, 1,
1405 &total_size, &block_size);
1406 h->cciss_read = CCISS_READ_16;
1407 h->cciss_write = CCISS_WRITE_16;
1409 h->cciss_read = CCISS_READ_10;
1410 h->cciss_write = CCISS_WRITE_10;
1414 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1416 drvinfo->block_size = block_size;
1417 drvinfo->nr_blocks = total_size + 1;
1419 cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
1420 sizeof(drvinfo->serial_no));
1422 /* Is it the same disk we already know, and nothing's changed? */
1423 if (h->drv[drv_index].raid_level != -1 &&
1424 ((memcmp(drvinfo->serial_no,
1425 h->drv[drv_index].serial_no, 16) == 0) &&
1426 drvinfo->block_size == h->drv[drv_index].block_size &&
1427 drvinfo->nr_blocks == h->drv[drv_index].nr_blocks &&
1428 drvinfo->heads == h->drv[drv_index].heads &&
1429 drvinfo->sectors == h->drv[drv_index].sectors &&
1430 drvinfo->cylinders == h->drv[drv_index].cylinders)) {
1431 /* The disk is unchanged, nothing to update */
1435 /* Not the same disk, or something's changed, so we need to */
1436 /* deregister it, and re-register it, if it's not in use. */
1438 /* if the disk already exists then deregister it before proceeding */
1439 /* (unless it's the first disk (for the controller node). */
1440 if (h->drv[drv_index].raid_level != -1 && drv_index != 0) {
1441 printk(KERN_WARNING "disk %d has changed.\n", drv_index);
1442 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1443 h->drv[drv_index].busy_configuring = 1;
1444 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1446 /* deregister_disk sets h->drv[drv_index].queue = NULL */
1447 /* which keeps the interrupt handler from starting */
1449 ret = deregister_disk(h->gendisk[drv_index],
1450 &h->drv[drv_index], 0);
1451 h->drv[drv_index].busy_configuring = 0;
1454 /* If the disk is in use return */
1458 /* Save the new information from cciss_geometry_inquiry */
1459 /* and serial number inquiry. */
1460 h->drv[drv_index].block_size = drvinfo->block_size;
1461 h->drv[drv_index].nr_blocks = drvinfo->nr_blocks;
1462 h->drv[drv_index].heads = drvinfo->heads;
1463 h->drv[drv_index].sectors = drvinfo->sectors;
1464 h->drv[drv_index].cylinders = drvinfo->cylinders;
1465 h->drv[drv_index].raid_level = drvinfo->raid_level;
1466 memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
1469 disk = h->gendisk[drv_index];
1470 set_capacity(disk, h->drv[drv_index].nr_blocks);
1472 /* if it's the controller (if drv_index == 0) it's already added */
1474 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1475 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
1476 disk->major = h->major;
1477 disk->first_minor = drv_index << NWD_SHIFT;
1478 disk->fops = &cciss_fops;
1479 disk->private_data = &h->drv[drv_index];
1481 /* Set up queue information */
1482 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1484 /* This is a hardware imposed limit. */
1485 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1487 /* This is a limit in the driver and could be eliminated. */
1488 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1490 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1492 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1494 disk->queue->queuedata = hba[ctlr];
1496 blk_queue_hardsect_size(disk->queue,
1497 hba[ctlr]->drv[drv_index].block_size);
1499 /* Make sure all queue data is written out before */
1500 /* setting h->drv[drv_index].queue, as setting this */
1501 /* allows the interrupt handler to start the queue */
1503 h->drv[drv_index].queue = disk->queue;
1512 printk(KERN_ERR "cciss: out of memory\n");
1516 /* This function will find the first index of the controllers drive array
1517 * that has a -1 for the raid_level and will return that index. This is
1518 * where new drives will be added. If the index to be returned is greater
1519 * than the highest_lun index for the controller then highest_lun is set
1520 * to this new index. If there are no available indexes then -1 is returned.
1522 static int cciss_find_free_drive_index(int ctlr)
1526 for (i = 0; i < CISS_MAX_LUN; i++) {
1527 if (hba[ctlr]->drv[i].raid_level == -1) {
1528 if (i > hba[ctlr]->highest_lun)
1529 hba[ctlr]->highest_lun = i;
1536 /* This function will add and remove logical drives from the Logical
1537 * drive array of the controller and maintain persistency of ordering
1538 * so that mount points are preserved until the next reboot. This allows
1539 * for the removal of logical drives in the middle of the drive array
1540 * without a re-ordering of those drives.
1542 * h = The controller to perform the operations on
1543 * del_disk = The disk to remove if specified. If the value given
1544 * is NULL then no disk is removed.
1546 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1550 ReportLunData_struct *ld_buff = NULL;
1557 unsigned long flags;
1559 /* Set busy_configuring flag for this operation */
1560 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1561 if (h->busy_configuring) {
1562 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1565 h->busy_configuring = 1;
1566 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1568 if (!capable(CAP_SYS_RAWIO))
1571 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1572 if (ld_buff == NULL)
1575 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1576 sizeof(ReportLunData_struct), 0,
1579 if (return_code == IO_OK)
1580 listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
1581 else { /* reading number of logical volumes failed */
1582 printk(KERN_WARNING "cciss: report logical volume"
1583 " command failed\n");
1588 num_luns = listlength / 8; /* 8 bytes per entry */
1589 if (num_luns > CISS_MAX_LUN) {
1590 num_luns = CISS_MAX_LUN;
1591 printk(KERN_WARNING "cciss: more luns configured"
1592 " on controller than can be handled by"
1596 /* Compare controller drive array to driver's drive array */
1597 /* to see if any drives are missing on the controller due */
1598 /* to action of Array Config Utility (user deletes drive) */
1599 /* and deregister logical drives which have disappeared. */
1600 for (i = 0; i <= h->highest_lun; i++) {
1603 for (j = 0; j < num_luns; j++) {
1604 memcpy(&lunid, &ld_buff->LUN[j][0], 4);
1605 lunid = le32_to_cpu(lunid);
1606 if (h->drv[i].LunID == lunid) {
1612 /* Deregister it from the OS, it's gone. */
1613 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1614 h->drv[i].busy_configuring = 1;
1615 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1616 return_code = deregister_disk(h->gendisk[i],
1618 h->drv[i].busy_configuring = 0;
1622 /* Compare controller drive array to driver's drive array.
1623 * Check for updates in the drive information and any new drives
1624 * on the controller due to ACU adding logical drives, or changing
1625 * a logical drive's size, etc. Reregister any new/changed drives
1627 for (i = 0; i < num_luns; i++) {
1632 memcpy(&lunid, &ld_buff->LUN[i][0], 4);
1633 lunid = le32_to_cpu(lunid);
1635 /* Find if the LUN is already in the drive array
1636 * of the driver. If so then update its info
1637 * if not in use. If it does not exist then find
1638 * the first free index and add it.
1640 for (j = 0; j <= h->highest_lun; j++) {
1641 if (h->drv[j].raid_level != -1 &&
1642 h->drv[j].LunID == lunid) {
1649 /* check if the drive was found already in the array */
1651 drv_index = cciss_find_free_drive_index(ctlr);
1652 if (drv_index == -1)
1654 /*Check if the gendisk needs to be allocated */
1655 if (!h->gendisk[drv_index]) {
1656 h->gendisk[drv_index] =
1657 alloc_disk(1 << NWD_SHIFT);
1658 if (!h->gendisk[drv_index]){
1659 printk(KERN_ERR "cciss: could not "
1660 "allocate new disk %d\n",
1665 h->drv[drv_index].LunID = lunid;
1667 /* Don't need to mark this busy because nobody
1668 * else knows about this disk yet to contend
1671 h->drv[drv_index].busy_configuring = 0;
1675 cciss_update_drive_info(ctlr, drv_index);
1680 h->busy_configuring = 0;
1681 /* We return -1 here to tell the ACU that we have registered/updated
1682 * all of the drives that we can and to keep it from calling us
1687 printk(KERN_ERR "cciss: out of memory\n");
1688 h->busy_configuring = 0;
1692 /* This function will deregister the disk and it's queue from the
1693 * kernel. It must be called with the controller lock held and the
1694 * drv structures busy_configuring flag set. It's parameters are:
1696 * disk = This is the disk to be deregistered
1697 * drv = This is the drive_info_struct associated with the disk to be
1698 * deregistered. It contains information about the disk used
1700 * clear_all = This flag determines whether or not the disk information
1701 * is going to be completely cleared out and the highest_lun
1702 * reset. Sometimes we want to clear out information about
1703 * the disk in preparation for re-adding it. In this case
1704 * the highest_lun should be left unchanged and the LunID
1705 * should not be cleared.
1707 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1711 ctlr_info_t *h = get_host(disk);
1713 if (!capable(CAP_SYS_RAWIO))
1716 /* make sure logical volume is NOT is use */
1717 if (clear_all || (h->gendisk[0] == disk)) {
1718 if (drv->usage_count > 1)
1720 } else if (drv->usage_count > 0)
1723 /* invalidate the devices and deregister the disk. If it is disk
1724 * zero do not deregister it but just zero out it's values. This
1725 * allows us to delete disk zero but keep the controller registered.
1727 if (h->gendisk[0] != disk) {
1728 struct request_queue *q = disk->queue;
1729 if (disk->flags & GENHD_FL_UP)
1732 blk_cleanup_queue(q);
1733 /* Set drv->queue to NULL so that we do not try
1734 * to call blk_start_queue on this queue in the
1739 /* If clear_all is set then we are deleting the logical
1740 * drive, not just refreshing its info. For drives
1741 * other than disk 0 we will call put_disk. We do not
1742 * do this for disk 0 as we need it to be able to
1743 * configure the controller.
1746 /* This isn't pretty, but we need to find the
1747 * disk in our array and NULL our the pointer.
1748 * This is so that we will call alloc_disk if
1749 * this index is used again later.
1751 for (i=0; i < CISS_MAX_LUN; i++){
1752 if (h->gendisk[i] == disk) {
1753 h->gendisk[i] = NULL;
1760 set_capacity(disk, 0);
1764 /* zero out the disk size info */
1766 drv->block_size = 0;
1770 drv->raid_level = -1; /* This can be used as a flag variable to
1771 * indicate that this element of the drive
1776 /* check to see if it was the last disk */
1777 if (drv == h->drv + h->highest_lun) {
1778 /* if so, find the new hightest lun */
1779 int i, newhighest = -1;
1780 for (i = 0; i <= h->highest_lun; i++) {
1781 /* if the disk has size > 0, it is available */
1782 if (h->drv[i].heads)
1785 h->highest_lun = newhighest;
1793 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,
1794 1: address logical volume log_unit,
1795 2: periph device address is scsi3addr */
1796 unsigned int log_unit, __u8 page_code,
1797 unsigned char *scsi3addr, int cmd_type)
1799 ctlr_info_t *h = hba[ctlr];
1800 u64bit buff_dma_handle;
1803 c->cmd_type = CMD_IOCTL_PEND;
1804 c->Header.ReplyQueue = 0;
1806 c->Header.SGList = 1;
1807 c->Header.SGTotal = 1;
1809 c->Header.SGList = 0;
1810 c->Header.SGTotal = 0;
1812 c->Header.Tag.lower = c->busaddr;
1814 c->Request.Type.Type = cmd_type;
1815 if (cmd_type == TYPE_CMD) {
1818 /* If the logical unit number is 0 then, this is going
1819 to controller so It's a physical command
1820 mode = 0 target = 0. So we have nothing to write.
1821 otherwise, if use_unit_num == 1,
1822 mode = 1(volume set addressing) target = LUNID
1823 otherwise, if use_unit_num == 2,
1824 mode = 0(periph dev addr) target = scsi3addr */
1825 if (use_unit_num == 1) {
1826 c->Header.LUN.LogDev.VolId =
1827 h->drv[log_unit].LunID;
1828 c->Header.LUN.LogDev.Mode = 1;
1829 } else if (use_unit_num == 2) {
1830 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1832 c->Header.LUN.LogDev.Mode = 0;
1834 /* are we trying to read a vital product page */
1835 if (page_code != 0) {
1836 c->Request.CDB[1] = 0x01;
1837 c->Request.CDB[2] = page_code;
1839 c->Request.CDBLen = 6;
1840 c->Request.Type.Attribute = ATTR_SIMPLE;
1841 c->Request.Type.Direction = XFER_READ;
1842 c->Request.Timeout = 0;
1843 c->Request.CDB[0] = CISS_INQUIRY;
1844 c->Request.CDB[4] = size & 0xFF;
1846 case CISS_REPORT_LOG:
1847 case CISS_REPORT_PHYS:
1848 /* Talking to controller so It's a physical command
1849 mode = 00 target = 0. Nothing to write.
1851 c->Request.CDBLen = 12;
1852 c->Request.Type.Attribute = ATTR_SIMPLE;
1853 c->Request.Type.Direction = XFER_READ;
1854 c->Request.Timeout = 0;
1855 c->Request.CDB[0] = cmd;
1856 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1857 c->Request.CDB[7] = (size >> 16) & 0xFF;
1858 c->Request.CDB[8] = (size >> 8) & 0xFF;
1859 c->Request.CDB[9] = size & 0xFF;
1862 case CCISS_READ_CAPACITY:
1863 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1864 c->Header.LUN.LogDev.Mode = 1;
1865 c->Request.CDBLen = 10;
1866 c->Request.Type.Attribute = ATTR_SIMPLE;
1867 c->Request.Type.Direction = XFER_READ;
1868 c->Request.Timeout = 0;
1869 c->Request.CDB[0] = cmd;
1871 case CCISS_READ_CAPACITY_16:
1872 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1873 c->Header.LUN.LogDev.Mode = 1;
1874 c->Request.CDBLen = 16;
1875 c->Request.Type.Attribute = ATTR_SIMPLE;
1876 c->Request.Type.Direction = XFER_READ;
1877 c->Request.Timeout = 0;
1878 c->Request.CDB[0] = cmd;
1879 c->Request.CDB[1] = 0x10;
1880 c->Request.CDB[10] = (size >> 24) & 0xFF;
1881 c->Request.CDB[11] = (size >> 16) & 0xFF;
1882 c->Request.CDB[12] = (size >> 8) & 0xFF;
1883 c->Request.CDB[13] = size & 0xFF;
1884 c->Request.Timeout = 0;
1885 c->Request.CDB[0] = cmd;
1887 case CCISS_CACHE_FLUSH:
1888 c->Request.CDBLen = 12;
1889 c->Request.Type.Attribute = ATTR_SIMPLE;
1890 c->Request.Type.Direction = XFER_WRITE;
1891 c->Request.Timeout = 0;
1892 c->Request.CDB[0] = BMIC_WRITE;
1893 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1897 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1900 } else if (cmd_type == TYPE_MSG) {
1902 case 0: /* ABORT message */
1903 c->Request.CDBLen = 12;
1904 c->Request.Type.Attribute = ATTR_SIMPLE;
1905 c->Request.Type.Direction = XFER_WRITE;
1906 c->Request.Timeout = 0;
1907 c->Request.CDB[0] = cmd; /* abort */
1908 c->Request.CDB[1] = 0; /* abort a command */
1909 /* buff contains the tag of the command to abort */
1910 memcpy(&c->Request.CDB[4], buff, 8);
1912 case 1: /* RESET message */
1913 c->Request.CDBLen = 12;
1914 c->Request.Type.Attribute = ATTR_SIMPLE;
1915 c->Request.Type.Direction = XFER_WRITE;
1916 c->Request.Timeout = 0;
1917 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1918 c->Request.CDB[0] = cmd; /* reset */
1919 c->Request.CDB[1] = 0x04; /* reset a LUN */
1921 case 3: /* No-Op message */
1922 c->Request.CDBLen = 1;
1923 c->Request.Type.Attribute = ATTR_SIMPLE;
1924 c->Request.Type.Direction = XFER_WRITE;
1925 c->Request.Timeout = 0;
1926 c->Request.CDB[0] = cmd;
1930 "cciss%d: unknown message type %d\n", ctlr, cmd);
1935 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1938 /* Fill in the scatter gather information */
1940 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1942 PCI_DMA_BIDIRECTIONAL);
1943 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1944 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1945 c->SG[0].Len = size;
1946 c->SG[0].Ext = 0; /* we are not chaining */
1951 static int sendcmd_withirq(__u8 cmd,
1955 unsigned int use_unit_num,
1956 unsigned int log_unit, __u8 page_code, int cmd_type)
1958 ctlr_info_t *h = hba[ctlr];
1959 CommandList_struct *c;
1960 u64bit buff_dma_handle;
1961 unsigned long flags;
1963 DECLARE_COMPLETION_ONSTACK(wait);
1965 if ((c = cmd_alloc(h, 0)) == NULL)
1967 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1968 log_unit, page_code, NULL, cmd_type);
1969 if (return_status != IO_OK) {
1971 return return_status;
1976 /* Put the request on the tail of the queue and send it */
1977 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1981 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1983 wait_for_completion(&wait);
1985 if (c->err_info->CommandStatus != 0) { /* an error has occurred */
1986 switch (c->err_info->CommandStatus) {
1987 case CMD_TARGET_STATUS:
1988 printk(KERN_WARNING "cciss: cmd %p has "
1989 " completed with errors\n", c);
1990 if (c->err_info->ScsiStatus) {
1991 printk(KERN_WARNING "cciss: cmd %p "
1992 "has SCSI Status = %x\n",
1993 c, c->err_info->ScsiStatus);
1997 case CMD_DATA_UNDERRUN:
1998 case CMD_DATA_OVERRUN:
1999 /* expected for inquire and report lun commands */
2002 printk(KERN_WARNING "cciss: Cmd %p is "
2003 "reported invalid\n", c);
2004 return_status = IO_ERROR;
2006 case CMD_PROTOCOL_ERR:
2007 printk(KERN_WARNING "cciss: cmd %p has "
2008 "protocol error \n", c);
2009 return_status = IO_ERROR;
2011 case CMD_HARDWARE_ERR:
2012 printk(KERN_WARNING "cciss: cmd %p had "
2013 " hardware error\n", c);
2014 return_status = IO_ERROR;
2016 case CMD_CONNECTION_LOST:
2017 printk(KERN_WARNING "cciss: cmd %p had "
2018 "connection lost\n", c);
2019 return_status = IO_ERROR;
2022 printk(KERN_WARNING "cciss: cmd %p was "
2024 return_status = IO_ERROR;
2026 case CMD_ABORT_FAILED:
2027 printk(KERN_WARNING "cciss: cmd %p reports "
2028 "abort failed\n", c);
2029 return_status = IO_ERROR;
2031 case CMD_UNSOLICITED_ABORT:
2033 "cciss%d: unsolicited abort %p\n", ctlr, c);
2034 if (c->retry_count < MAX_CMD_RETRIES) {
2036 "cciss%d: retrying %p\n", ctlr, c);
2038 /* erase the old error information */
2039 memset(c->err_info, 0,
2040 sizeof(ErrorInfo_struct));
2041 return_status = IO_OK;
2042 INIT_COMPLETION(wait);
2045 return_status = IO_ERROR;
2048 printk(KERN_WARNING "cciss: cmd %p returned "
2049 "unknown status %x\n", c,
2050 c->err_info->CommandStatus);
2051 return_status = IO_ERROR;
2054 /* unlock the buffers from DMA */
2055 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2056 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2057 pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
2058 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2060 return return_status;
2063 static void cciss_geometry_inquiry(int ctlr, int logvol,
2064 int withirq, sector_t total_size,
2065 unsigned int block_size,
2066 InquiryData_struct *inq_buff,
2067 drive_info_struct *drv)
2072 memset(inq_buff, 0, sizeof(InquiryData_struct));
2074 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
2075 inq_buff, sizeof(*inq_buff), 1,
2076 logvol, 0xC1, TYPE_CMD);
2078 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
2079 sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
2081 if (return_code == IO_OK) {
2082 if (inq_buff->data_byte[8] == 0xFF) {
2084 "cciss: reading geometry failed, volume "
2085 "does not support reading geometry\n");
2087 drv->sectors = 32; // Sectors per track
2088 drv->cylinders = total_size + 1;
2089 drv->raid_level = RAID_UNKNOWN;
2091 drv->heads = inq_buff->data_byte[6];
2092 drv->sectors = inq_buff->data_byte[7];
2093 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
2094 drv->cylinders += inq_buff->data_byte[5];
2095 drv->raid_level = inq_buff->data_byte[8];
2097 drv->block_size = block_size;
2098 drv->nr_blocks = total_size + 1;
2099 t = drv->heads * drv->sectors;
2101 sector_t real_size = total_size + 1;
2102 unsigned long rem = sector_div(real_size, t);
2105 drv->cylinders = real_size;
2107 } else { /* Get geometry failed */
2108 printk(KERN_WARNING "cciss: reading geometry failed\n");
2110 printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n",
2111 drv->heads, drv->sectors, drv->cylinders);
2115 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
2116 unsigned int *block_size)
2118 ReadCapdata_struct *buf;
2121 buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
2123 printk(KERN_WARNING "cciss: out of memory\n");
2128 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
2129 ctlr, buf, sizeof(ReadCapdata_struct),
2130 1, logvol, 0, TYPE_CMD);
2132 return_code = sendcmd(CCISS_READ_CAPACITY,
2133 ctlr, buf, sizeof(ReadCapdata_struct),
2134 1, logvol, 0, NULL, TYPE_CMD);
2135 if (return_code == IO_OK) {
2136 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
2137 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2138 } else { /* read capacity command failed */
2139 printk(KERN_WARNING "cciss: read capacity failed\n");
2141 *block_size = BLOCK_SIZE;
2143 if (*total_size != 0)
2144 printk(KERN_INFO " blocks= %llu block_size= %d\n",
2145 (unsigned long long)*total_size+1, *block_size);
2150 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, unsigned int *block_size)
2152 ReadCapdata_struct_16 *buf;
2155 buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
2157 printk(KERN_WARNING "cciss: out of memory\n");
2162 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2163 ctlr, buf, sizeof(ReadCapdata_struct_16),
2164 1, logvol, 0, TYPE_CMD);
2167 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2168 ctlr, buf, sizeof(ReadCapdata_struct_16),
2169 1, logvol, 0, NULL, TYPE_CMD);
2171 if (return_code == IO_OK) {
2172 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
2173 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2174 } else { /* read capacity command failed */
2175 printk(KERN_WARNING "cciss: read capacity failed\n");
2177 *block_size = BLOCK_SIZE;
2179 printk(KERN_INFO " blocks= %llu block_size= %d\n",
2180 (unsigned long long)*total_size+1, *block_size);
2184 static int cciss_revalidate(struct gendisk *disk)
2186 ctlr_info_t *h = get_host(disk);
2187 drive_info_struct *drv = get_drv(disk);
2190 unsigned int block_size;
2191 sector_t total_size;
2192 InquiryData_struct *inq_buff = NULL;
2194 for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2195 if (h->drv[logvol].LunID == drv->LunID) {
2204 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2205 if (inq_buff == NULL) {
2206 printk(KERN_WARNING "cciss: out of memory\n");
2209 if (h->cciss_read == CCISS_READ_10) {
2210 cciss_read_capacity(h->ctlr, logvol, 1,
2211 &total_size, &block_size);
2213 cciss_read_capacity_16(h->ctlr, logvol, 1,
2214 &total_size, &block_size);
2216 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2219 blk_queue_hardsect_size(drv->queue, drv->block_size);
2220 set_capacity(disk, drv->nr_blocks);
2227 * Wait polling for a command to complete.
2228 * The memory mapped FIFO is polled for the completion.
2229 * Used only at init time, interrupts from the HBA are disabled.
2231 static unsigned long pollcomplete(int ctlr)
2236 /* Wait (up to 20 seconds) for a command to complete */
2238 for (i = 20 * HZ; i > 0; i--) {
2239 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2240 if (done == FIFO_EMPTY)
2241 schedule_timeout_uninterruptible(1);
2245 /* Invalid address to tell caller we ran out of time */
2249 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2251 /* We get in here if sendcmd() is polling for completions
2252 and gets some command back that it wasn't expecting --
2253 something other than that which it just sent down.
2254 Ordinarily, that shouldn't happen, but it can happen when
2255 the scsi tape stuff gets into error handling mode, and
2256 starts using sendcmd() to try to abort commands and
2257 reset tape drives. In that case, sendcmd may pick up
2258 completions of commands that were sent to logical drives
2259 through the block i/o system, or cciss ioctls completing, etc.
2260 In that case, we need to save those completions for later
2261 processing by the interrupt handler.
2264 #ifdef CONFIG_CISS_SCSI_TAPE
2265 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2267 /* If it's not the scsi tape stuff doing error handling, (abort */
2268 /* or reset) then we don't expect anything weird. */
2269 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2271 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2272 "Invalid command list address returned! (%lx)\n",
2274 /* not much we can do. */
2275 #ifdef CONFIG_CISS_SCSI_TAPE
2279 /* We've sent down an abort or reset, but something else
2281 if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2282 /* Uh oh. No room to save it for later... */
2283 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2284 "reject list overflow, command lost!\n", ctlr);
2287 /* Save it for later */
2288 srl->complete[srl->ncompletions] = complete;
2289 srl->ncompletions++;
2295 * Send a command to the controller, and wait for it to complete.
2296 * Only used at init time.
2298 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
2299 1: address logical volume log_unit,
2300 2: periph device address is scsi3addr */
2301 unsigned int log_unit,
2302 __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2304 CommandList_struct *c;
2306 unsigned long complete;
2307 ctlr_info_t *info_p = hba[ctlr];
2308 u64bit buff_dma_handle;
2309 int status, done = 0;
2311 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2312 printk(KERN_WARNING "cciss: unable to get memory");
2315 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2316 log_unit, page_code, scsi3addr, cmd_type);
2317 if (status != IO_OK) {
2318 cmd_free(info_p, c, 1);
2326 printk(KERN_DEBUG "cciss: turning intr off\n");
2327 #endif /* CCISS_DEBUG */
2328 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2330 /* Make sure there is room in the command FIFO */
2331 /* Actually it should be completely empty at this time */
2332 /* unless we are in here doing error handling for the scsi */
2333 /* tape side of the driver. */
2334 for (i = 200000; i > 0; i--) {
2335 /* if fifo isn't full go */
2336 if (!(info_p->access.fifo_full(info_p))) {
2341 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2342 " waiting!\n", ctlr);
2347 info_p->access.submit_command(info_p, c);
2350 complete = pollcomplete(ctlr);
2353 printk(KERN_DEBUG "cciss: command completed\n");
2354 #endif /* CCISS_DEBUG */
2356 if (complete == 1) {
2358 "cciss cciss%d: SendCmd Timeout out, "
2359 "No command list address returned!\n", ctlr);
2365 /* This will need to change for direct lookup completions */
2366 if ((complete & CISS_ERROR_BIT)
2367 && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2368 /* if data overrun or underun on Report command
2371 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2372 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2373 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2374 ((c->err_info->CommandStatus ==
2375 CMD_DATA_OVERRUN) ||
2376 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2378 complete = c->busaddr;
2380 if (c->err_info->CommandStatus ==
2381 CMD_UNSOLICITED_ABORT) {
2382 printk(KERN_WARNING "cciss%d: "
2383 "unsolicited abort %p\n",
2385 if (c->retry_count < MAX_CMD_RETRIES) {
2387 "cciss%d: retrying %p\n",
2390 /* erase the old error */
2392 memset(c->err_info, 0,
2394 (ErrorInfo_struct));
2398 "cciss%d: retried %p too "
2399 "many times\n", ctlr, c);
2403 } else if (c->err_info->CommandStatus ==
2406 "cciss%d: command could not be aborted.\n",
2411 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2412 " Error %x \n", ctlr,
2413 c->err_info->CommandStatus);
2414 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2416 " size %x\n num %x value %x\n",
2418 c->err_info->MoreErrInfo.Invalid_Cmd.
2420 c->err_info->MoreErrInfo.Invalid_Cmd.
2422 c->err_info->MoreErrInfo.Invalid_Cmd.
2428 /* This will need changing for direct lookup completions */
2429 if (complete != c->busaddr) {
2430 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2431 BUG(); /* we are pretty much hosed if we get here. */
2439 /* unlock the data buffer from DMA */
2440 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2441 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2442 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2443 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2444 #ifdef CONFIG_CISS_SCSI_TAPE
2445 /* if we saved some commands for later, process them now. */
2446 if (info_p->scsi_rejects.ncompletions > 0)
2447 do_cciss_intr(0, info_p);
2449 cmd_free(info_p, c, 1);
2454 * Map (physical) PCI mem into (virtual) kernel space
2456 static void __iomem *remap_pci_mem(ulong base, ulong size)
2458 ulong page_base = ((ulong) base) & PAGE_MASK;
2459 ulong page_offs = ((ulong) base) - page_base;
2460 void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2462 return page_remapped ? (page_remapped + page_offs) : NULL;
2466 * Takes jobs of the Q and sends them to the hardware, then puts it on
2467 * the Q to wait for completion.
2469 static void start_io(ctlr_info_t *h)
2471 CommandList_struct *c;
2473 while ((c = h->reqQ) != NULL) {
2474 /* can't do anything if fifo is full */
2475 if ((h->access.fifo_full(h))) {
2476 printk(KERN_WARNING "cciss: fifo full\n");
2480 /* Get the first entry from the Request Q */
2481 removeQ(&(h->reqQ), c);
2484 /* Tell the controller execute command */
2485 h->access.submit_command(h, c);
2487 /* Put job onto the completed Q */
2488 addQ(&(h->cmpQ), c);
2492 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2493 /* Zeros out the error record and then resends the command back */
2494 /* to the controller */
2495 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2497 /* erase the old error information */
2498 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2500 /* add it to software queue and then send it to the controller */
2501 addQ(&(h->reqQ), c);
2503 if (h->Qdepth > h->maxQsinceinit)
2504 h->maxQsinceinit = h->Qdepth;
2509 static inline unsigned int make_status_bytes(unsigned int scsi_status_byte,
2510 unsigned int msg_byte, unsigned int host_byte,
2511 unsigned int driver_byte)
2513 /* inverse of macros in scsi.h */
2514 return (scsi_status_byte & 0xff) |
2515 ((msg_byte & 0xff) << 8) |
2516 ((host_byte & 0xff) << 16) |
2517 ((driver_byte & 0xff) << 24);
2520 static inline int evaluate_target_status(CommandList_struct *cmd)
2522 unsigned char sense_key;
2523 unsigned char status_byte, msg_byte, host_byte, driver_byte;
2526 /* If we get in here, it means we got "target status", that is, scsi status */
2527 status_byte = cmd->err_info->ScsiStatus;
2528 driver_byte = DRIVER_OK;
2529 msg_byte = cmd->err_info->CommandStatus; /* correct? seems too device specific */
2531 if (blk_pc_request(cmd->rq))
2532 host_byte = DID_PASSTHROUGH;
2536 error_value = make_status_bytes(status_byte, msg_byte,
2537 host_byte, driver_byte);
2539 if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
2540 if (!blk_pc_request(cmd->rq))
2541 printk(KERN_WARNING "cciss: cmd %p "
2542 "has SCSI Status 0x%x\n",
2543 cmd, cmd->err_info->ScsiStatus);
2547 /* check the sense key */
2548 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2549 /* no status or recovered error */
2550 if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
2553 if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
2554 if (error_value != 0)
2555 printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
2556 " sense key = 0x%x\n", cmd, sense_key);
2560 /* SG_IO or similar, copy sense data back */
2561 if (cmd->rq->sense) {
2562 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
2563 cmd->rq->sense_len = cmd->err_info->SenseLen;
2564 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
2565 cmd->rq->sense_len);
2567 cmd->rq->sense_len = 0;
2572 /* checks the status of the job and calls complete buffers to mark all
2573 * buffers for the completed job. Note that this function does not need
2574 * to hold the hba/queue lock.
2576 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2580 struct request *rq = cmd->rq;
2585 rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT);
2587 if (cmd->err_info->CommandStatus == 0) /* no error has occurred */
2588 goto after_error_processing;
2590 switch (cmd->err_info->CommandStatus) {
2591 case CMD_TARGET_STATUS:
2592 rq->errors = evaluate_target_status(cmd);
2594 case CMD_DATA_UNDERRUN:
2595 if (blk_fs_request(cmd->rq)) {
2596 printk(KERN_WARNING "cciss: cmd %p has"
2597 " completed with data underrun "
2599 cmd->rq->data_len = cmd->err_info->ResidualCnt;
2602 case CMD_DATA_OVERRUN:
2603 if (blk_fs_request(cmd->rq))
2604 printk(KERN_WARNING "cciss: cmd %p has"
2605 " completed with data overrun "
2609 printk(KERN_WARNING "cciss: cmd %p is "
2610 "reported invalid\n", cmd);
2611 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2612 cmd->err_info->CommandStatus, DRIVER_OK,
2613 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2615 case CMD_PROTOCOL_ERR:
2616 printk(KERN_WARNING "cciss: cmd %p has "
2617 "protocol error \n", cmd);
2618 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2619 cmd->err_info->CommandStatus, DRIVER_OK,
2620 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2622 case CMD_HARDWARE_ERR:
2623 printk(KERN_WARNING "cciss: cmd %p had "
2624 " hardware error\n", cmd);
2625 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2626 cmd->err_info->CommandStatus, DRIVER_OK,
2627 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2629 case CMD_CONNECTION_LOST:
2630 printk(KERN_WARNING "cciss: cmd %p had "
2631 "connection lost\n", cmd);
2632 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2633 cmd->err_info->CommandStatus, DRIVER_OK,
2634 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2637 printk(KERN_WARNING "cciss: cmd %p was "
2639 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2640 cmd->err_info->CommandStatus, DRIVER_OK,
2641 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2643 case CMD_ABORT_FAILED:
2644 printk(KERN_WARNING "cciss: cmd %p reports "
2645 "abort failed\n", cmd);
2646 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2647 cmd->err_info->CommandStatus, DRIVER_OK,
2648 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2650 case CMD_UNSOLICITED_ABORT:
2651 printk(KERN_WARNING "cciss%d: unsolicited "
2652 "abort %p\n", h->ctlr, cmd);
2653 if (cmd->retry_count < MAX_CMD_RETRIES) {
2656 "cciss%d: retrying %p\n", h->ctlr, cmd);
2660 "cciss%d: %p retried too "
2661 "many times\n", h->ctlr, cmd);
2662 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2663 cmd->err_info->CommandStatus, DRIVER_OK,
2664 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2667 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2668 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2669 cmd->err_info->CommandStatus, DRIVER_OK,
2670 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2673 printk(KERN_WARNING "cciss: cmd %p returned "
2674 "unknown status %x\n", cmd,
2675 cmd->err_info->CommandStatus);
2676 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2677 cmd->err_info->CommandStatus, DRIVER_OK,
2678 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2681 after_error_processing:
2683 /* We need to return this command */
2685 resend_cciss_cmd(h, cmd);
2688 cmd->rq->completion_data = cmd;
2689 blk_complete_request(cmd->rq);
2693 * Get a request and submit it to the controller.
2695 static void do_cciss_request(struct request_queue *q)
2697 ctlr_info_t *h = q->queuedata;
2698 CommandList_struct *c;
2701 struct request *creq;
2703 struct scatterlist tmp_sg[MAXSGENTRIES];
2704 drive_info_struct *drv;
2707 /* We call start_io here in case there is a command waiting on the
2708 * queue that has not been sent.
2710 if (blk_queue_plugged(q))
2714 creq = elv_next_request(q);
2718 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2720 if ((c = cmd_alloc(h, 1)) == NULL)
2723 blkdev_dequeue_request(creq);
2725 spin_unlock_irq(q->queue_lock);
2727 c->cmd_type = CMD_RWREQ;
2730 /* fill in the request */
2731 drv = creq->rq_disk->private_data;
2732 c->Header.ReplyQueue = 0; // unused in simple mode
2733 /* got command from pool, so use the command block index instead */
2734 /* for direct lookups. */
2735 /* The first 2 bits are reserved for controller error reporting. */
2736 c->Header.Tag.lower = (c->cmdindex << 3);
2737 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2738 c->Header.LUN.LogDev.VolId = drv->LunID;
2739 c->Header.LUN.LogDev.Mode = 1;
2740 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2741 c->Request.Type.Type = TYPE_CMD; // It is a command.
2742 c->Request.Type.Attribute = ATTR_SIMPLE;
2743 c->Request.Type.Direction =
2744 (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
2745 c->Request.Timeout = 0; // Don't time out
2747 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2748 start_blk = creq->sector;
2750 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2751 (int)creq->nr_sectors);
2752 #endif /* CCISS_DEBUG */
2754 sg_init_table(tmp_sg, MAXSGENTRIES);
2755 seg = blk_rq_map_sg(q, creq, tmp_sg);
2757 /* get the DMA records for the setup */
2758 if (c->Request.Type.Direction == XFER_READ)
2759 dir = PCI_DMA_FROMDEVICE;
2761 dir = PCI_DMA_TODEVICE;
2763 for (i = 0; i < seg; i++) {
2764 c->SG[i].Len = tmp_sg[i].length;
2765 temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]),
2767 tmp_sg[i].length, dir);
2768 c->SG[i].Addr.lower = temp64.val32.lower;
2769 c->SG[i].Addr.upper = temp64.val32.upper;
2770 c->SG[i].Ext = 0; // we are not chaining
2772 /* track how many SG entries we are using */
2777 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2778 creq->nr_sectors, seg);
2779 #endif /* CCISS_DEBUG */
2781 c->Header.SGList = c->Header.SGTotal = seg;
2782 if (likely(blk_fs_request(creq))) {
2783 if(h->cciss_read == CCISS_READ_10) {
2784 c->Request.CDB[1] = 0;
2785 c->Request.CDB[2] = (start_blk >> 24) & 0xff; //MSB
2786 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2787 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2788 c->Request.CDB[5] = start_blk & 0xff;
2789 c->Request.CDB[6] = 0; // (sect >> 24) & 0xff; MSB
2790 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2791 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2792 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2794 u32 upper32 = upper_32_bits(start_blk);
2796 c->Request.CDBLen = 16;
2797 c->Request.CDB[1]= 0;
2798 c->Request.CDB[2]= (upper32 >> 24) & 0xff; //MSB
2799 c->Request.CDB[3]= (upper32 >> 16) & 0xff;
2800 c->Request.CDB[4]= (upper32 >> 8) & 0xff;
2801 c->Request.CDB[5]= upper32 & 0xff;
2802 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2803 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2804 c->Request.CDB[8]= (start_blk >> 8) & 0xff;
2805 c->Request.CDB[9]= start_blk & 0xff;
2806 c->Request.CDB[10]= (creq->nr_sectors >> 24) & 0xff;
2807 c->Request.CDB[11]= (creq->nr_sectors >> 16) & 0xff;
2808 c->Request.CDB[12]= (creq->nr_sectors >> 8) & 0xff;
2809 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2810 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2812 } else if (blk_pc_request(creq)) {
2813 c->Request.CDBLen = creq->cmd_len;
2814 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
2816 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
2820 spin_lock_irq(q->queue_lock);
2822 addQ(&(h->reqQ), c);
2824 if (h->Qdepth > h->maxQsinceinit)
2825 h->maxQsinceinit = h->Qdepth;
2831 /* We will already have the driver lock here so not need
2837 static inline unsigned long get_next_completion(ctlr_info_t *h)
2839 #ifdef CONFIG_CISS_SCSI_TAPE
2840 /* Any rejects from sendcmd() lying around? Process them first */
2841 if (h->scsi_rejects.ncompletions == 0)
2842 return h->access.command_completed(h);
2844 struct sendcmd_reject_list *srl;
2846 srl = &h->scsi_rejects;
2847 n = --srl->ncompletions;
2848 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2850 return srl->complete[n];
2853 return h->access.command_completed(h);
2857 static inline int interrupt_pending(ctlr_info_t *h)
2859 #ifdef CONFIG_CISS_SCSI_TAPE
2860 return (h->access.intr_pending(h)
2861 || (h->scsi_rejects.ncompletions > 0));
2863 return h->access.intr_pending(h);
2867 static inline long interrupt_not_for_us(ctlr_info_t *h)
2869 #ifdef CONFIG_CISS_SCSI_TAPE
2870 return (((h->access.intr_pending(h) == 0) ||
2871 (h->interrupts_enabled == 0))
2872 && (h->scsi_rejects.ncompletions == 0));
2874 return (((h->access.intr_pending(h) == 0) ||
2875 (h->interrupts_enabled == 0)));
2879 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2881 ctlr_info_t *h = dev_id;
2882 CommandList_struct *c;
2883 unsigned long flags;
2886 if (interrupt_not_for_us(h))
2889 * If there are completed commands in the completion queue,
2890 * we had better do something about it.
2892 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2893 while (interrupt_pending(h)) {
2894 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2898 if (a2 >= h->nr_cmds) {
2900 "cciss: controller cciss%d failed, stopping.\n",
2902 fail_all_cmds(h->ctlr);
2906 c = h->cmd_pool + a2;
2911 if ((c = h->cmpQ) == NULL) {
2913 "cciss: Completion of %08x ignored\n",
2917 while (c->busaddr != a) {
2924 * If we've found the command, take it off the
2925 * completion Q and free it
2927 if (c->busaddr == a) {
2928 removeQ(&h->cmpQ, c);
2929 if (c->cmd_type == CMD_RWREQ) {
2930 complete_command(h, c, 0);
2931 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2932 complete(c->waiting);
2934 # ifdef CONFIG_CISS_SCSI_TAPE
2935 else if (c->cmd_type == CMD_SCSI)
2936 complete_scsi_command(c, 0, a1);
2943 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2948 * We cannot read the structure directly, for portability we must use
2950 * This is for debug only.
2953 static void print_cfg_table(CfgTable_struct *tb)
2958 printk("Controller Configuration information\n");
2959 printk("------------------------------------\n");
2960 for (i = 0; i < 4; i++)
2961 temp_name[i] = readb(&(tb->Signature[i]));
2962 temp_name[4] = '\0';
2963 printk(" Signature = %s\n", temp_name);
2964 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2965 printk(" Transport methods supported = 0x%x\n",
2966 readl(&(tb->TransportSupport)));
2967 printk(" Transport methods active = 0x%x\n",
2968 readl(&(tb->TransportActive)));
2969 printk(" Requested transport Method = 0x%x\n",
2970 readl(&(tb->HostWrite.TransportRequest)));
2971 printk(" Coalesce Interrupt Delay = 0x%x\n",
2972 readl(&(tb->HostWrite.CoalIntDelay)));
2973 printk(" Coalesce Interrupt Count = 0x%x\n",
2974 readl(&(tb->HostWrite.CoalIntCount)));
2975 printk(" Max outstanding commands = 0x%d\n",
2976 readl(&(tb->CmdsOutMax)));
2977 printk(" Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2978 for (i = 0; i < 16; i++)
2979 temp_name[i] = readb(&(tb->ServerName[i]));
2980 temp_name[16] = '\0';
2981 printk(" Server Name = %s\n", temp_name);
2982 printk(" Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
2984 #endif /* CCISS_DEBUG */
2986 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
2988 int i, offset, mem_type, bar_type;
2989 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2992 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2993 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
2994 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2997 mem_type = pci_resource_flags(pdev, i) &
2998 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
3000 case PCI_BASE_ADDRESS_MEM_TYPE_32:
3001 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
3002 offset += 4; /* 32 bit */
3004 case PCI_BASE_ADDRESS_MEM_TYPE_64:
3007 default: /* reserved in PCI 2.2 */
3009 "Base address is invalid\n");
3014 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
3020 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
3021 * controllers that are capable. If not, we use IO-APIC mode.
3024 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
3025 struct pci_dev *pdev, __u32 board_id)
3027 #ifdef CONFIG_PCI_MSI
3029 struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
3033 /* Some boards advertise MSI but don't really support it */
3034 if ((board_id == 0x40700E11) ||
3035 (board_id == 0x40800E11) ||
3036 (board_id == 0x40820E11) || (board_id == 0x40830E11))
3037 goto default_int_mode;
3039 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
3040 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
3042 c->intr[0] = cciss_msix_entries[0].vector;
3043 c->intr[1] = cciss_msix_entries[1].vector;
3044 c->intr[2] = cciss_msix_entries[2].vector;
3045 c->intr[3] = cciss_msix_entries[3].vector;
3050 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
3051 "available\n", err);
3052 goto default_int_mode;
3054 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
3056 goto default_int_mode;
3059 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
3060 if (!pci_enable_msi(pdev)) {
3063 printk(KERN_WARNING "cciss: MSI init failed\n");
3067 #endif /* CONFIG_PCI_MSI */
3068 /* if we get here we're going to use the default interrupt mode */
3069 c->intr[SIMPLE_MODE_INT] = pdev->irq;
3073 static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
3075 ushort subsystem_vendor_id, subsystem_device_id, command;
3076 __u32 board_id, scratchpad = 0;
3078 __u32 cfg_base_addr;
3079 __u64 cfg_base_addr_index;
3082 /* check to see if controller has been disabled */
3083 /* BEFORE trying to enable it */
3084 (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
3085 if (!(command & 0x02)) {
3087 "cciss: controller appears to be disabled\n");
3091 err = pci_enable_device(pdev);
3093 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
3097 err = pci_request_regions(pdev, "cciss");
3099 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
3104 subsystem_vendor_id = pdev->subsystem_vendor;
3105 subsystem_device_id = pdev->subsystem_device;
3106 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
3107 subsystem_vendor_id);
3110 printk("command = %x\n", command);
3111 printk("irq = %x\n", pdev->irq);
3112 printk("board_id = %x\n", board_id);
3113 #endif /* CCISS_DEBUG */
3115 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
3116 * else we use the IO-APIC interrupt assigned to us by system ROM.
3118 cciss_interrupt_mode(c, pdev, board_id);
3121 * Memory base addr is first addr , the second points to the config
3125 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
3127 printk("address 0 = %x\n", c->paddr);
3128 #endif /* CCISS_DEBUG */
3129 c->vaddr = remap_pci_mem(c->paddr, 0x250);
3131 /* Wait for the board to become ready. (PCI hotplug needs this.)
3132 * We poll for up to 120 secs, once per 100ms. */
3133 for (i = 0; i < 1200; i++) {
3134 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
3135 if (scratchpad == CCISS_FIRMWARE_READY)
3137 set_current_state(TASK_INTERRUPTIBLE);
3138 schedule_timeout(HZ / 10); /* wait 100ms */
3140 if (scratchpad != CCISS_FIRMWARE_READY) {
3141 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
3143 goto err_out_free_res;
3146 /* get the address index number */
3147 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
3148 cfg_base_addr &= (__u32) 0x0000ffff;
3150 printk("cfg base address = %x\n", cfg_base_addr);
3151 #endif /* CCISS_DEBUG */
3152 cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
3154 printk("cfg base address index = %x\n", cfg_base_addr_index);
3155 #endif /* CCISS_DEBUG */
3156 if (cfg_base_addr_index == -1) {
3157 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
3159 goto err_out_free_res;
3162 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
3164 printk("cfg offset = %x\n", cfg_offset);
3165 #endif /* CCISS_DEBUG */
3166 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
3167 cfg_base_addr_index) +
3168 cfg_offset, sizeof(CfgTable_struct));
3169 c->board_id = board_id;
3172 print_cfg_table(c->cfgtable);
3173 #endif /* CCISS_DEBUG */
3175 /* Some controllers support Zero Memory Raid (ZMR).
3176 * When configured in ZMR mode the number of supported
3177 * commands drops to 64. So instead of just setting an
3178 * arbitrary value we make the driver a little smarter.
3179 * We read the config table to tell us how many commands
3180 * are supported on the controller then subtract 4 to
3181 * leave a little room for ioctl calls.
3183 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3184 for (i = 0; i < ARRAY_SIZE(products); i++) {
3185 if (board_id == products[i].board_id) {
3186 c->product_name = products[i].product_name;
3187 c->access = *(products[i].access);
3188 c->nr_cmds = c->max_commands - 4;
3192 if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
3193 (readb(&c->cfgtable->Signature[1]) != 'I') ||
3194 (readb(&c->cfgtable->Signature[2]) != 'S') ||
3195 (readb(&c->cfgtable->Signature[3]) != 'S')) {
3196 printk("Does not appear to be a valid CISS config table\n");
3198 goto err_out_free_res;
3200 /* We didn't find the controller in our list. We know the
3201 * signature is valid. If it's an HP device let's try to
3202 * bind to the device and fire it up. Otherwise we bail.
3204 if (i == ARRAY_SIZE(products)) {
3205 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
3206 c->product_name = products[i-1].product_name;
3207 c->access = *(products[i-1].access);
3208 c->nr_cmds = c->max_commands - 4;
3209 printk(KERN_WARNING "cciss: This is an unknown "
3210 "Smart Array controller.\n"
3211 "cciss: Please update to the latest driver "
3212 "available from www.hp.com.\n");
3214 printk(KERN_WARNING "cciss: Sorry, I don't know how"
3215 " to access the Smart Array controller %08lx\n"
3216 , (unsigned long)board_id);
3218 goto err_out_free_res;
3223 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
3225 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
3227 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
3231 /* Disabling DMA prefetch and refetch for the P600.
3232 * An ASIC bug may result in accesses to invalid memory addresses.
3233 * We've disabled prefetch for some time now. Testing with XEN
3234 * kernels revealed a bug in the refetch if dom0 resides on a P600.
3236 if(board_id == 0x3225103C) {
3239 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
3240 dma_prefetch |= 0x8000;
3241 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
3242 pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch);
3244 pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch);
3248 printk("Trying to put board into Simple mode\n");
3249 #endif /* CCISS_DEBUG */
3250 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3251 /* Update the field, and then ring the doorbell */
3252 writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
3253 writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
3255 /* under certain very rare conditions, this can take awhile.
3256 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
3257 * as we enter this code.) */
3258 for (i = 0; i < MAX_CONFIG_WAIT; i++) {
3259 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3261 /* delay and try again */
3262 set_current_state(TASK_INTERRUPTIBLE);
3263 schedule_timeout(10);
3267 printk(KERN_DEBUG "I counter got to %d %x\n", i,
3268 readl(c->vaddr + SA5_DOORBELL));
3269 #endif /* CCISS_DEBUG */
3271 print_cfg_table(c->cfgtable);
3272 #endif /* CCISS_DEBUG */
3274 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
3275 printk(KERN_WARNING "cciss: unable to get board into"
3278 goto err_out_free_res;
3284 * Deliberately omit pci_disable_device(): it does something nasty to
3285 * Smart Array controllers that pci_enable_device does not undo
3287 pci_release_regions(pdev);
3292 * Gets information about the local volumes attached to the controller.
3294 static void cciss_getgeometry(int cntl_num)
3296 ReportLunData_struct *ld_buff;
3297 InquiryData_struct *inq_buff;
3302 unsigned block_size;
3303 sector_t total_size;
3305 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3306 if (ld_buff == NULL) {
3307 printk(KERN_ERR "cciss: out of memory\n");
3310 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3311 if (inq_buff == NULL) {
3312 printk(KERN_ERR "cciss: out of memory\n");
3316 /* Get the firmware version */
3317 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3318 sizeof(InquiryData_struct), 0, 0, 0, NULL,
3320 if (return_code == IO_OK) {
3321 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3322 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3323 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3324 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3325 } else { /* send command failed */
3327 printk(KERN_WARNING "cciss: unable to determine firmware"
3328 " version of controller\n");
3330 /* Get the number of logical volumes */
3331 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3332 sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3335 if (return_code == IO_OK) {
3337 printk("LUN Data\n--------------------------\n");
3338 #endif /* CCISS_DEBUG */
3341 (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3343 (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3345 (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
3346 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3347 } else { /* reading number of logical volumes failed */
3349 printk(KERN_WARNING "cciss: report logical volume"
3350 " command failed\n");
3353 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
3354 if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3356 "ciss: only %d number of logical volumes supported\n",
3358 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3361 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3362 ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3363 ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3364 hba[cntl_num]->num_luns);
3365 #endif /* CCISS_DEBUG */
3367 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
3368 for (i = 0; i < CISS_MAX_LUN; i++) {
3369 if (i < hba[cntl_num]->num_luns) {
3370 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3372 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3374 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3376 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3378 hba[cntl_num]->drv[i].LunID = lunid;
3381 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
3382 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3383 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3384 hba[cntl_num]->drv[i].LunID);
3385 #endif /* CCISS_DEBUG */
3387 /* testing to see if 16-byte CDBs are already being used */
3388 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3389 cciss_read_capacity_16(cntl_num, i, 0,
3390 &total_size, &block_size);
3393 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3395 /* If read_capacity returns all F's the logical is >2TB */
3396 /* so we switch to 16-byte CDBs for all read/write ops */
3397 if(total_size == 0xFFFFFFFFULL) {
3398 cciss_read_capacity_16(cntl_num, i, 0,
3399 &total_size, &block_size);
3400 hba[cntl_num]->cciss_read = CCISS_READ_16;
3401 hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3403 hba[cntl_num]->cciss_read = CCISS_READ_10;
3404 hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3407 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3408 block_size, inq_buff,
3409 &hba[cntl_num]->drv[i]);
3410 cciss_get_serial_no(cntl_num, i, 0,
3411 hba[cntl_num]->drv[i].serial_no,
3412 sizeof(hba[cntl_num]->drv[i].serial_no));
3414 /* initialize raid_level to indicate a free space */
3415 hba[cntl_num]->drv[i].raid_level = -1;
3422 /* Function to find the first free pointer into our hba[] array */
3423 /* Returns -1 if no free entries are left. */
3424 static int alloc_cciss_hba(void)
3428 for (i = 0; i < MAX_CTLR; i++) {
3432 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3435 p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
3436 if (!p->gendisk[0]) {
3444 printk(KERN_WARNING "cciss: This driver supports a maximum"
3445 " of %d controllers.\n", MAX_CTLR);
3448 printk(KERN_ERR "cciss: out of memory.\n");
3452 static void free_hba(int i)
3454 ctlr_info_t *p = hba[i];
3458 for (n = 0; n < CISS_MAX_LUN; n++)
3459 put_disk(p->gendisk[n]);
3464 * This is it. Find all the controllers and register them. I really hate
3465 * stealing all these major device numbers.
3466 * returns the number of block devices registered.
3468 static int __devinit cciss_init_one(struct pci_dev *pdev,
3469 const struct pci_device_id *ent)
3476 i = alloc_cciss_hba();
3480 hba[i]->busy_initializing = 1;
3482 if (cciss_pci_init(hba[i], pdev) != 0)
3485 sprintf(hba[i]->devname, "cciss%d", i);
3487 hba[i]->pdev = pdev;
3489 /* configure PCI DMA stuff */
3490 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3492 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3495 printk(KERN_ERR "cciss: no suitable DMA available\n");
3500 * register with the major number, or get a dynamic major number
3501 * by passing 0 as argument. This is done for greater than
3502 * 8 controller support.
3504 if (i < MAX_CTLR_ORIG)
3505 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3506 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3507 if (rc == -EBUSY || rc == -EINVAL) {
3509 "cciss: Unable to get major number %d for %s "
3510 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3513 if (i >= MAX_CTLR_ORIG)
3517 /* make sure the board interrupts are off */
3518 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3519 if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3520 IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3521 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3522 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3526 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3527 hba[i]->devname, pdev->device, pci_name(pdev),
3528 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3530 hba[i]->cmd_pool_bits =
3531 kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3532 1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3533 hba[i]->cmd_pool = (CommandList_struct *)
3534 pci_alloc_consistent(hba[i]->pdev,
3535 hba[i]->nr_cmds * sizeof(CommandList_struct),
3536 &(hba[i]->cmd_pool_dhandle));
3537 hba[i]->errinfo_pool = (ErrorInfo_struct *)
3538 pci_alloc_consistent(hba[i]->pdev,
3539 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3540 &(hba[i]->errinfo_pool_dhandle));
3541 if ((hba[i]->cmd_pool_bits == NULL)
3542 || (hba[i]->cmd_pool == NULL)
3543 || (hba[i]->errinfo_pool == NULL)) {
3544 printk(KERN_ERR "cciss: out of memory");
3547 #ifdef CONFIG_CISS_SCSI_TAPE
3548 hba[i]->scsi_rejects.complete =
3549 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3550 (hba[i]->nr_cmds + 5), GFP_KERNEL);
3551 if (hba[i]->scsi_rejects.complete == NULL) {
3552 printk(KERN_ERR "cciss: out of memory");
3556 spin_lock_init(&hba[i]->lock);
3558 /* Initialize the pdev driver private data.
3559 have it point to hba[i]. */
3560 pci_set_drvdata(pdev, hba[i]);
3561 /* command and error info recs zeroed out before
3563 memset(hba[i]->cmd_pool_bits, 0,
3564 ((hba[i]->nr_cmds + BITS_PER_LONG -
3565 1) / BITS_PER_LONG) * sizeof(unsigned long));
3568 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3569 #endif /* CCISS_DEBUG */
3571 cciss_getgeometry(i);
3573 cciss_scsi_setup(i);
3575 /* Turn the interrupts on so we can service requests */
3576 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3580 hba[i]->cciss_max_sectors = 2048;
3582 hba[i]->busy_initializing = 0;
3585 drive_info_struct *drv = &(hba[i]->drv[j]);
3586 struct gendisk *disk = hba[i]->gendisk[j];
3587 struct request_queue *q;
3589 /* Check if the disk was allocated already */
3591 hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
3592 disk = hba[i]->gendisk[j];
3595 /* Check that the disk was able to be allocated */
3597 printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
3601 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3604 "cciss: unable to allocate queue for disk %d\n",
3610 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3612 /* This is a hardware imposed limit. */
3613 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3615 /* This is a limit in the driver and could be eliminated. */
3616 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3618 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
3620 blk_queue_softirq_done(q, cciss_softirq_done);
3622 q->queuedata = hba[i];
3623 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3624 disk->major = hba[i]->major;
3625 disk->first_minor = j << NWD_SHIFT;
3626 disk->fops = &cciss_fops;
3628 disk->private_data = drv;
3629 disk->driverfs_dev = &pdev->dev;
3630 /* we must register the controller even if no disks exist */
3631 /* this is for the online array utilities */
3632 if (!drv->heads && j)
3634 blk_queue_hardsect_size(q, drv->block_size);
3635 set_capacity(disk, drv->nr_blocks);
3637 } while (j <= hba[i]->highest_lun);
3639 /* Make sure all queue data is written out before */
3640 /* interrupt handler, triggered by add_disk, */
3641 /* is allowed to start them. */
3644 for (j = 0; j <= hba[i]->highest_lun; j++)
3645 add_disk(hba[i]->gendisk[j]);
3647 /* we must register the controller even if no disks exist */
3648 if (hba[i]->highest_lun == -1)
3649 add_disk(hba[i]->gendisk[0]);
3654 #ifdef CONFIG_CISS_SCSI_TAPE
3655 kfree(hba[i]->scsi_rejects.complete);
3657 kfree(hba[i]->cmd_pool_bits);
3658 if (hba[i]->cmd_pool)
3659 pci_free_consistent(hba[i]->pdev,
3660 hba[i]->nr_cmds * sizeof(CommandList_struct),
3661 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3662 if (hba[i]->errinfo_pool)
3663 pci_free_consistent(hba[i]->pdev,
3664 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3665 hba[i]->errinfo_pool,
3666 hba[i]->errinfo_pool_dhandle);
3667 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3669 unregister_blkdev(hba[i]->major, hba[i]->devname);
3671 hba[i]->busy_initializing = 0;
3672 /* cleanup any queues that may have been initialized */
3673 for (j=0; j <= hba[i]->highest_lun; j++){
3674 drive_info_struct *drv = &(hba[i]->drv[j]);
3676 blk_cleanup_queue(drv->queue);
3679 * Deliberately omit pci_disable_device(): it does something nasty to
3680 * Smart Array controllers that pci_enable_device does not undo
3682 pci_release_regions(pdev);
3683 pci_set_drvdata(pdev, NULL);
3688 static void cciss_shutdown(struct pci_dev *pdev)
3690 ctlr_info_t *tmp_ptr;
3695 tmp_ptr = pci_get_drvdata(pdev);
3696 if (tmp_ptr == NULL)
3702 /* Turn board interrupts off and send the flush cache command */
3703 /* sendcmd will turn off interrupt, and send the flush...
3704 * To write all data in the battery backed cache to disks */
3705 memset(flush_buf, 0, 4);
3706 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3708 if (return_code == IO_OK) {
3709 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
3711 printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
3713 free_irq(hba[i]->intr[2], hba[i]);
3716 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3718 ctlr_info_t *tmp_ptr;
3721 if (pci_get_drvdata(pdev) == NULL) {
3722 printk(KERN_ERR "cciss: Unable to remove device \n");
3725 tmp_ptr = pci_get_drvdata(pdev);
3727 if (hba[i] == NULL) {
3728 printk(KERN_ERR "cciss: device appears to "
3729 "already be removed \n");
3733 remove_proc_entry(hba[i]->devname, proc_cciss);
3734 unregister_blkdev(hba[i]->major, hba[i]->devname);
3736 /* remove it from the disk list */
3737 for (j = 0; j < CISS_MAX_LUN; j++) {
3738 struct gendisk *disk = hba[i]->gendisk[j];
3740 struct request_queue *q = disk->queue;
3742 if (disk->flags & GENHD_FL_UP)
3745 blk_cleanup_queue(q);
3749 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3751 cciss_shutdown(pdev);
3753 #ifdef CONFIG_PCI_MSI
3754 if (hba[i]->msix_vector)
3755 pci_disable_msix(hba[i]->pdev);
3756 else if (hba[i]->msi_vector)
3757 pci_disable_msi(hba[i]->pdev);
3758 #endif /* CONFIG_PCI_MSI */
3760 iounmap(hba[i]->vaddr);
3762 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
3763 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3764 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3765 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3766 kfree(hba[i]->cmd_pool_bits);
3767 #ifdef CONFIG_CISS_SCSI_TAPE
3768 kfree(hba[i]->scsi_rejects.complete);
3771 * Deliberately omit pci_disable_device(): it does something nasty to
3772 * Smart Array controllers that pci_enable_device does not undo
3774 pci_release_regions(pdev);
3775 pci_set_drvdata(pdev, NULL);
3779 static struct pci_driver cciss_pci_driver = {
3781 .probe = cciss_init_one,
3782 .remove = __devexit_p(cciss_remove_one),
3783 .id_table = cciss_pci_device_id, /* id_table */
3784 .shutdown = cciss_shutdown,
3788 * This is it. Register the PCI driver information for the cards we control
3789 * the OS will call our registered routines when it finds one of our cards.
3791 static int __init cciss_init(void)
3793 printk(KERN_INFO DRIVER_NAME "\n");
3795 /* Register for our PCI devices */
3796 return pci_register_driver(&cciss_pci_driver);
3799 static void __exit cciss_cleanup(void)
3803 pci_unregister_driver(&cciss_pci_driver);
3804 /* double check that all controller entrys have been removed */
3805 for (i = 0; i < MAX_CTLR; i++) {
3806 if (hba[i] != NULL) {
3807 printk(KERN_WARNING "cciss: had to remove"
3808 " controller %d\n", i);
3809 cciss_remove_one(hba[i]->pdev);
3812 remove_proc_entry("driver/cciss", NULL);
3815 static void fail_all_cmds(unsigned long ctlr)
3817 /* If we get here, the board is apparently dead. */
3818 ctlr_info_t *h = hba[ctlr];
3819 CommandList_struct *c;
3820 unsigned long flags;
3822 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3823 h->alive = 0; /* the controller apparently died... */
3825 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3827 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3829 /* move everything off the request queue onto the completed queue */
3830 while ((c = h->reqQ) != NULL) {
3831 removeQ(&(h->reqQ), c);
3833 addQ(&(h->cmpQ), c);
3836 /* Now, fail everything on the completed queue with a HW error */
3837 while ((c = h->cmpQ) != NULL) {
3838 removeQ(&h->cmpQ, c);
3839 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3840 if (c->cmd_type == CMD_RWREQ) {
3841 complete_command(h, c, 0);
3842 } else if (c->cmd_type == CMD_IOCTL_PEND)
3843 complete(c->waiting);
3844 #ifdef CONFIG_CISS_SCSI_TAPE
3845 else if (c->cmd_type == CMD_SCSI)
3846 complete_scsi_command(c, 0, 0);
3849 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3853 module_init(cciss_init);
3854 module_exit(cciss_cleanup);