2 * Disk Array driver for HP SA 5xxx and 6xxx Controllers
3 * Copyright 2000, 2006 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; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
13 * NON INFRINGEMENT. See the GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
23 #include <linux/config.h> /* CONFIG_PROC_FS */
24 #include <linux/module.h>
25 #include <linux/interrupt.h>
26 #include <linux/types.h>
27 #include <linux/pci.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/major.h>
33 #include <linux/bio.h>
34 #include <linux/blkpg.h>
35 #include <linux/timer.h>
36 #include <linux/proc_fs.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>
50 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
51 #define DRIVER_NAME "HP CISS Driver (v 2.6.10)"
52 #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,10)
54 /* Embedded module documentation macros - see modules.h */
55 MODULE_AUTHOR("Hewlett-Packard Company");
56 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.10");
57 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
58 " SA6i P600 P800 P400 P400i E200 E200i");
59 MODULE_LICENSE("GPL");
61 #include "cciss_cmd.h"
63 #include <linux/cciss_ioctl.h>
65 /* define the PCI info for the cards we can control */
66 static const struct pci_device_id cciss_pci_device_id[] = {
67 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
68 0x0E11, 0x4070, 0, 0, 0},
69 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
70 0x0E11, 0x4080, 0, 0, 0},
71 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
72 0x0E11, 0x4082, 0, 0, 0},
73 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
74 0x0E11, 0x4083, 0, 0, 0},
75 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
76 0x0E11, 0x409A, 0, 0, 0},
77 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
78 0x0E11, 0x409B, 0, 0, 0},
79 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
80 0x0E11, 0x409C, 0, 0, 0},
81 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
82 0x0E11, 0x409D, 0, 0, 0},
83 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
84 0x0E11, 0x4091, 0, 0, 0},
85 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
86 0x103C, 0x3225, 0, 0, 0},
87 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
88 0x103c, 0x3223, 0, 0, 0},
89 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
90 0x103c, 0x3234, 0, 0, 0},
91 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
92 0x103c, 0x3235, 0, 0, 0},
93 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
94 0x103c, 0x3211, 0, 0, 0},
95 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
96 0x103c, 0x3212, 0, 0, 0},
97 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
98 0x103c, 0x3213, 0, 0, 0},
99 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
100 0x103c, 0x3214, 0, 0, 0},
101 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
102 0x103c, 0x3215, 0, 0, 0},
105 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
107 /* board_id = Subsystem Device ID & Vendor ID
108 * product = Marketing Name for the board
109 * access = Address of the struct of function pointers
111 static struct board_type products[] = {
112 { 0x40700E11, "Smart Array 5300", &SA5_access },
113 { 0x40800E11, "Smart Array 5i", &SA5B_access},
114 { 0x40820E11, "Smart Array 532", &SA5B_access},
115 { 0x40830E11, "Smart Array 5312", &SA5B_access},
116 { 0x409A0E11, "Smart Array 641", &SA5_access},
117 { 0x409B0E11, "Smart Array 642", &SA5_access},
118 { 0x409C0E11, "Smart Array 6400", &SA5_access},
119 { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
120 { 0x40910E11, "Smart Array 6i", &SA5_access},
121 { 0x3225103C, "Smart Array P600", &SA5_access},
122 { 0x3223103C, "Smart Array P800", &SA5_access},
123 { 0x3234103C, "Smart Array P400", &SA5_access},
124 { 0x3235103C, "Smart Array P400i", &SA5_access},
125 { 0x3211103C, "Smart Array E200i", &SA5_access},
126 { 0x3212103C, "Smart Array E200", &SA5_access},
127 { 0x3213103C, "Smart Array E200i", &SA5_access},
128 { 0x3214103C, "Smart Array E200i", &SA5_access},
129 { 0x3215103C, "Smart Array E200i", &SA5_access},
132 /* How long to wait (in millesconds) for board to go into simple mode */
133 #define MAX_CONFIG_WAIT 30000
134 #define MAX_IOCTL_CONFIG_WAIT 1000
136 /*define how many times we will try a command because of bus resets */
137 #define MAX_CMD_RETRIES 3
139 #define READ_AHEAD 1024
140 #define NR_CMDS 384 /* #commands that can be outstanding */
143 /* Originally cciss driver only supports 8 major numbers */
144 #define MAX_CTLR_ORIG 8
147 static ctlr_info_t *hba[MAX_CTLR];
149 static void do_cciss_request(request_queue_t *q);
150 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
151 static int cciss_open(struct inode *inode, struct file *filep);
152 static int cciss_release(struct inode *inode, struct file *filep);
153 static int cciss_ioctl(struct inode *inode, struct file *filep,
154 unsigned int cmd, unsigned long arg);
155 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
157 static int revalidate_allvol(ctlr_info_t *host);
158 static int cciss_revalidate(struct gendisk *disk);
159 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
160 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
162 static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
163 int withirq, unsigned int *total_size, unsigned int *block_size);
164 static void cciss_geometry_inquiry(int ctlr, int logvol,
165 int withirq, unsigned int total_size,
166 unsigned int block_size, InquiryData_struct *inq_buff,
167 drive_info_struct *drv);
168 static void cciss_getgeometry(int cntl_num);
169 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, __u32);
170 static void start_io( ctlr_info_t *h);
171 static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
172 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
173 unsigned char *scsi3addr, int cmd_type);
174 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
175 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
178 static void fail_all_cmds(unsigned long ctlr);
180 #ifdef CONFIG_PROC_FS
181 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
182 int length, int *eof, void *data);
183 static void cciss_procinit(int i);
185 static void cciss_procinit(int i) {}
186 #endif /* CONFIG_PROC_FS */
189 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
192 static struct block_device_operations cciss_fops = {
193 .owner = THIS_MODULE,
195 .release = cciss_release,
196 .ioctl = cciss_ioctl,
197 .getgeo = cciss_getgeo,
199 .compat_ioctl = cciss_compat_ioctl,
201 .revalidate_disk= cciss_revalidate,
205 * Enqueuing and dequeuing functions for cmdlists.
207 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
211 c->next = c->prev = c;
213 c->prev = (*Qptr)->prev;
215 (*Qptr)->prev->next = c;
220 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
221 CommandList_struct *c)
223 if (c && c->next != c) {
224 if (*Qptr == c) *Qptr = c->next;
225 c->prev->next = c->next;
226 c->next->prev = c->prev;
233 #include "cciss_scsi.c" /* For SCSI tape support */
235 #ifdef CONFIG_PROC_FS
238 * Report information about this controller.
240 #define ENG_GIG 1000000000
241 #define ENG_GIG_FACTOR (ENG_GIG/512)
242 #define RAID_UNKNOWN 6
243 static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
246 static struct proc_dir_entry *proc_cciss;
248 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
249 int length, int *eof, void *data)
254 ctlr_info_t *h = (ctlr_info_t*)data;
255 drive_info_struct *drv;
257 sector_t vol_sz, vol_sz_frac;
261 /* prevent displaying bogus info during configuration
262 * or deconfiguration of a logical volume
264 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
265 if (h->busy_configuring) {
266 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
269 h->busy_configuring = 1;
270 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
272 size = sprintf(buffer, "%s: HP %s Controller\n"
273 "Board ID: 0x%08lx\n"
274 "Firmware Version: %c%c%c%c\n"
276 "Logical drives: %d\n"
277 "Current Q depth: %d\n"
278 "Current # commands on controller: %d\n"
279 "Max Q depth since init: %d\n"
280 "Max # commands on controller since init: %d\n"
281 "Max SG entries since init: %d\n\n",
284 (unsigned long)h->board_id,
285 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
286 (unsigned int)h->intr[SIMPLE_MODE_INT],
288 h->Qdepth, h->commands_outstanding,
289 h->maxQsinceinit, h->max_outstanding, h->maxSG);
291 pos += size; len += size;
292 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
293 for(i=0; i<=h->highest_lun; i++) {
299 vol_sz = drv->nr_blocks;
300 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
302 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
304 if (drv->raid_level > 5)
305 drv->raid_level = RAID_UNKNOWN;
306 size = sprintf(buffer+len, "cciss/c%dd%d:"
307 "\t%4u.%02uGB\tRAID %s\n",
308 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
309 raid_label[drv->raid_level]);
310 pos += size; len += size;
314 *start = buffer+offset;
318 h->busy_configuring = 0;
323 cciss_proc_write(struct file *file, const char __user *buffer,
324 unsigned long count, void *data)
326 unsigned char cmd[80];
328 #ifdef CONFIG_CISS_SCSI_TAPE
329 ctlr_info_t *h = (ctlr_info_t *) data;
333 if (count > sizeof(cmd)-1) return -EINVAL;
334 if (copy_from_user(cmd, buffer, count)) return -EFAULT;
336 len = strlen(cmd); // above 3 lines ensure safety
337 if (len && cmd[len-1] == '\n')
339 # ifdef CONFIG_CISS_SCSI_TAPE
340 if (strcmp("engage scsi", cmd)==0) {
341 rc = cciss_engage_scsi(h->ctlr);
342 if (rc != 0) return -rc;
345 /* might be nice to have "disengage" too, but it's not
346 safely possible. (only 1 module use count, lock issues.) */
352 * Get us a file in /proc/cciss that says something about each controller.
353 * Create /proc/cciss if it doesn't exist yet.
355 static void __devinit cciss_procinit(int i)
357 struct proc_dir_entry *pde;
359 if (proc_cciss == NULL) {
360 proc_cciss = proc_mkdir("cciss", proc_root_driver);
365 pde = create_proc_read_entry(hba[i]->devname,
366 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
367 proc_cciss, cciss_proc_get_info, hba[i]);
368 pde->write_proc = cciss_proc_write;
370 #endif /* CONFIG_PROC_FS */
373 * For operations that cannot sleep, a command block is allocated at init,
374 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
375 * which ones are free or in use. For operations that can wait for kmalloc
376 * to possible sleep, this routine can be called with get_from_pool set to 0.
377 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
379 static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
381 CommandList_struct *c;
384 dma_addr_t cmd_dma_handle, err_dma_handle;
388 c = (CommandList_struct *) pci_alloc_consistent(
389 h->pdev, sizeof(CommandList_struct), &cmd_dma_handle);
392 memset(c, 0, sizeof(CommandList_struct));
396 c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
397 h->pdev, sizeof(ErrorInfo_struct),
400 if (c->err_info == NULL)
402 pci_free_consistent(h->pdev,
403 sizeof(CommandList_struct), c, cmd_dma_handle);
406 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
407 } else /* get it out of the controllers pool */
410 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
413 } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
415 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
418 memset(c, 0, sizeof(CommandList_struct));
419 cmd_dma_handle = h->cmd_pool_dhandle
420 + i*sizeof(CommandList_struct);
421 c->err_info = h->errinfo_pool + i;
422 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
423 err_dma_handle = h->errinfo_pool_dhandle
424 + i*sizeof(ErrorInfo_struct);
430 c->busaddr = (__u32) cmd_dma_handle;
431 temp64.val = (__u64) err_dma_handle;
432 c->ErrDesc.Addr.lower = temp64.val32.lower;
433 c->ErrDesc.Addr.upper = temp64.val32.upper;
434 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
443 * Frees a command block that was previously allocated with cmd_alloc().
445 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
452 temp64.val32.lower = c->ErrDesc.Addr.lower;
453 temp64.val32.upper = c->ErrDesc.Addr.upper;
454 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
455 c->err_info, (dma_addr_t) temp64.val);
456 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
457 c, (dma_addr_t) c->busaddr);
461 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
466 static inline ctlr_info_t *get_host(struct gendisk *disk)
468 return disk->queue->queuedata;
471 static inline drive_info_struct *get_drv(struct gendisk *disk)
473 return disk->private_data;
477 * Open. Make sure the device is really there.
479 static int cciss_open(struct inode *inode, struct file *filep)
481 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
482 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
485 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
486 #endif /* CCISS_DEBUG */
488 if (host->busy_initializing || drv->busy_configuring)
491 * Root is allowed to open raw volume zero even if it's not configured
492 * so array config can still work. Root is also allowed to open any
493 * volume that has a LUN ID, so it can issue IOCTL to reread the
494 * disk information. I don't think I really like this
495 * but I'm already using way to many device nodes to claim another one
496 * for "raw controller".
498 if (drv->nr_blocks == 0) {
499 if (iminor(inode) != 0) { /* not node 0? */
500 /* if not node 0 make sure it is a partition = 0 */
501 if (iminor(inode) & 0x0f) {
503 /* if it is, make sure we have a LUN ID */
504 } else if (drv->LunID == 0) {
508 if (!capable(CAP_SYS_ADMIN))
518 static int cciss_release(struct inode *inode, struct file *filep)
520 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
521 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
524 printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
525 #endif /* CCISS_DEBUG */
534 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
538 ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
543 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
544 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
546 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
549 case CCISS_GETPCIINFO:
550 case CCISS_GETINTINFO:
551 case CCISS_SETINTINFO:
552 case CCISS_GETNODENAME:
553 case CCISS_SETNODENAME:
554 case CCISS_GETHEARTBEAT:
555 case CCISS_GETBUSTYPES:
556 case CCISS_GETFIRMVER:
557 case CCISS_GETDRIVVER:
558 case CCISS_REVALIDVOLS:
559 case CCISS_DEREGDISK:
560 case CCISS_REGNEWDISK:
562 case CCISS_RESCANDISK:
563 case CCISS_GETLUNINFO:
564 return do_ioctl(f, cmd, arg);
566 case CCISS_PASSTHRU32:
567 return cciss_ioctl32_passthru(f, cmd, arg);
568 case CCISS_BIG_PASSTHRU32:
569 return cciss_ioctl32_big_passthru(f, cmd, arg);
576 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
578 IOCTL32_Command_struct __user *arg32 =
579 (IOCTL32_Command_struct __user *) arg;
580 IOCTL_Command_struct arg64;
581 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
586 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
587 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
588 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
589 err |= get_user(arg64.buf_size, &arg32->buf_size);
590 err |= get_user(cp, &arg32->buf);
591 arg64.buf = compat_ptr(cp);
592 err |= copy_to_user(p, &arg64, sizeof(arg64));
597 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
600 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
606 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
608 BIG_IOCTL32_Command_struct __user *arg32 =
609 (BIG_IOCTL32_Command_struct __user *) arg;
610 BIG_IOCTL_Command_struct arg64;
611 BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
616 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
617 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
618 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
619 err |= get_user(arg64.buf_size, &arg32->buf_size);
620 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
621 err |= get_user(cp, &arg32->buf);
622 arg64.buf = compat_ptr(cp);
623 err |= copy_to_user(p, &arg64, sizeof(arg64));
628 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
631 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
638 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
640 drive_info_struct *drv = get_drv(bdev->bd_disk);
645 geo->heads = drv->heads;
646 geo->sectors = drv->sectors;
647 geo->cylinders = drv->cylinders;
654 static int cciss_ioctl(struct inode *inode, struct file *filep,
655 unsigned int cmd, unsigned long arg)
657 struct block_device *bdev = inode->i_bdev;
658 struct gendisk *disk = bdev->bd_disk;
659 ctlr_info_t *host = get_host(disk);
660 drive_info_struct *drv = get_drv(disk);
661 int ctlr = host->ctlr;
662 void __user *argp = (void __user *)arg;
665 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
666 #endif /* CCISS_DEBUG */
669 case CCISS_GETPCIINFO:
671 cciss_pci_info_struct pciinfo;
673 if (!arg) return -EINVAL;
674 pciinfo.domain = pci_domain_nr(host->pdev->bus);
675 pciinfo.bus = host->pdev->bus->number;
676 pciinfo.dev_fn = host->pdev->devfn;
677 pciinfo.board_id = host->board_id;
678 if (copy_to_user(argp, &pciinfo, sizeof( cciss_pci_info_struct )))
682 case CCISS_GETINTINFO:
684 cciss_coalint_struct intinfo;
685 if (!arg) return -EINVAL;
686 intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
687 intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
688 if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
692 case CCISS_SETINTINFO:
694 cciss_coalint_struct intinfo;
698 if (!arg) return -EINVAL;
699 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
700 if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
702 if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
705 // printk("cciss_ioctl: delay and count cannot be 0\n");
708 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
709 /* Update the field, and then ring the doorbell */
710 writel( intinfo.delay,
711 &(host->cfgtable->HostWrite.CoalIntDelay));
712 writel( intinfo.count,
713 &(host->cfgtable->HostWrite.CoalIntCount));
714 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
716 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
717 if (!(readl(host->vaddr + SA5_DOORBELL)
720 /* delay and try again */
723 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
724 if (i >= MAX_IOCTL_CONFIG_WAIT)
728 case CCISS_GETNODENAME:
730 NodeName_type NodeName;
733 if (!arg) return -EINVAL;
735 NodeName[i] = readb(&host->cfgtable->ServerName[i]);
736 if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
740 case CCISS_SETNODENAME:
742 NodeName_type NodeName;
746 if (!arg) return -EINVAL;
747 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
749 if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
752 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
754 /* Update the field, and then ring the doorbell */
756 writeb( NodeName[i], &host->cfgtable->ServerName[i]);
758 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
760 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
761 if (!(readl(host->vaddr + SA5_DOORBELL)
764 /* delay and try again */
767 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
768 if (i >= MAX_IOCTL_CONFIG_WAIT)
773 case CCISS_GETHEARTBEAT:
775 Heartbeat_type heartbeat;
777 if (!arg) return -EINVAL;
778 heartbeat = readl(&host->cfgtable->HeartBeat);
779 if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
783 case CCISS_GETBUSTYPES:
785 BusTypes_type BusTypes;
787 if (!arg) return -EINVAL;
788 BusTypes = readl(&host->cfgtable->BusTypes);
789 if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
793 case CCISS_GETFIRMVER:
795 FirmwareVer_type firmware;
797 if (!arg) return -EINVAL;
798 memcpy(firmware, host->firm_ver, 4);
800 if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
804 case CCISS_GETDRIVVER:
806 DriverVer_type DriverVer = DRIVER_VERSION;
808 if (!arg) return -EINVAL;
810 if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
815 case CCISS_REVALIDVOLS:
816 if (bdev != bdev->bd_contains || drv != host->drv)
818 return revalidate_allvol(host);
820 case CCISS_GETLUNINFO: {
821 LogvolInfo_struct luninfo;
823 luninfo.LunID = drv->LunID;
824 luninfo.num_opens = drv->usage_count;
825 luninfo.num_parts = 0;
826 if (copy_to_user(argp, &luninfo,
827 sizeof(LogvolInfo_struct)))
831 case CCISS_DEREGDISK:
832 return rebuild_lun_table(host, disk);
835 return rebuild_lun_table(host, NULL);
839 IOCTL_Command_struct iocommand;
840 CommandList_struct *c;
844 DECLARE_COMPLETION(wait);
846 if (!arg) return -EINVAL;
848 if (!capable(CAP_SYS_RAWIO)) return -EPERM;
850 if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
852 if((iocommand.buf_size < 1) &&
853 (iocommand.Request.Type.Direction != XFER_NONE))
857 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
858 /* Check kmalloc limits */
859 if(iocommand.buf_size > 128000)
862 if(iocommand.buf_size > 0)
864 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
868 if (iocommand.Request.Type.Direction == XFER_WRITE)
870 /* Copy the data into the buffer we created */
871 if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
877 memset(buff, 0, iocommand.buf_size);
879 if ((c = cmd_alloc(host , 0)) == NULL)
884 // Fill in the command type
885 c->cmd_type = CMD_IOCTL_PEND;
886 // Fill in Command Header
887 c->Header.ReplyQueue = 0; // unused in simple mode
888 if( iocommand.buf_size > 0) // buffer to fill
890 c->Header.SGList = 1;
891 c->Header.SGTotal= 1;
892 } else // no buffers to fill
894 c->Header.SGList = 0;
895 c->Header.SGTotal= 0;
897 c->Header.LUN = iocommand.LUN_info;
898 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
900 // Fill in Request block
901 c->Request = iocommand.Request;
903 // Fill in the scatter gather information
904 if (iocommand.buf_size > 0 )
906 temp64.val = pci_map_single( host->pdev, buff,
908 PCI_DMA_BIDIRECTIONAL);
909 c->SG[0].Addr.lower = temp64.val32.lower;
910 c->SG[0].Addr.upper = temp64.val32.upper;
911 c->SG[0].Len = iocommand.buf_size;
912 c->SG[0].Ext = 0; // we are not chaining
916 /* Put the request on the tail of the request queue */
917 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
918 addQ(&host->reqQ, c);
921 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
923 wait_for_completion(&wait);
925 /* unlock the buffers from DMA */
926 temp64.val32.lower = c->SG[0].Addr.lower;
927 temp64.val32.upper = c->SG[0].Addr.upper;
928 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
929 iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
931 /* Copy the error information out */
932 iocommand.error_info = *(c->err_info);
933 if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
936 cmd_free(host, c, 0);
940 if (iocommand.Request.Type.Direction == XFER_READ)
942 /* Copy the data out of the buffer we created */
943 if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
946 cmd_free(host, c, 0);
951 cmd_free(host, c, 0);
954 case CCISS_BIG_PASSTHRU: {
955 BIG_IOCTL_Command_struct *ioc;
956 CommandList_struct *c;
957 unsigned char **buff = NULL;
958 int *buff_size = NULL;
964 DECLARE_COMPLETION(wait);
967 BYTE __user *data_ptr;
971 if (!capable(CAP_SYS_RAWIO))
973 ioc = (BIG_IOCTL_Command_struct *)
974 kmalloc(sizeof(*ioc), GFP_KERNEL);
979 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
983 if ((ioc->buf_size < 1) &&
984 (ioc->Request.Type.Direction != XFER_NONE)) {
988 /* Check kmalloc limits using all SGs */
989 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
993 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
997 buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1002 buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int),
1008 left = ioc->buf_size;
1009 data_ptr = ioc->buf;
1011 sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
1012 buff_size[sg_used] = sz;
1013 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1014 if (buff[sg_used] == NULL) {
1018 if (ioc->Request.Type.Direction == XFER_WRITE) {
1019 if (copy_from_user(buff[sg_used], data_ptr, sz)) {
1024 memset(buff[sg_used], 0, sz);
1030 if ((c = cmd_alloc(host , 0)) == NULL) {
1034 c->cmd_type = CMD_IOCTL_PEND;
1035 c->Header.ReplyQueue = 0;
1037 if( ioc->buf_size > 0) {
1038 c->Header.SGList = sg_used;
1039 c->Header.SGTotal= sg_used;
1041 c->Header.SGList = 0;
1042 c->Header.SGTotal= 0;
1044 c->Header.LUN = ioc->LUN_info;
1045 c->Header.Tag.lower = c->busaddr;
1047 c->Request = ioc->Request;
1048 if (ioc->buf_size > 0 ) {
1050 for(i=0; i<sg_used; i++) {
1051 temp64.val = pci_map_single( host->pdev, buff[i],
1053 PCI_DMA_BIDIRECTIONAL);
1054 c->SG[i].Addr.lower = temp64.val32.lower;
1055 c->SG[i].Addr.upper = temp64.val32.upper;
1056 c->SG[i].Len = buff_size[i];
1057 c->SG[i].Ext = 0; /* we are not chaining */
1061 /* Put the request on the tail of the request queue */
1062 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1063 addQ(&host->reqQ, c);
1066 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1067 wait_for_completion(&wait);
1068 /* unlock the buffers from DMA */
1069 for(i=0; i<sg_used; i++) {
1070 temp64.val32.lower = c->SG[i].Addr.lower;
1071 temp64.val32.upper = c->SG[i].Addr.upper;
1072 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
1073 buff_size[i], PCI_DMA_BIDIRECTIONAL);
1075 /* Copy the error information out */
1076 ioc->error_info = *(c->err_info);
1077 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1078 cmd_free(host, c, 0);
1082 if (ioc->Request.Type.Direction == XFER_READ) {
1083 /* Copy the data out of the buffer we created */
1084 BYTE __user *ptr = ioc->buf;
1085 for(i=0; i< sg_used; i++) {
1086 if (copy_to_user(ptr, buff[i], buff_size[i])) {
1087 cmd_free(host, c, 0);
1091 ptr += buff_size[i];
1094 cmd_free(host, c, 0);
1098 for(i=0; i<sg_used; i++)
1113 * revalidate_allvol is for online array config utilities. After a
1114 * utility reconfigures the drives in the array, it can use this function
1115 * (through an ioctl) to make the driver zap any previous disk structs for
1116 * that controller and get new ones.
1118 * Right now I'm using the getgeometry() function to do this, but this
1119 * function should probably be finer grained and allow you to revalidate one
1120 * particualar logical volume (instead of all of them on a particular
1123 static int revalidate_allvol(ctlr_info_t *host)
1125 int ctlr = host->ctlr, i;
1126 unsigned long flags;
1128 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1129 if (host->usage_count > 1) {
1130 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1131 printk(KERN_WARNING "cciss: Device busy for volume"
1132 " revalidation (usage=%d)\n", host->usage_count);
1135 host->usage_count++;
1136 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1138 for(i=0; i< NWD; i++) {
1139 struct gendisk *disk = host->gendisk[i];
1141 request_queue_t *q = disk->queue;
1143 if (disk->flags & GENHD_FL_UP)
1146 blk_cleanup_queue(q);
1151 * Set the partition and block size structures for all volumes
1152 * on this controller to zero. We will reread all of this data
1154 memset(host->drv, 0, sizeof(drive_info_struct)
1157 * Tell the array controller not to give us any interrupts while
1158 * we check the new geometry. Then turn interrupts back on when
1161 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1162 cciss_getgeometry(ctlr);
1163 host->access.set_intr_mask(host, CCISS_INTR_ON);
1165 /* Loop through each real device */
1166 for (i = 0; i < NWD; i++) {
1167 struct gendisk *disk = host->gendisk[i];
1168 drive_info_struct *drv = &(host->drv[i]);
1169 /* we must register the controller even if no disks exist */
1170 /* this is for the online array utilities */
1171 if (!drv->heads && i)
1173 blk_queue_hardsect_size(drv->queue, drv->block_size);
1174 set_capacity(disk, drv->nr_blocks);
1177 host->usage_count--;
1181 static inline void complete_buffers(struct bio *bio, int status)
1184 struct bio *xbh = bio->bi_next;
1185 int nr_sectors = bio_sectors(bio);
1187 bio->bi_next = NULL;
1188 blk_finished_io(len);
1189 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
1195 static void cciss_softirq_done(struct request *rq)
1197 CommandList_struct *cmd = rq->completion_data;
1198 ctlr_info_t *h = hba[cmd->ctlr];
1199 unsigned long flags;
1203 if (cmd->Request.Type.Direction == XFER_READ)
1204 ddir = PCI_DMA_FROMDEVICE;
1206 ddir = PCI_DMA_TODEVICE;
1208 /* command did not need to be retried */
1209 /* unmap the DMA mapping for all the scatter gather elements */
1210 for(i=0; i<cmd->Header.SGList; i++) {
1211 temp64.val32.lower = cmd->SG[i].Addr.lower;
1212 temp64.val32.upper = cmd->SG[i].Addr.upper;
1213 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1216 complete_buffers(rq->bio, rq->errors);
1219 printk("Done with %p\n", rq);
1220 #endif /* CCISS_DEBUG */
1222 add_disk_randomness(rq->rq_disk);
1223 spin_lock_irqsave(&h->lock, flags);
1224 end_that_request_last(rq, rq->errors);
1226 spin_unlock_irqrestore(&h->lock, flags);
1229 /* This function will check the usage_count of the drive to be updated/added.
1230 * If the usage_count is zero then the drive information will be updated and
1231 * the disk will be re-registered with the kernel. If not then it will be
1232 * left alone for the next reboot. The exception to this is disk 0 which
1233 * will always be left registered with the kernel since it is also the
1234 * controller node. Any changes to disk 0 will show up on the next
1237 static void cciss_update_drive_info(int ctlr, int drv_index)
1239 ctlr_info_t *h = hba[ctlr];
1240 struct gendisk *disk;
1241 ReadCapdata_struct *size_buff = NULL;
1242 InquiryData_struct *inq_buff = NULL;
1243 unsigned int block_size;
1244 unsigned int total_size;
1245 unsigned long flags = 0;
1248 /* if the disk already exists then deregister it before proceeding*/
1249 if (h->drv[drv_index].raid_level != -1){
1250 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1251 h->drv[drv_index].busy_configuring = 1;
1252 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1253 ret = deregister_disk(h->gendisk[drv_index],
1254 &h->drv[drv_index], 0);
1255 h->drv[drv_index].busy_configuring = 0;
1258 /* If the disk is in use return */
1263 /* Get information about the disk and modify the driver sturcture */
1264 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1265 if (size_buff == NULL)
1267 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1268 if (inq_buff == NULL)
1271 cciss_read_capacity(ctlr, drv_index, size_buff, 1,
1272 &total_size, &block_size);
1273 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1274 inq_buff, &h->drv[drv_index]);
1277 disk = h->gendisk[drv_index];
1278 set_capacity(disk, h->drv[drv_index].nr_blocks);
1281 /* if it's the controller it's already added */
1283 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1285 /* Set up queue information */
1286 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1287 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1289 /* This is a hardware imposed limit. */
1290 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1292 /* This is a limit in the driver and could be eliminated. */
1293 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1295 blk_queue_max_sectors(disk->queue, 512);
1297 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1299 disk->queue->queuedata = hba[ctlr];
1301 blk_queue_hardsect_size(disk->queue,
1302 hba[ctlr]->drv[drv_index].block_size);
1304 h->drv[drv_index].queue = disk->queue;
1313 printk(KERN_ERR "cciss: out of memory\n");
1317 /* This function will find the first index of the controllers drive array
1318 * that has a -1 for the raid_level and will return that index. This is
1319 * where new drives will be added. If the index to be returned is greater
1320 * than the highest_lun index for the controller then highest_lun is set
1321 * to this new index. If there are no available indexes then -1 is returned.
1323 static int cciss_find_free_drive_index(int ctlr)
1327 for (i=0; i < CISS_MAX_LUN; i++){
1328 if (hba[ctlr]->drv[i].raid_level == -1){
1329 if (i > hba[ctlr]->highest_lun)
1330 hba[ctlr]->highest_lun = i;
1337 /* This function will add and remove logical drives from the Logical
1338 * drive array of the controller and maintain persistancy of ordering
1339 * so that mount points are preserved until the next reboot. This allows
1340 * for the removal of logical drives in the middle of the drive array
1341 * without a re-ordering of those drives.
1343 * h = The controller to perform the operations on
1344 * del_disk = The disk to remove if specified. If the value given
1345 * is NULL then no disk is removed.
1347 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1351 ReportLunData_struct *ld_buff = NULL;
1352 drive_info_struct *drv = NULL;
1359 unsigned long flags;
1361 /* Set busy_configuring flag for this operation */
1362 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1363 if (h->num_luns >= CISS_MAX_LUN){
1364 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1368 if (h->busy_configuring){
1369 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1372 h->busy_configuring = 1;
1374 /* if del_disk is NULL then we are being called to add a new disk
1375 * and update the logical drive table. If it is not NULL then
1376 * we will check if the disk is in use or not.
1378 if (del_disk != NULL){
1379 drv = get_drv(del_disk);
1380 drv->busy_configuring = 1;
1381 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1382 return_code = deregister_disk(del_disk, drv, 1);
1383 drv->busy_configuring = 0;
1384 h->busy_configuring = 0;
1387 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1388 if (!capable(CAP_SYS_RAWIO))
1391 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1392 if (ld_buff == NULL)
1395 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1396 sizeof(ReportLunData_struct), 0, 0, 0,
1399 if (return_code == IO_OK){
1400 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
1401 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
1402 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
1403 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1404 } else{ /* reading number of logical volumes failed */
1405 printk(KERN_WARNING "cciss: report logical volume"
1406 " command failed\n");
1411 num_luns = listlength / 8; /* 8 bytes per entry */
1412 if (num_luns > CISS_MAX_LUN){
1413 num_luns = CISS_MAX_LUN;
1414 printk(KERN_WARNING "cciss: more luns configured"
1415 " on controller than can be handled by"
1419 /* Compare controller drive array to drivers drive array.
1420 * Check for updates in the drive information and any new drives
1421 * on the controller.
1423 for (i=0; i < num_luns; i++){
1429 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1431 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1433 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1435 (unsigned int)(ld_buff->LUN[i][0]);
1437 /* Find if the LUN is already in the drive array
1438 * of the controller. If so then update its info
1439 * if not is use. If it does not exist then find
1440 * the first free index and add it.
1442 for (j=0; j <= h->highest_lun; j++){
1443 if (h->drv[j].LunID == lunid){
1449 /* check if the drive was found already in the array */
1451 drv_index = cciss_find_free_drive_index(ctlr);
1452 if (drv_index == -1)
1456 h->drv[drv_index].LunID = lunid;
1457 cciss_update_drive_info(ctlr, drv_index);
1463 h->busy_configuring = 0;
1464 /* We return -1 here to tell the ACU that we have registered/updated
1465 * all of the drives that we can and to keep it from calling us
1470 printk(KERN_ERR "cciss: out of memory\n");
1474 /* This function will deregister the disk and it's queue from the
1475 * kernel. It must be called with the controller lock held and the
1476 * drv structures busy_configuring flag set. It's parameters are:
1478 * disk = This is the disk to be deregistered
1479 * drv = This is the drive_info_struct associated with the disk to be
1480 * deregistered. It contains information about the disk used
1482 * clear_all = This flag determines whether or not the disk information
1483 * is going to be completely cleared out and the highest_lun
1484 * reset. Sometimes we want to clear out information about
1485 * the disk in preperation for re-adding it. In this case
1486 * the highest_lun should be left unchanged and the LunID
1487 * should not be cleared.
1489 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1492 ctlr_info_t *h = get_host(disk);
1494 if (!capable(CAP_SYS_RAWIO))
1497 /* make sure logical volume is NOT is use */
1498 if(clear_all || (h->gendisk[0] == disk)) {
1499 if (drv->usage_count > 1)
1503 if( drv->usage_count > 0 )
1506 /* invalidate the devices and deregister the disk. If it is disk
1507 * zero do not deregister it but just zero out it's values. This
1508 * allows us to delete disk zero but keep the controller registered.
1510 if (h->gendisk[0] != disk){
1512 request_queue_t *q = disk->queue;
1513 if (disk->flags & GENHD_FL_UP)
1516 blk_cleanup_queue(q);
1523 /* zero out the disk size info */
1525 drv->block_size = 0;
1529 drv->raid_level = -1; /* This can be used as a flag variable to
1530 * indicate that this element of the drive
1535 /* check to see if it was the last disk */
1536 if (drv == h->drv + h->highest_lun) {
1537 /* if so, find the new hightest lun */
1538 int i, newhighest =-1;
1539 for(i=0; i<h->highest_lun; i++) {
1540 /* if the disk has size > 0, it is available */
1541 if (h->drv[i].heads)
1544 h->highest_lun = newhighest;
1552 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
1554 unsigned int use_unit_num, /* 0: address the controller,
1555 1: address logical volume log_unit,
1556 2: periph device address is scsi3addr */
1557 unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
1560 ctlr_info_t *h= hba[ctlr];
1561 u64bit buff_dma_handle;
1564 c->cmd_type = CMD_IOCTL_PEND;
1565 c->Header.ReplyQueue = 0;
1567 c->Header.SGList = 1;
1568 c->Header.SGTotal= 1;
1570 c->Header.SGList = 0;
1571 c->Header.SGTotal= 0;
1573 c->Header.Tag.lower = c->busaddr;
1575 c->Request.Type.Type = cmd_type;
1576 if (cmd_type == TYPE_CMD) {
1579 /* If the logical unit number is 0 then, this is going
1580 to controller so It's a physical command
1581 mode = 0 target = 0. So we have nothing to write.
1582 otherwise, if use_unit_num == 1,
1583 mode = 1(volume set addressing) target = LUNID
1584 otherwise, if use_unit_num == 2,
1585 mode = 0(periph dev addr) target = scsi3addr */
1586 if (use_unit_num == 1) {
1587 c->Header.LUN.LogDev.VolId=
1588 h->drv[log_unit].LunID;
1589 c->Header.LUN.LogDev.Mode = 1;
1590 } else if (use_unit_num == 2) {
1591 memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
1592 c->Header.LUN.LogDev.Mode = 0;
1594 /* are we trying to read a vital product page */
1595 if(page_code != 0) {
1596 c->Request.CDB[1] = 0x01;
1597 c->Request.CDB[2] = page_code;
1599 c->Request.CDBLen = 6;
1600 c->Request.Type.Attribute = ATTR_SIMPLE;
1601 c->Request.Type.Direction = XFER_READ;
1602 c->Request.Timeout = 0;
1603 c->Request.CDB[0] = CISS_INQUIRY;
1604 c->Request.CDB[4] = size & 0xFF;
1606 case CISS_REPORT_LOG:
1607 case CISS_REPORT_PHYS:
1608 /* Talking to controller so It's a physical command
1609 mode = 00 target = 0. Nothing to write.
1611 c->Request.CDBLen = 12;
1612 c->Request.Type.Attribute = ATTR_SIMPLE;
1613 c->Request.Type.Direction = XFER_READ;
1614 c->Request.Timeout = 0;
1615 c->Request.CDB[0] = cmd;
1616 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1617 c->Request.CDB[7] = (size >> 16) & 0xFF;
1618 c->Request.CDB[8] = (size >> 8) & 0xFF;
1619 c->Request.CDB[9] = size & 0xFF;
1622 case CCISS_READ_CAPACITY:
1623 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1624 c->Header.LUN.LogDev.Mode = 1;
1625 c->Request.CDBLen = 10;
1626 c->Request.Type.Attribute = ATTR_SIMPLE;
1627 c->Request.Type.Direction = XFER_READ;
1628 c->Request.Timeout = 0;
1629 c->Request.CDB[0] = cmd;
1631 case CCISS_CACHE_FLUSH:
1632 c->Request.CDBLen = 12;
1633 c->Request.Type.Attribute = ATTR_SIMPLE;
1634 c->Request.Type.Direction = XFER_WRITE;
1635 c->Request.Timeout = 0;
1636 c->Request.CDB[0] = BMIC_WRITE;
1637 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1641 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1644 } else if (cmd_type == TYPE_MSG) {
1646 case 0: /* ABORT message */
1647 c->Request.CDBLen = 12;
1648 c->Request.Type.Attribute = ATTR_SIMPLE;
1649 c->Request.Type.Direction = XFER_WRITE;
1650 c->Request.Timeout = 0;
1651 c->Request.CDB[0] = cmd; /* abort */
1652 c->Request.CDB[1] = 0; /* abort a command */
1653 /* buff contains the tag of the command to abort */
1654 memcpy(&c->Request.CDB[4], buff, 8);
1656 case 1: /* RESET message */
1657 c->Request.CDBLen = 12;
1658 c->Request.Type.Attribute = ATTR_SIMPLE;
1659 c->Request.Type.Direction = XFER_WRITE;
1660 c->Request.Timeout = 0;
1661 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1662 c->Request.CDB[0] = cmd; /* reset */
1663 c->Request.CDB[1] = 0x04; /* reset a LUN */
1664 case 3: /* No-Op message */
1665 c->Request.CDBLen = 1;
1666 c->Request.Type.Attribute = ATTR_SIMPLE;
1667 c->Request.Type.Direction = XFER_WRITE;
1668 c->Request.Timeout = 0;
1669 c->Request.CDB[0] = cmd;
1673 "cciss%d: unknown message type %d\n",
1679 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1682 /* Fill in the scatter gather information */
1684 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1685 buff, size, PCI_DMA_BIDIRECTIONAL);
1686 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1687 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1688 c->SG[0].Len = size;
1689 c->SG[0].Ext = 0; /* we are not chaining */
1693 static int sendcmd_withirq(__u8 cmd,
1697 unsigned int use_unit_num,
1698 unsigned int log_unit,
1702 ctlr_info_t *h = hba[ctlr];
1703 CommandList_struct *c;
1704 u64bit buff_dma_handle;
1705 unsigned long flags;
1707 DECLARE_COMPLETION(wait);
1709 if ((c = cmd_alloc(h , 0)) == NULL)
1711 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1712 log_unit, page_code, NULL, cmd_type);
1713 if (return_status != IO_OK) {
1715 return return_status;
1720 /* Put the request on the tail of the queue and send it */
1721 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1725 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1727 wait_for_completion(&wait);
1729 if(c->err_info->CommandStatus != 0)
1730 { /* an error has occurred */
1731 switch(c->err_info->CommandStatus)
1733 case CMD_TARGET_STATUS:
1734 printk(KERN_WARNING "cciss: cmd %p has "
1735 " completed with errors\n", c);
1736 if( c->err_info->ScsiStatus)
1738 printk(KERN_WARNING "cciss: cmd %p "
1739 "has SCSI Status = %x\n",
1741 c->err_info->ScsiStatus);
1745 case CMD_DATA_UNDERRUN:
1746 case CMD_DATA_OVERRUN:
1747 /* expected for inquire and report lun commands */
1750 printk(KERN_WARNING "cciss: Cmd %p is "
1751 "reported invalid\n", c);
1752 return_status = IO_ERROR;
1754 case CMD_PROTOCOL_ERR:
1755 printk(KERN_WARNING "cciss: cmd %p has "
1756 "protocol error \n", c);
1757 return_status = IO_ERROR;
1759 case CMD_HARDWARE_ERR:
1760 printk(KERN_WARNING "cciss: cmd %p had "
1761 " hardware error\n", c);
1762 return_status = IO_ERROR;
1764 case CMD_CONNECTION_LOST:
1765 printk(KERN_WARNING "cciss: cmd %p had "
1766 "connection lost\n", c);
1767 return_status = IO_ERROR;
1770 printk(KERN_WARNING "cciss: cmd %p was "
1772 return_status = IO_ERROR;
1774 case CMD_ABORT_FAILED:
1775 printk(KERN_WARNING "cciss: cmd %p reports "
1776 "abort failed\n", c);
1777 return_status = IO_ERROR;
1779 case CMD_UNSOLICITED_ABORT:
1781 "cciss%d: unsolicited abort %p\n",
1783 if (c->retry_count < MAX_CMD_RETRIES) {
1785 "cciss%d: retrying %p\n",
1788 /* erase the old error information */
1789 memset(c->err_info, 0,
1790 sizeof(ErrorInfo_struct));
1791 return_status = IO_OK;
1792 INIT_COMPLETION(wait);
1795 return_status = IO_ERROR;
1798 printk(KERN_WARNING "cciss: cmd %p returned "
1799 "unknown status %x\n", c,
1800 c->err_info->CommandStatus);
1801 return_status = IO_ERROR;
1804 /* unlock the buffers from DMA */
1805 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1806 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1807 pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
1808 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1810 return(return_status);
1813 static void cciss_geometry_inquiry(int ctlr, int logvol,
1814 int withirq, unsigned int total_size,
1815 unsigned int block_size, InquiryData_struct *inq_buff,
1816 drive_info_struct *drv)
1819 memset(inq_buff, 0, sizeof(InquiryData_struct));
1821 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1822 inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
1824 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1825 sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
1826 if (return_code == IO_OK) {
1827 if(inq_buff->data_byte[8] == 0xFF) {
1829 "cciss: reading geometry failed, volume "
1830 "does not support reading geometry\n");
1831 drv->block_size = block_size;
1832 drv->nr_blocks = total_size;
1834 drv->sectors = 32; // Sectors per track
1835 drv->cylinders = total_size / 255 / 32;
1839 drv->block_size = block_size;
1840 drv->nr_blocks = total_size;
1841 drv->heads = inq_buff->data_byte[6];
1842 drv->sectors = inq_buff->data_byte[7];
1843 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1844 drv->cylinders += inq_buff->data_byte[5];
1845 drv->raid_level = inq_buff->data_byte[8];
1846 t = drv->heads * drv->sectors;
1848 drv->cylinders = total_size/t;
1851 } else { /* Get geometry failed */
1852 printk(KERN_WARNING "cciss: reading geometry failed\n");
1854 printk(KERN_INFO " heads= %d, sectors= %d, cylinders= %d\n\n",
1855 drv->heads, drv->sectors, drv->cylinders);
1858 cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
1859 int withirq, unsigned int *total_size, unsigned int *block_size)
1862 memset(buf, 0, sizeof(*buf));
1864 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1865 ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
1867 return_code = sendcmd(CCISS_READ_CAPACITY,
1868 ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
1869 if (return_code == IO_OK) {
1870 *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
1871 *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
1872 } else { /* read capacity command failed */
1873 printk(KERN_WARNING "cciss: read capacity failed\n");
1875 *block_size = BLOCK_SIZE;
1877 printk(KERN_INFO " blocks= %u block_size= %d\n",
1878 *total_size, *block_size);
1882 static int cciss_revalidate(struct gendisk *disk)
1884 ctlr_info_t *h = get_host(disk);
1885 drive_info_struct *drv = get_drv(disk);
1888 unsigned int block_size;
1889 unsigned int total_size;
1890 ReadCapdata_struct *size_buff = NULL;
1891 InquiryData_struct *inq_buff = NULL;
1893 for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
1895 if(h->drv[logvol].LunID == drv->LunID) {
1901 if (!FOUND) return 1;
1903 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1904 if (size_buff == NULL)
1906 printk(KERN_WARNING "cciss: out of memory\n");
1909 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1910 if (inq_buff == NULL)
1912 printk(KERN_WARNING "cciss: out of memory\n");
1917 cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
1918 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
1920 blk_queue_hardsect_size(drv->queue, drv->block_size);
1921 set_capacity(disk, drv->nr_blocks);
1929 * Wait polling for a command to complete.
1930 * The memory mapped FIFO is polled for the completion.
1931 * Used only at init time, interrupts from the HBA are disabled.
1933 static unsigned long pollcomplete(int ctlr)
1938 /* Wait (up to 20 seconds) for a command to complete */
1940 for (i = 20 * HZ; i > 0; i--) {
1941 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1942 if (done == FIFO_EMPTY)
1943 schedule_timeout_uninterruptible(1);
1947 /* Invalid address to tell caller we ran out of time */
1951 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
1953 /* We get in here if sendcmd() is polling for completions
1954 and gets some command back that it wasn't expecting --
1955 something other than that which it just sent down.
1956 Ordinarily, that shouldn't happen, but it can happen when
1957 the scsi tape stuff gets into error handling mode, and
1958 starts using sendcmd() to try to abort commands and
1959 reset tape drives. In that case, sendcmd may pick up
1960 completions of commands that were sent to logical drives
1961 through the block i/o system, or cciss ioctls completing, etc.
1962 In that case, we need to save those completions for later
1963 processing by the interrupt handler.
1966 #ifdef CONFIG_CISS_SCSI_TAPE
1967 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
1969 /* If it's not the scsi tape stuff doing error handling, (abort */
1970 /* or reset) then we don't expect anything weird. */
1971 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
1973 printk( KERN_WARNING "cciss cciss%d: SendCmd "
1974 "Invalid command list address returned! (%lx)\n",
1976 /* not much we can do. */
1977 #ifdef CONFIG_CISS_SCSI_TAPE
1981 /* We've sent down an abort or reset, but something else
1983 if (srl->ncompletions >= (NR_CMDS + 2)) {
1984 /* Uh oh. No room to save it for later... */
1985 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
1986 "reject list overflow, command lost!\n", ctlr);
1989 /* Save it for later */
1990 srl->complete[srl->ncompletions] = complete;
1991 srl->ncompletions++;
1997 * Send a command to the controller, and wait for it to complete.
1998 * Only used at init time.
2005 unsigned int use_unit_num, /* 0: address the controller,
2006 1: address logical volume log_unit,
2007 2: periph device address is scsi3addr */
2008 unsigned int log_unit,
2010 unsigned char *scsi3addr,
2013 CommandList_struct *c;
2015 unsigned long complete;
2016 ctlr_info_t *info_p= hba[ctlr];
2017 u64bit buff_dma_handle;
2018 int status, done = 0;
2020 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2021 printk(KERN_WARNING "cciss: unable to get memory");
2024 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2025 log_unit, page_code, scsi3addr, cmd_type);
2026 if (status != IO_OK) {
2027 cmd_free(info_p, c, 1);
2035 printk(KERN_DEBUG "cciss: turning intr off\n");
2036 #endif /* CCISS_DEBUG */
2037 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2039 /* Make sure there is room in the command FIFO */
2040 /* Actually it should be completely empty at this time */
2041 /* unless we are in here doing error handling for the scsi */
2042 /* tape side of the driver. */
2043 for (i = 200000; i > 0; i--)
2045 /* if fifo isn't full go */
2046 if (!(info_p->access.fifo_full(info_p)))
2052 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2053 " waiting!\n", ctlr);
2058 info_p->access.submit_command(info_p, c);
2061 complete = pollcomplete(ctlr);
2064 printk(KERN_DEBUG "cciss: command completed\n");
2065 #endif /* CCISS_DEBUG */
2067 if (complete == 1) {
2068 printk( KERN_WARNING
2069 "cciss cciss%d: SendCmd Timeout out, "
2070 "No command list address returned!\n",
2077 /* This will need to change for direct lookup completions */
2078 if ( (complete & CISS_ERROR_BIT)
2079 && (complete & ~CISS_ERROR_BIT) == c->busaddr)
2081 /* if data overrun or underun on Report command
2084 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2085 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2086 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2087 ((c->err_info->CommandStatus ==
2088 CMD_DATA_OVERRUN) ||
2089 (c->err_info->CommandStatus ==
2093 complete = c->busaddr;
2095 if (c->err_info->CommandStatus ==
2096 CMD_UNSOLICITED_ABORT) {
2097 printk(KERN_WARNING "cciss%d: "
2098 "unsolicited abort %p\n",
2100 if (c->retry_count < MAX_CMD_RETRIES) {
2102 "cciss%d: retrying %p\n",
2105 /* erase the old error */
2107 memset(c->err_info, 0,
2108 sizeof(ErrorInfo_struct));
2112 "cciss%d: retried %p too "
2113 "many times\n", ctlr, c);
2117 } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
2118 printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
2122 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2123 " Error %x \n", ctlr,
2124 c->err_info->CommandStatus);
2125 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2127 " size %x\n num %x value %x\n", ctlr,
2128 c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
2129 c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
2130 c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
2135 /* This will need changing for direct lookup completions */
2136 if (complete != c->busaddr) {
2137 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2138 BUG(); /* we are pretty much hosed if we get here. */
2146 /* unlock the data buffer from DMA */
2147 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2148 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2149 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2150 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2151 #ifdef CONFIG_CISS_SCSI_TAPE
2152 /* if we saved some commands for later, process them now. */
2153 if (info_p->scsi_rejects.ncompletions > 0)
2154 do_cciss_intr(0, info_p, NULL);
2156 cmd_free(info_p, c, 1);
2160 * Map (physical) PCI mem into (virtual) kernel space
2162 static void __iomem *remap_pci_mem(ulong base, ulong size)
2164 ulong page_base = ((ulong) base) & PAGE_MASK;
2165 ulong page_offs = ((ulong) base) - page_base;
2166 void __iomem *page_remapped = ioremap(page_base, page_offs+size);
2168 return page_remapped ? (page_remapped + page_offs) : NULL;
2172 * Takes jobs of the Q and sends them to the hardware, then puts it on
2173 * the Q to wait for completion.
2175 static void start_io( ctlr_info_t *h)
2177 CommandList_struct *c;
2179 while(( c = h->reqQ) != NULL )
2181 /* can't do anything if fifo is full */
2182 if ((h->access.fifo_full(h))) {
2183 printk(KERN_WARNING "cciss: fifo full\n");
2187 /* Get the first entry from the Request Q */
2188 removeQ(&(h->reqQ), c);
2191 /* Tell the controller execute command */
2192 h->access.submit_command(h, c);
2194 /* Put job onto the completed Q */
2195 addQ (&(h->cmpQ), c);
2198 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2199 /* Zeros out the error record and then resends the command back */
2200 /* to the controller */
2201 static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
2203 /* erase the old error information */
2204 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2206 /* add it to software queue and then send it to the controller */
2209 if(h->Qdepth > h->maxQsinceinit)
2210 h->maxQsinceinit = h->Qdepth;
2215 /* checks the status of the job and calls complete buffers to mark all
2216 * buffers for the completed job. Note that this function does not need
2217 * to hold the hba/queue lock.
2219 static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
2228 if(cmd->err_info->CommandStatus != 0)
2229 { /* an error has occurred */
2230 switch(cmd->err_info->CommandStatus)
2232 unsigned char sense_key;
2233 case CMD_TARGET_STATUS:
2236 if( cmd->err_info->ScsiStatus == 0x02)
2238 printk(KERN_WARNING "cciss: cmd %p "
2239 "has CHECK CONDITION "
2240 " byte 2 = 0x%x\n", cmd,
2241 cmd->err_info->SenseInfo[2]
2243 /* check the sense key */
2245 cmd->err_info->SenseInfo[2];
2246 /* no status or recovered error */
2247 if((sense_key == 0x0) ||
2254 printk(KERN_WARNING "cciss: cmd %p "
2255 "has SCSI Status 0x%x\n",
2256 cmd, cmd->err_info->ScsiStatus);
2259 case CMD_DATA_UNDERRUN:
2260 printk(KERN_WARNING "cciss: cmd %p has"
2261 " completed with data underrun "
2264 case CMD_DATA_OVERRUN:
2265 printk(KERN_WARNING "cciss: cmd %p has"
2266 " completed with data overrun "
2270 printk(KERN_WARNING "cciss: cmd %p is "
2271 "reported invalid\n", cmd);
2274 case CMD_PROTOCOL_ERR:
2275 printk(KERN_WARNING "cciss: cmd %p has "
2276 "protocol error \n", cmd);
2279 case CMD_HARDWARE_ERR:
2280 printk(KERN_WARNING "cciss: cmd %p had "
2281 " hardware error\n", cmd);
2284 case CMD_CONNECTION_LOST:
2285 printk(KERN_WARNING "cciss: cmd %p had "
2286 "connection lost\n", cmd);
2290 printk(KERN_WARNING "cciss: cmd %p was "
2294 case CMD_ABORT_FAILED:
2295 printk(KERN_WARNING "cciss: cmd %p reports "
2296 "abort failed\n", cmd);
2299 case CMD_UNSOLICITED_ABORT:
2300 printk(KERN_WARNING "cciss%d: unsolicited "
2301 "abort %p\n", h->ctlr, cmd);
2302 if (cmd->retry_count < MAX_CMD_RETRIES) {
2305 "cciss%d: retrying %p\n",
2310 "cciss%d: %p retried too "
2311 "many times\n", h->ctlr, cmd);
2315 printk(KERN_WARNING "cciss: cmd %p timedout\n",
2320 printk(KERN_WARNING "cciss: cmd %p returned "
2321 "unknown status %x\n", cmd,
2322 cmd->err_info->CommandStatus);
2326 /* We need to return this command */
2328 resend_cciss_cmd(h,cmd);
2332 cmd->rq->completion_data = cmd;
2333 cmd->rq->errors = status;
2334 blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
2335 blk_complete_request(cmd->rq);
2339 * Get a request and submit it to the controller.
2341 static void do_cciss_request(request_queue_t *q)
2343 ctlr_info_t *h= q->queuedata;
2344 CommandList_struct *c;
2346 struct request *creq;
2348 struct scatterlist tmp_sg[MAXSGENTRIES];
2349 drive_info_struct *drv;
2352 /* We call start_io here in case there is a command waiting on the
2353 * queue that has not been sent.
2355 if (blk_queue_plugged(q))
2359 creq = elv_next_request(q);
2363 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2365 if (( c = cmd_alloc(h, 1)) == NULL)
2368 blkdev_dequeue_request(creq);
2370 spin_unlock_irq(q->queue_lock);
2372 c->cmd_type = CMD_RWREQ;
2375 /* fill in the request */
2376 drv = creq->rq_disk->private_data;
2377 c->Header.ReplyQueue = 0; // unused in simple mode
2378 /* got command from pool, so use the command block index instead */
2379 /* for direct lookups. */
2380 /* The first 2 bits are reserved for controller error reporting. */
2381 c->Header.Tag.lower = (c->cmdindex << 3);
2382 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2383 c->Header.LUN.LogDev.VolId= drv->LunID;
2384 c->Header.LUN.LogDev.Mode = 1;
2385 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2386 c->Request.Type.Type = TYPE_CMD; // It is a command.
2387 c->Request.Type.Attribute = ATTR_SIMPLE;
2388 c->Request.Type.Direction =
2389 (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE;
2390 c->Request.Timeout = 0; // Don't time out
2391 c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
2392 start_blk = creq->sector;
2394 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
2395 (int) creq->nr_sectors);
2396 #endif /* CCISS_DEBUG */
2398 seg = blk_rq_map_sg(q, creq, tmp_sg);
2400 /* get the DMA records for the setup */
2401 if (c->Request.Type.Direction == XFER_READ)
2402 dir = PCI_DMA_FROMDEVICE;
2404 dir = PCI_DMA_TODEVICE;
2406 for (i=0; i<seg; i++)
2408 c->SG[i].Len = tmp_sg[i].length;
2409 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2410 tmp_sg[i].offset, tmp_sg[i].length,
2412 c->SG[i].Addr.lower = temp64.val32.lower;
2413 c->SG[i].Addr.upper = temp64.val32.upper;
2414 c->SG[i].Ext = 0; // we are not chaining
2416 /* track how many SG entries we are using */
2421 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
2422 #endif /* CCISS_DEBUG */
2424 c->Header.SGList = c->Header.SGTotal = seg;
2425 c->Request.CDB[1]= 0;
2426 c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
2427 c->Request.CDB[3]= (start_blk >> 16) & 0xff;
2428 c->Request.CDB[4]= (start_blk >> 8) & 0xff;
2429 c->Request.CDB[5]= start_blk & 0xff;
2430 c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
2431 c->Request.CDB[7]= (creq->nr_sectors >> 8) & 0xff;
2432 c->Request.CDB[8]= creq->nr_sectors & 0xff;
2433 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2435 spin_lock_irq(q->queue_lock);
2439 if(h->Qdepth > h->maxQsinceinit)
2440 h->maxQsinceinit = h->Qdepth;
2446 /* We will already have the driver lock here so not need
2452 static inline unsigned long get_next_completion(ctlr_info_t *h)
2454 #ifdef CONFIG_CISS_SCSI_TAPE
2455 /* Any rejects from sendcmd() lying around? Process them first */
2456 if (h->scsi_rejects.ncompletions == 0)
2457 return h->access.command_completed(h);
2459 struct sendcmd_reject_list *srl;
2461 srl = &h->scsi_rejects;
2462 n = --srl->ncompletions;
2463 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2465 return srl->complete[n];
2468 return h->access.command_completed(h);
2472 static inline int interrupt_pending(ctlr_info_t *h)
2474 #ifdef CONFIG_CISS_SCSI_TAPE
2475 return ( h->access.intr_pending(h)
2476 || (h->scsi_rejects.ncompletions > 0));
2478 return h->access.intr_pending(h);
2482 static inline long interrupt_not_for_us(ctlr_info_t *h)
2484 #ifdef CONFIG_CISS_SCSI_TAPE
2485 return (((h->access.intr_pending(h) == 0) ||
2486 (h->interrupts_enabled == 0))
2487 && (h->scsi_rejects.ncompletions == 0));
2489 return (((h->access.intr_pending(h) == 0) ||
2490 (h->interrupts_enabled == 0)));
2494 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
2496 ctlr_info_t *h = dev_id;
2497 CommandList_struct *c;
2498 unsigned long flags;
2501 int start_queue = h->next_to_run;
2503 if (interrupt_not_for_us(h))
2506 * If there are completed commands in the completion queue,
2507 * we had better do something about it.
2509 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2510 while (interrupt_pending(h)) {
2511 while((a = get_next_completion(h)) != FIFO_EMPTY) {
2515 if (a2 >= NR_CMDS) {
2516 printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
2517 fail_all_cmds(h->ctlr);
2521 c = h->cmd_pool + a2;
2526 if ((c = h->cmpQ) == NULL) {
2527 printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
2530 while(c->busaddr != a) {
2537 * If we've found the command, take it off the
2538 * completion Q and free it
2540 if (c->busaddr == a) {
2541 removeQ(&h->cmpQ, c);
2542 if (c->cmd_type == CMD_RWREQ) {
2543 complete_command(h, c, 0);
2544 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2545 complete(c->waiting);
2547 # ifdef CONFIG_CISS_SCSI_TAPE
2548 else if (c->cmd_type == CMD_SCSI)
2549 complete_scsi_command(c, 0, a1);
2556 /* check to see if we have maxed out the number of commands that can
2557 * be placed on the queue. If so then exit. We do this check here
2558 * in case the interrupt we serviced was from an ioctl and did not
2559 * free any new commands.
2561 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2564 /* We have room on the queue for more commands. Now we need to queue
2565 * them up. We will also keep track of the next queue to run so
2566 * that every queue gets a chance to be started first.
2568 for (j=0; j < h->highest_lun + 1; j++){
2569 int curr_queue = (start_queue + j) % (h->highest_lun + 1);
2570 /* make sure the disk has been added and the drive is real
2571 * because this can be called from the middle of init_one.
2573 if(!(h->drv[curr_queue].queue) ||
2574 !(h->drv[curr_queue].heads))
2576 blk_start_queue(h->gendisk[curr_queue]->queue);
2578 /* check to see if we have maxed out the number of commands
2579 * that can be placed on the queue.
2581 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2583 if (curr_queue == start_queue){
2584 h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
2587 h->next_to_run = curr_queue;
2591 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
2596 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2600 * We cannot read the structure directly, for portablity we must use
2602 * This is for debug only.
2605 static void print_cfg_table( CfgTable_struct *tb)
2610 printk("Controller Configuration information\n");
2611 printk("------------------------------------\n");
2613 temp_name[i] = readb(&(tb->Signature[i]));
2615 printk(" Signature = %s\n", temp_name);
2616 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2617 printk(" Transport methods supported = 0x%x\n",
2618 readl(&(tb-> TransportSupport)));
2619 printk(" Transport methods active = 0x%x\n",
2620 readl(&(tb->TransportActive)));
2621 printk(" Requested transport Method = 0x%x\n",
2622 readl(&(tb->HostWrite.TransportRequest)));
2623 printk(" Coalese Interrupt Delay = 0x%x\n",
2624 readl(&(tb->HostWrite.CoalIntDelay)));
2625 printk(" Coalese Interrupt Count = 0x%x\n",
2626 readl(&(tb->HostWrite.CoalIntCount)));
2627 printk(" Max outstanding commands = 0x%d\n",
2628 readl(&(tb->CmdsOutMax)));
2629 printk(" Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
2631 temp_name[i] = readb(&(tb->ServerName[i]));
2632 temp_name[16] = '\0';
2633 printk(" Server Name = %s\n", temp_name);
2634 printk(" Heartbeat Counter = 0x%x\n\n\n",
2635 readl(&(tb->HeartBeat)));
2637 #endif /* CCISS_DEBUG */
2639 static int find_PCI_BAR_index(struct pci_dev *pdev,
2640 unsigned long pci_bar_addr)
2642 int i, offset, mem_type, bar_type;
2643 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2646 for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
2647 bar_type = pci_resource_flags(pdev, i) &
2648 PCI_BASE_ADDRESS_SPACE;
2649 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2652 mem_type = pci_resource_flags(pdev, i) &
2653 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2655 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2656 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2657 offset += 4; /* 32 bit */
2659 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2662 default: /* reserved in PCI 2.2 */
2663 printk(KERN_WARNING "Base address is invalid\n");
2668 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2674 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
2675 * controllers that are capable. If not, we use IO-APIC mode.
2678 static void __devinit cciss_interrupt_mode(ctlr_info_t *c, struct pci_dev *pdev, __u32 board_id)
2680 #ifdef CONFIG_PCI_MSI
2682 struct msix_entry cciss_msix_entries[4] = {{0,0}, {0,1},
2685 /* Some boards advertise MSI but don't really support it */
2686 if ((board_id == 0x40700E11) ||
2687 (board_id == 0x40800E11) ||
2688 (board_id == 0x40820E11) ||
2689 (board_id == 0x40830E11))
2690 goto default_int_mode;
2692 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2693 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2695 c->intr[0] = cciss_msix_entries[0].vector;
2696 c->intr[1] = cciss_msix_entries[1].vector;
2697 c->intr[2] = cciss_msix_entries[2].vector;
2698 c->intr[3] = cciss_msix_entries[3].vector;
2703 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2704 "available\n", err);
2706 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2710 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2711 if (!pci_enable_msi(pdev)) {
2712 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2716 printk(KERN_WARNING "cciss: MSI init failed\n");
2717 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2722 #endif /* CONFIG_PCI_MSI */
2723 /* if we get here we're going to use the default interrupt mode */
2724 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2728 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2730 ushort subsystem_vendor_id, subsystem_device_id, command;
2731 __u32 board_id, scratchpad = 0;
2733 __u32 cfg_base_addr;
2734 __u64 cfg_base_addr_index;
2737 /* check to see if controller has been disabled */
2738 /* BEFORE trying to enable it */
2739 (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
2740 if(!(command & 0x02))
2742 printk(KERN_WARNING "cciss: controller appears to be disabled\n");
2746 err = pci_enable_device(pdev);
2749 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2753 err = pci_request_regions(pdev, "cciss");
2755 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
2757 goto err_out_disable_pdev;
2760 subsystem_vendor_id = pdev->subsystem_vendor;
2761 subsystem_device_id = pdev->subsystem_device;
2762 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2763 subsystem_vendor_id);
2766 printk("command = %x\n", command);
2767 printk("irq = %x\n", pdev->irq);
2768 printk("board_id = %x\n", board_id);
2769 #endif /* CCISS_DEBUG */
2771 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2772 * else we use the IO-APIC interrupt assigned to us by system ROM.
2774 cciss_interrupt_mode(c, pdev, board_id);
2777 * Memory base addr is first addr , the second points to the config
2781 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2783 printk("address 0 = %x\n", c->paddr);
2784 #endif /* CCISS_DEBUG */
2785 c->vaddr = remap_pci_mem(c->paddr, 200);
2787 /* Wait for the board to become ready. (PCI hotplug needs this.)
2788 * We poll for up to 120 secs, once per 100ms. */
2789 for (i=0; i < 1200; i++) {
2790 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2791 if (scratchpad == CCISS_FIRMWARE_READY)
2793 set_current_state(TASK_INTERRUPTIBLE);
2794 schedule_timeout(HZ / 10); /* wait 100ms */
2796 if (scratchpad != CCISS_FIRMWARE_READY) {
2797 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
2799 goto err_out_free_res;
2802 /* get the address index number */
2803 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2804 cfg_base_addr &= (__u32) 0x0000ffff;
2806 printk("cfg base address = %x\n", cfg_base_addr);
2807 #endif /* CCISS_DEBUG */
2808 cfg_base_addr_index =
2809 find_PCI_BAR_index(pdev, cfg_base_addr);
2811 printk("cfg base address index = %x\n", cfg_base_addr_index);
2812 #endif /* CCISS_DEBUG */
2813 if (cfg_base_addr_index == -1) {
2814 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2816 goto err_out_free_res;
2819 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2821 printk("cfg offset = %x\n", cfg_offset);
2822 #endif /* CCISS_DEBUG */
2823 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2824 cfg_base_addr_index) + cfg_offset,
2825 sizeof(CfgTable_struct));
2826 c->board_id = board_id;
2829 print_cfg_table(c->cfgtable);
2830 #endif /* CCISS_DEBUG */
2832 for(i=0; i<ARRAY_SIZE(products); i++) {
2833 if (board_id == products[i].board_id) {
2834 c->product_name = products[i].product_name;
2835 c->access = *(products[i].access);
2839 if (i == ARRAY_SIZE(products)) {
2840 printk(KERN_WARNING "cciss: Sorry, I don't know how"
2841 " to access the Smart Array controller %08lx\n",
2842 (unsigned long)board_id);
2844 goto err_out_free_res;
2846 if ( (readb(&c->cfgtable->Signature[0]) != 'C') ||
2847 (readb(&c->cfgtable->Signature[1]) != 'I') ||
2848 (readb(&c->cfgtable->Signature[2]) != 'S') ||
2849 (readb(&c->cfgtable->Signature[3]) != 'S') )
2851 printk("Does not appear to be a valid CISS config table\n");
2853 goto err_out_free_res;
2858 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2860 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2862 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2867 printk("Trying to put board into Simple mode\n");
2868 #endif /* CCISS_DEBUG */
2869 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2870 /* Update the field, and then ring the doorbell */
2871 writel( CFGTBL_Trans_Simple,
2872 &(c->cfgtable->HostWrite.TransportRequest));
2873 writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2875 /* under certain very rare conditions, this can take awhile.
2876 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2877 * as we enter this code.) */
2878 for(i=0;i<MAX_CONFIG_WAIT;i++) {
2879 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2881 /* delay and try again */
2882 set_current_state(TASK_INTERRUPTIBLE);
2883 schedule_timeout(10);
2887 printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
2888 #endif /* CCISS_DEBUG */
2890 print_cfg_table(c->cfgtable);
2891 #endif /* CCISS_DEBUG */
2893 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
2895 printk(KERN_WARNING "cciss: unable to get board into"
2898 goto err_out_free_res;
2903 pci_release_regions(pdev);
2905 err_out_disable_pdev:
2906 pci_disable_device(pdev);
2911 * Gets information about the local volumes attached to the controller.
2913 static void cciss_getgeometry(int cntl_num)
2915 ReportLunData_struct *ld_buff;
2916 ReadCapdata_struct *size_buff;
2917 InquiryData_struct *inq_buff;
2925 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
2926 if (ld_buff == NULL)
2928 printk(KERN_ERR "cciss: out of memory\n");
2931 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
2932 if (size_buff == NULL)
2934 printk(KERN_ERR "cciss: out of memory\n");
2938 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
2939 if (inq_buff == NULL)
2941 printk(KERN_ERR "cciss: out of memory\n");
2946 /* Get the firmware version */
2947 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
2948 sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
2949 if (return_code == IO_OK)
2951 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
2952 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
2953 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
2954 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
2955 } else /* send command failed */
2957 printk(KERN_WARNING "cciss: unable to determine firmware"
2958 " version of controller\n");
2960 /* Get the number of logical volumes */
2961 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
2962 sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
2964 if( return_code == IO_OK)
2967 printk("LUN Data\n--------------------------\n");
2968 #endif /* CCISS_DEBUG */
2970 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
2971 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
2972 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
2973 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
2974 } else /* reading number of logical volumes failed */
2976 printk(KERN_WARNING "cciss: report logical volume"
2977 " command failed\n");
2980 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
2981 if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
2983 printk(KERN_ERR "ciss: only %d number of logical volumes supported\n",
2985 hba[cntl_num]->num_luns = CISS_MAX_LUN;
2988 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
2989 ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
2990 ld_buff->LUNListLength[3], hba[cntl_num]->num_luns);
2991 #endif /* CCISS_DEBUG */
2993 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
2994 // for(i=0; i< hba[cntl_num]->num_luns; i++)
2995 for(i=0; i < CISS_MAX_LUN; i++)
2997 if (i < hba[cntl_num]->num_luns){
2998 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3000 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3002 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3004 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3006 hba[cntl_num]->drv[i].LunID = lunid;
3010 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
3011 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3012 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3013 hba[cntl_num]->drv[i].LunID);
3014 #endif /* CCISS_DEBUG */
3015 cciss_read_capacity(cntl_num, i, size_buff, 0,
3016 &total_size, &block_size);
3017 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3018 block_size, inq_buff, &hba[cntl_num]->drv[i]);
3020 /* initialize raid_level to indicate a free space */
3021 hba[cntl_num]->drv[i].raid_level = -1;
3029 /* Function to find the first free pointer into our hba[] array */
3030 /* Returns -1 if no free entries are left. */
3031 static int alloc_cciss_hba(void)
3033 struct gendisk *disk[NWD];
3035 for (n = 0; n < NWD; n++) {
3036 disk[n] = alloc_disk(1 << NWD_SHIFT);
3041 for(i=0; i< MAX_CTLR; i++) {
3044 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3047 for (n = 0; n < NWD; n++)
3048 p->gendisk[n] = disk[n];
3053 printk(KERN_WARNING "cciss: This driver supports a maximum"
3054 " of %d controllers.\n", MAX_CTLR);
3057 printk(KERN_ERR "cciss: out of memory.\n");
3064 static void free_hba(int i)
3066 ctlr_info_t *p = hba[i];
3070 for (n = 0; n < NWD; n++)
3071 put_disk(p->gendisk[n]);
3076 * This is it. Find all the controllers and register them. I really hate
3077 * stealing all these major device numbers.
3078 * returns the number of block devices registered.
3080 static int __devinit cciss_init_one(struct pci_dev *pdev,
3081 const struct pci_device_id *ent)
3089 i = alloc_cciss_hba();
3093 hba[i]->busy_initializing = 1;
3095 if (cciss_pci_init(hba[i], pdev) != 0)
3098 sprintf(hba[i]->devname, "cciss%d", i);
3100 hba[i]->pdev = pdev;
3102 /* configure PCI DMA stuff */
3103 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3105 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3108 printk(KERN_ERR "cciss: no suitable DMA available\n");
3113 * register with the major number, or get a dynamic major number
3114 * by passing 0 as argument. This is done for greater than
3115 * 8 controller support.
3117 if (i < MAX_CTLR_ORIG)
3118 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3119 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3120 if(rc == -EBUSY || rc == -EINVAL) {
3122 "cciss: Unable to get major number %d for %s "
3123 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3127 if (i >= MAX_CTLR_ORIG)
3131 /* make sure the board interrupts are off */
3132 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3133 if( request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3134 SA_INTERRUPT | SA_SHIRQ, hba[i]->devname, hba[i])) {
3135 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3136 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3140 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3141 hba[i]->devname, pdev->device, pci_name(pdev),
3142 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3144 hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
3145 hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
3146 hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3147 &(hba[i]->cmd_pool_dhandle));
3148 hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
3149 hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3150 &(hba[i]->errinfo_pool_dhandle));
3151 if((hba[i]->cmd_pool_bits == NULL)
3152 || (hba[i]->cmd_pool == NULL)
3153 || (hba[i]->errinfo_pool == NULL)) {
3154 printk( KERN_ERR "cciss: out of memory");
3157 #ifdef CONFIG_CISS_SCSI_TAPE
3158 hba[i]->scsi_rejects.complete =
3159 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3160 (NR_CMDS + 5), GFP_KERNEL);
3161 if (hba[i]->scsi_rejects.complete == NULL) {
3162 printk( KERN_ERR "cciss: out of memory");
3166 spin_lock_init(&hba[i]->lock);
3168 /* Initialize the pdev driver private data.
3169 have it point to hba[i]. */
3170 pci_set_drvdata(pdev, hba[i]);
3171 /* command and error info recs zeroed out before
3173 memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
3176 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
3177 #endif /* CCISS_DEBUG */
3179 cciss_getgeometry(i);
3181 cciss_scsi_setup(i);
3183 /* Turn the interrupts on so we can service requests */
3184 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3187 hba[i]->busy_initializing = 0;
3189 for(j=0; j < NWD; j++) { /* mfm */
3190 drive_info_struct *drv = &(hba[i]->drv[j]);
3191 struct gendisk *disk = hba[i]->gendisk[j];
3193 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3196 "cciss: unable to allocate queue for disk %d\n",
3202 q->backing_dev_info.ra_pages = READ_AHEAD;
3203 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3205 /* This is a hardware imposed limit. */
3206 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3208 /* This is a limit in the driver and could be eliminated. */
3209 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3211 blk_queue_max_sectors(q, 512);
3213 blk_queue_softirq_done(q, cciss_softirq_done);
3215 q->queuedata = hba[i];
3216 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3217 sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
3218 disk->major = hba[i]->major;
3219 disk->first_minor = j << NWD_SHIFT;
3220 disk->fops = &cciss_fops;
3222 disk->private_data = drv;
3223 disk->driverfs_dev = &pdev->dev;
3224 /* we must register the controller even if no disks exist */
3225 /* this is for the online array utilities */
3226 if(!drv->heads && j)
3228 blk_queue_hardsect_size(q, drv->block_size);
3229 set_capacity(disk, drv->nr_blocks);
3236 #ifdef CONFIG_CISS_SCSI_TAPE
3237 kfree(hba[i]->scsi_rejects.complete);
3239 kfree(hba[i]->cmd_pool_bits);
3240 if(hba[i]->cmd_pool)
3241 pci_free_consistent(hba[i]->pdev,
3242 NR_CMDS * sizeof(CommandList_struct),
3243 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3244 if(hba[i]->errinfo_pool)
3245 pci_free_consistent(hba[i]->pdev,
3246 NR_CMDS * sizeof( ErrorInfo_struct),
3247 hba[i]->errinfo_pool,
3248 hba[i]->errinfo_pool_dhandle);
3249 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3251 unregister_blkdev(hba[i]->major, hba[i]->devname);
3253 hba[i]->busy_initializing = 0;
3258 static void __devexit cciss_remove_one (struct pci_dev *pdev)
3260 ctlr_info_t *tmp_ptr;
3265 if (pci_get_drvdata(pdev) == NULL)
3267 printk( KERN_ERR "cciss: Unable to remove device \n");
3270 tmp_ptr = pci_get_drvdata(pdev);
3274 printk(KERN_ERR "cciss: device appears to "
3275 "already be removed \n");
3278 /* Turn board interrupts off and send the flush cache command */
3279 /* sendcmd will turn off interrupt, and send the flush...
3280 * To write all data in the battery backed cache to disks */
3281 memset(flush_buf, 0, 4);
3282 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3284 if(return_code != IO_OK)
3286 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3289 free_irq(hba[i]->intr[2], hba[i]);
3291 #ifdef CONFIG_PCI_MSI
3292 if (hba[i]->msix_vector)
3293 pci_disable_msix(hba[i]->pdev);
3294 else if (hba[i]->msi_vector)
3295 pci_disable_msi(hba[i]->pdev);
3296 #endif /* CONFIG_PCI_MSI */
3298 iounmap(hba[i]->vaddr);
3299 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3300 unregister_blkdev(hba[i]->major, hba[i]->devname);
3301 remove_proc_entry(hba[i]->devname, proc_cciss);
3303 /* remove it from the disk list */
3304 for (j = 0; j < NWD; j++) {
3305 struct gendisk *disk = hba[i]->gendisk[j];
3307 request_queue_t *q = disk->queue;
3309 if (disk->flags & GENHD_FL_UP)
3312 blk_cleanup_queue(q);
3316 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3317 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3318 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3319 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3320 kfree(hba[i]->cmd_pool_bits);
3321 #ifdef CONFIG_CISS_SCSI_TAPE
3322 kfree(hba[i]->scsi_rejects.complete);
3324 pci_release_regions(pdev);
3325 pci_disable_device(pdev);
3326 pci_set_drvdata(pdev, NULL);
3330 static struct pci_driver cciss_pci_driver = {
3332 .probe = cciss_init_one,
3333 .remove = __devexit_p(cciss_remove_one),
3334 .id_table = cciss_pci_device_id, /* id_table */
3338 * This is it. Register the PCI driver information for the cards we control
3339 * the OS will call our registered routines when it finds one of our cards.
3341 static int __init cciss_init(void)
3343 printk(KERN_INFO DRIVER_NAME "\n");
3345 /* Register for our PCI devices */
3346 return pci_register_driver(&cciss_pci_driver);
3349 static void __exit cciss_cleanup(void)
3353 pci_unregister_driver(&cciss_pci_driver);
3354 /* double check that all controller entrys have been removed */
3355 for (i=0; i< MAX_CTLR; i++)
3359 printk(KERN_WARNING "cciss: had to remove"
3360 " controller %d\n", i);
3361 cciss_remove_one(hba[i]->pdev);
3364 remove_proc_entry("cciss", proc_root_driver);
3367 static void fail_all_cmds(unsigned long ctlr)
3369 /* If we get here, the board is apparently dead. */
3370 ctlr_info_t *h = hba[ctlr];
3371 CommandList_struct *c;
3372 unsigned long flags;
3374 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3375 h->alive = 0; /* the controller apparently died... */
3377 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3379 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3381 /* move everything off the request queue onto the completed queue */
3382 while( (c = h->reqQ) != NULL ) {
3383 removeQ(&(h->reqQ), c);
3385 addQ (&(h->cmpQ), c);
3388 /* Now, fail everything on the completed queue with a HW error */
3389 while( (c = h->cmpQ) != NULL ) {
3390 removeQ(&h->cmpQ, c);
3391 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3392 if (c->cmd_type == CMD_RWREQ) {
3393 complete_command(h, c, 0);
3394 } else if (c->cmd_type == CMD_IOCTL_PEND)
3395 complete(c->waiting);
3396 #ifdef CONFIG_CISS_SCSI_TAPE
3397 else if (c->cmd_type == CMD_SCSI)
3398 complete_scsi_command(c, 0, 0);
3401 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3405 module_init(cciss_init);
3406 module_exit(cciss_cleanup);