2 * Disk Array driver for HP SA 5xxx and 6xxx Controllers
3 * Copyright 2000, 2005 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 <asm/uaccess.h>
44 #include <linux/dma-mapping.h>
45 #include <linux/blkdev.h>
46 #include <linux/genhd.h>
47 #include <linux/completion.h>
49 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
50 #define DRIVER_NAME "HP CISS Driver (v 2.6.8)"
51 #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,8)
53 /* Embedded module documentation macros - see modules.h */
54 MODULE_AUTHOR("Hewlett-Packard Company");
55 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.8");
56 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
57 " SA6i P600 P800 P400 P400i E200 E200i");
58 MODULE_LICENSE("GPL");
60 #include "cciss_cmd.h"
62 #include <linux/cciss_ioctl.h>
64 /* define the PCI info for the cards we can control */
65 static const struct pci_device_id cciss_pci_device_id[] = {
66 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
67 0x0E11, 0x4070, 0, 0, 0},
68 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
69 0x0E11, 0x4080, 0, 0, 0},
70 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
71 0x0E11, 0x4082, 0, 0, 0},
72 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
73 0x0E11, 0x4083, 0, 0, 0},
74 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
75 0x0E11, 0x409A, 0, 0, 0},
76 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
77 0x0E11, 0x409B, 0, 0, 0},
78 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
79 0x0E11, 0x409C, 0, 0, 0},
80 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
81 0x0E11, 0x409D, 0, 0, 0},
82 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
83 0x0E11, 0x4091, 0, 0, 0},
84 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
85 0x103C, 0x3225, 0, 0, 0},
86 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
87 0x103c, 0x3223, 0, 0, 0},
88 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
89 0x103c, 0x3234, 0, 0, 0},
90 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
91 0x103c, 0x3235, 0, 0, 0},
92 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
93 0x103c, 0x3211, 0, 0, 0},
94 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
95 0x103c, 0x3212, 0, 0, 0},
96 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
97 0x103c, 0x3213, 0, 0, 0},
98 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
99 0x103c, 0x3214, 0, 0, 0},
100 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
101 0x103c, 0x3215, 0, 0, 0},
104 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
106 #define NR_PRODUCTS (sizeof(products)/sizeof(struct board_type))
108 /* board_id = Subsystem Device ID & Vendor ID
109 * product = Marketing Name for the board
110 * access = Address of the struct of function pointers
112 static struct board_type products[] = {
113 { 0x40700E11, "Smart Array 5300", &SA5_access },
114 { 0x40800E11, "Smart Array 5i", &SA5B_access},
115 { 0x40820E11, "Smart Array 532", &SA5B_access},
116 { 0x40830E11, "Smart Array 5312", &SA5B_access},
117 { 0x409A0E11, "Smart Array 641", &SA5_access},
118 { 0x409B0E11, "Smart Array 642", &SA5_access},
119 { 0x409C0E11, "Smart Array 6400", &SA5_access},
120 { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
121 { 0x40910E11, "Smart Array 6i", &SA5_access},
122 { 0x3225103C, "Smart Array P600", &SA5_access},
123 { 0x3223103C, "Smart Array P800", &SA5_access},
124 { 0x3234103C, "Smart Array P400", &SA5_access},
125 { 0x3235103C, "Smart Array P400i", &SA5_access},
126 { 0x3211103C, "Smart Array E200i", &SA5_access},
127 { 0x3212103C, "Smart Array E200", &SA5_access},
128 { 0x3213103C, "Smart Array E200i", &SA5_access},
129 { 0x3214103C, "Smart Array E200i", &SA5_access},
130 { 0x3215103C, "Smart Array E200i", &SA5_access},
133 /* How long to wait (in millesconds) for board to go into simple mode */
134 #define MAX_CONFIG_WAIT 30000
135 #define MAX_IOCTL_CONFIG_WAIT 1000
137 /*define how many times we will try a command because of bus resets */
138 #define MAX_CMD_RETRIES 3
140 #define READ_AHEAD 1024
141 #define NR_CMDS 384 /* #commands that can be outstanding */
144 /* Originally cciss driver only supports 8 major numbers */
145 #define MAX_CTLR_ORIG 8
148 static ctlr_info_t *hba[MAX_CTLR];
150 static void do_cciss_request(request_queue_t *q);
151 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
152 static int cciss_open(struct inode *inode, struct file *filep);
153 static int cciss_release(struct inode *inode, struct file *filep);
154 static int cciss_ioctl(struct inode *inode, struct file *filep,
155 unsigned int cmd, unsigned long arg);
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);
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,
198 .compat_ioctl = cciss_compat_ioctl,
200 .revalidate_disk= cciss_revalidate,
204 * Enqueuing and dequeuing functions for cmdlists.
206 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
210 c->next = c->prev = c;
212 c->prev = (*Qptr)->prev;
214 (*Qptr)->prev->next = c;
219 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
220 CommandList_struct *c)
222 if (c && c->next != c) {
223 if (*Qptr == c) *Qptr = c->next;
224 c->prev->next = c->next;
225 c->next->prev = c->prev;
232 #include "cciss_scsi.c" /* For SCSI tape support */
234 #ifdef CONFIG_PROC_FS
237 * Report information about this controller.
239 #define ENG_GIG 1000000000
240 #define ENG_GIG_FACTOR (ENG_GIG/512)
241 #define RAID_UNKNOWN 6
242 static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
245 static struct proc_dir_entry *proc_cciss;
247 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
248 int length, int *eof, void *data)
253 ctlr_info_t *h = (ctlr_info_t*)data;
254 drive_info_struct *drv;
256 sector_t vol_sz, vol_sz_frac;
260 /* prevent displaying bogus info during configuration
261 * or deconfiguration of a logical volume
263 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
264 if (h->busy_configuring) {
265 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
268 h->busy_configuring = 1;
269 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
271 size = sprintf(buffer, "%s: HP %s Controller\n"
272 "Board ID: 0x%08lx\n"
273 "Firmware Version: %c%c%c%c\n"
275 "Logical drives: %d\n"
276 "Current Q depth: %d\n"
277 "Current # commands on controller: %d\n"
278 "Max Q depth since init: %d\n"
279 "Max # commands on controller since init: %d\n"
280 "Max SG entries since init: %d\n\n",
283 (unsigned long)h->board_id,
284 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
285 (unsigned int)h->intr,
287 h->Qdepth, h->commands_outstanding,
288 h->maxQsinceinit, h->max_outstanding, h->maxSG);
290 pos += size; len += size;
291 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
292 for(i=0; i<=h->highest_lun; i++) {
298 vol_sz = drv->nr_blocks;
299 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
301 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
303 if (drv->raid_level > 5)
304 drv->raid_level = RAID_UNKNOWN;
305 size = sprintf(buffer+len, "cciss/c%dd%d:"
306 "\t%4u.%02uGB\tRAID %s\n",
307 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
308 raid_label[drv->raid_level]);
309 pos += size; len += size;
313 *start = buffer+offset;
317 h->busy_configuring = 0;
322 cciss_proc_write(struct file *file, const char __user *buffer,
323 unsigned long count, void *data)
325 unsigned char cmd[80];
327 #ifdef CONFIG_CISS_SCSI_TAPE
328 ctlr_info_t *h = (ctlr_info_t *) data;
332 if (count > sizeof(cmd)-1) return -EINVAL;
333 if (copy_from_user(cmd, buffer, count)) return -EFAULT;
335 len = strlen(cmd); // above 3 lines ensure safety
336 if (len && cmd[len-1] == '\n')
338 # ifdef CONFIG_CISS_SCSI_TAPE
339 if (strcmp("engage scsi", cmd)==0) {
340 rc = cciss_engage_scsi(h->ctlr);
341 if (rc != 0) return -rc;
344 /* might be nice to have "disengage" too, but it's not
345 safely possible. (only 1 module use count, lock issues.) */
351 * Get us a file in /proc/cciss that says something about each controller.
352 * Create /proc/cciss if it doesn't exist yet.
354 static void __devinit cciss_procinit(int i)
356 struct proc_dir_entry *pde;
358 if (proc_cciss == NULL) {
359 proc_cciss = proc_mkdir("cciss", proc_root_driver);
364 pde = create_proc_read_entry(hba[i]->devname,
365 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
366 proc_cciss, cciss_proc_get_info, hba[i]);
367 pde->write_proc = cciss_proc_write;
369 #endif /* CONFIG_PROC_FS */
372 * For operations that cannot sleep, a command block is allocated at init,
373 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
374 * which ones are free or in use. For operations that can wait for kmalloc
375 * to possible sleep, this routine can be called with get_from_pool set to 0.
376 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
378 static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
380 CommandList_struct *c;
383 dma_addr_t cmd_dma_handle, err_dma_handle;
387 c = (CommandList_struct *) pci_alloc_consistent(
388 h->pdev, sizeof(CommandList_struct), &cmd_dma_handle);
391 memset(c, 0, sizeof(CommandList_struct));
395 c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
396 h->pdev, sizeof(ErrorInfo_struct),
399 if (c->err_info == NULL)
401 pci_free_consistent(h->pdev,
402 sizeof(CommandList_struct), c, cmd_dma_handle);
405 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
406 } else /* get it out of the controllers pool */
409 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
412 } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
414 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
417 memset(c, 0, sizeof(CommandList_struct));
418 cmd_dma_handle = h->cmd_pool_dhandle
419 + i*sizeof(CommandList_struct);
420 c->err_info = h->errinfo_pool + i;
421 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
422 err_dma_handle = h->errinfo_pool_dhandle
423 + i*sizeof(ErrorInfo_struct);
429 c->busaddr = (__u32) cmd_dma_handle;
430 temp64.val = (__u64) err_dma_handle;
431 c->ErrDesc.Addr.lower = temp64.val32.lower;
432 c->ErrDesc.Addr.upper = temp64.val32.upper;
433 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
442 * Frees a command block that was previously allocated with cmd_alloc().
444 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
451 temp64.val32.lower = c->ErrDesc.Addr.lower;
452 temp64.val32.upper = c->ErrDesc.Addr.upper;
453 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
454 c->err_info, (dma_addr_t) temp64.val);
455 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
456 c, (dma_addr_t) c->busaddr);
460 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
465 static inline ctlr_info_t *get_host(struct gendisk *disk)
467 return disk->queue->queuedata;
470 static inline drive_info_struct *get_drv(struct gendisk *disk)
472 return disk->private_data;
476 * Open. Make sure the device is really there.
478 static int cciss_open(struct inode *inode, struct file *filep)
480 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
481 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
484 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
485 #endif /* CCISS_DEBUG */
487 if (host->busy_initializing || drv->busy_configuring)
490 * Root is allowed to open raw volume zero even if it's not configured
491 * so array config can still work. Root is also allowed to open any
492 * volume that has a LUN ID, so it can issue IOCTL to reread the
493 * disk information. I don't think I really like this
494 * but I'm already using way to many device nodes to claim another one
495 * for "raw controller".
497 if (drv->nr_blocks == 0) {
498 if (iminor(inode) != 0) { /* not node 0? */
499 /* if not node 0 make sure it is a partition = 0 */
500 if (iminor(inode) & 0x0f) {
502 /* if it is, make sure we have a LUN ID */
503 } else if (drv->LunID == 0) {
507 if (!capable(CAP_SYS_ADMIN))
517 static int cciss_release(struct inode *inode, struct file *filep)
519 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
520 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
523 printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
524 #endif /* CCISS_DEBUG */
533 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
537 ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
542 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
543 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
545 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
548 case CCISS_GETPCIINFO:
549 case CCISS_GETINTINFO:
550 case CCISS_SETINTINFO:
551 case CCISS_GETNODENAME:
552 case CCISS_SETNODENAME:
553 case CCISS_GETHEARTBEAT:
554 case CCISS_GETBUSTYPES:
555 case CCISS_GETFIRMVER:
556 case CCISS_GETDRIVVER:
557 case CCISS_REVALIDVOLS:
558 case CCISS_DEREGDISK:
559 case CCISS_REGNEWDISK:
561 case CCISS_RESCANDISK:
562 case CCISS_GETLUNINFO:
563 return do_ioctl(f, cmd, arg);
565 case CCISS_PASSTHRU32:
566 return cciss_ioctl32_passthru(f, cmd, arg);
567 case CCISS_BIG_PASSTHRU32:
568 return cciss_ioctl32_big_passthru(f, cmd, arg);
575 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
577 IOCTL32_Command_struct __user *arg32 =
578 (IOCTL32_Command_struct __user *) arg;
579 IOCTL_Command_struct arg64;
580 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
585 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
586 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
587 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
588 err |= get_user(arg64.buf_size, &arg32->buf_size);
589 err |= get_user(cp, &arg32->buf);
590 arg64.buf = compat_ptr(cp);
591 err |= copy_to_user(p, &arg64, sizeof(arg64));
596 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
599 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
605 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
607 BIG_IOCTL32_Command_struct __user *arg32 =
608 (BIG_IOCTL32_Command_struct __user *) arg;
609 BIG_IOCTL_Command_struct arg64;
610 BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
615 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
616 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
617 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
618 err |= get_user(arg64.buf_size, &arg32->buf_size);
619 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
620 err |= get_user(cp, &arg32->buf);
621 arg64.buf = compat_ptr(cp);
622 err |= copy_to_user(p, &arg64, sizeof(arg64));
627 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
630 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
639 static int cciss_ioctl(struct inode *inode, struct file *filep,
640 unsigned int cmd, unsigned long arg)
642 struct block_device *bdev = inode->i_bdev;
643 struct gendisk *disk = bdev->bd_disk;
644 ctlr_info_t *host = get_host(disk);
645 drive_info_struct *drv = get_drv(disk);
646 int ctlr = host->ctlr;
647 void __user *argp = (void __user *)arg;
650 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
651 #endif /* CCISS_DEBUG */
656 struct hd_geometry driver_geo;
657 if (drv->cylinders) {
658 driver_geo.heads = drv->heads;
659 driver_geo.sectors = drv->sectors;
660 driver_geo.cylinders = drv->cylinders;
663 driver_geo.start= get_start_sect(inode->i_bdev);
664 if (copy_to_user(argp, &driver_geo, sizeof(struct hd_geometry)))
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 = (unsigned char **) kmalloc(MAXSGENTRIES *
998 sizeof(char *), GFP_KERNEL);
1003 memset(buff, 0, MAXSGENTRIES);
1004 buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int),
1010 left = ioc->buf_size;
1011 data_ptr = ioc->buf;
1013 sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
1014 buff_size[sg_used] = sz;
1015 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1016 if (buff[sg_used] == NULL) {
1020 if (ioc->Request.Type.Direction == XFER_WRITE &&
1021 copy_from_user(buff[sg_used], data_ptr, sz)) {
1025 memset(buff[sg_used], 0, sz);
1031 if ((c = cmd_alloc(host , 0)) == NULL) {
1035 c->cmd_type = CMD_IOCTL_PEND;
1036 c->Header.ReplyQueue = 0;
1038 if( ioc->buf_size > 0) {
1039 c->Header.SGList = sg_used;
1040 c->Header.SGTotal= sg_used;
1042 c->Header.SGList = 0;
1043 c->Header.SGTotal= 0;
1045 c->Header.LUN = ioc->LUN_info;
1046 c->Header.Tag.lower = c->busaddr;
1048 c->Request = ioc->Request;
1049 if (ioc->buf_size > 0 ) {
1051 for(i=0; i<sg_used; i++) {
1052 temp64.val = pci_map_single( host->pdev, buff[i],
1054 PCI_DMA_BIDIRECTIONAL);
1055 c->SG[i].Addr.lower = temp64.val32.lower;
1056 c->SG[i].Addr.upper = temp64.val32.upper;
1057 c->SG[i].Len = buff_size[i];
1058 c->SG[i].Ext = 0; /* we are not chaining */
1062 /* Put the request on the tail of the request queue */
1063 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1064 addQ(&host->reqQ, c);
1067 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1068 wait_for_completion(&wait);
1069 /* unlock the buffers from DMA */
1070 for(i=0; i<sg_used; i++) {
1071 temp64.val32.lower = c->SG[i].Addr.lower;
1072 temp64.val32.upper = c->SG[i].Addr.upper;
1073 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
1074 buff_size[i], PCI_DMA_BIDIRECTIONAL);
1076 /* Copy the error information out */
1077 ioc->error_info = *(c->err_info);
1078 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1079 cmd_free(host, c, 0);
1083 if (ioc->Request.Type.Direction == XFER_READ) {
1084 /* Copy the data out of the buffer we created */
1085 BYTE __user *ptr = ioc->buf;
1086 for(i=0; i< sg_used; i++) {
1087 if (copy_to_user(ptr, buff[i], buff_size[i])) {
1088 cmd_free(host, c, 0);
1092 ptr += buff_size[i];
1095 cmd_free(host, c, 0);
1099 for(i=0; i<sg_used; i++)
1117 * revalidate_allvol is for online array config utilities. After a
1118 * utility reconfigures the drives in the array, it can use this function
1119 * (through an ioctl) to make the driver zap any previous disk structs for
1120 * that controller and get new ones.
1122 * Right now I'm using the getgeometry() function to do this, but this
1123 * function should probably be finer grained and allow you to revalidate one
1124 * particualar logical volume (instead of all of them on a particular
1127 static int revalidate_allvol(ctlr_info_t *host)
1129 int ctlr = host->ctlr, i;
1130 unsigned long flags;
1132 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1133 if (host->usage_count > 1) {
1134 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1135 printk(KERN_WARNING "cciss: Device busy for volume"
1136 " revalidation (usage=%d)\n", host->usage_count);
1139 host->usage_count++;
1140 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1142 for(i=0; i< NWD; i++) {
1143 struct gendisk *disk = host->gendisk[i];
1144 if (disk->flags & GENHD_FL_UP)
1149 * Set the partition and block size structures for all volumes
1150 * on this controller to zero. We will reread all of this data
1152 memset(host->drv, 0, sizeof(drive_info_struct)
1155 * Tell the array controller not to give us any interrupts while
1156 * we check the new geometry. Then turn interrupts back on when
1159 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1160 cciss_getgeometry(ctlr);
1161 host->access.set_intr_mask(host, CCISS_INTR_ON);
1163 /* Loop through each real device */
1164 for (i = 0; i < NWD; i++) {
1165 struct gendisk *disk = host->gendisk[i];
1166 drive_info_struct *drv = &(host->drv[i]);
1167 /* we must register the controller even if no disks exist */
1168 /* this is for the online array utilities */
1169 if (!drv->heads && i)
1171 blk_queue_hardsect_size(drv->queue, drv->block_size);
1172 set_capacity(disk, drv->nr_blocks);
1175 host->usage_count--;
1179 /* This function will check the usage_count of the drive to be updated/added.
1180 * If the usage_count is zero then the drive information will be updated and
1181 * the disk will be re-registered with the kernel. If not then it will be
1182 * left alone for the next reboot. The exception to this is disk 0 which
1183 * will always be left registered with the kernel since it is also the
1184 * controller node. Any changes to disk 0 will show up on the next
1187 static void cciss_update_drive_info(int ctlr, int drv_index)
1189 ctlr_info_t *h = hba[ctlr];
1190 struct gendisk *disk;
1191 ReadCapdata_struct *size_buff = NULL;
1192 InquiryData_struct *inq_buff = NULL;
1193 unsigned int block_size;
1194 unsigned int total_size;
1195 unsigned long flags = 0;
1198 /* if the disk already exists then deregister it before proceeding*/
1199 if (h->drv[drv_index].raid_level != -1){
1200 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1201 h->drv[drv_index].busy_configuring = 1;
1202 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1203 ret = deregister_disk(h->gendisk[drv_index],
1204 &h->drv[drv_index], 0);
1205 h->drv[drv_index].busy_configuring = 0;
1208 /* If the disk is in use return */
1213 /* Get information about the disk and modify the driver sturcture */
1214 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1215 if (size_buff == NULL)
1217 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1218 if (inq_buff == NULL)
1221 cciss_read_capacity(ctlr, drv_index, size_buff, 1,
1222 &total_size, &block_size);
1223 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1224 inq_buff, &h->drv[drv_index]);
1227 disk = h->gendisk[drv_index];
1228 set_capacity(disk, h->drv[drv_index].nr_blocks);
1231 /* if it's the controller it's already added */
1233 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1235 /* Set up queue information */
1236 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1237 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1239 /* This is a hardware imposed limit. */
1240 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1242 /* This is a limit in the driver and could be eliminated. */
1243 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1245 blk_queue_max_sectors(disk->queue, 512);
1247 disk->queue->queuedata = hba[ctlr];
1249 blk_queue_hardsect_size(disk->queue,
1250 hba[ctlr]->drv[drv_index].block_size);
1252 h->drv[drv_index].queue = disk->queue;
1261 printk(KERN_ERR "cciss: out of memory\n");
1265 /* This function will find the first index of the controllers drive array
1266 * that has a -1 for the raid_level and will return that index. This is
1267 * where new drives will be added. If the index to be returned is greater
1268 * than the highest_lun index for the controller then highest_lun is set
1269 * to this new index. If there are no available indexes then -1 is returned.
1271 static int cciss_find_free_drive_index(int ctlr)
1275 for (i=0; i < CISS_MAX_LUN; i++){
1276 if (hba[ctlr]->drv[i].raid_level == -1){
1277 if (i > hba[ctlr]->highest_lun)
1278 hba[ctlr]->highest_lun = i;
1285 /* This function will add and remove logical drives from the Logical
1286 * drive array of the controller and maintain persistancy of ordering
1287 * so that mount points are preserved until the next reboot. This allows
1288 * for the removal of logical drives in the middle of the drive array
1289 * without a re-ordering of those drives.
1291 * h = The controller to perform the operations on
1292 * del_disk = The disk to remove if specified. If the value given
1293 * is NULL then no disk is removed.
1295 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1299 ReportLunData_struct *ld_buff = NULL;
1300 drive_info_struct *drv = NULL;
1307 unsigned long flags;
1309 /* Set busy_configuring flag for this operation */
1310 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1311 if (h->num_luns >= CISS_MAX_LUN){
1312 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1316 if (h->busy_configuring){
1317 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1320 h->busy_configuring = 1;
1322 /* if del_disk is NULL then we are being called to add a new disk
1323 * and update the logical drive table. If it is not NULL then
1324 * we will check if the disk is in use or not.
1326 if (del_disk != NULL){
1327 drv = get_drv(del_disk);
1328 drv->busy_configuring = 1;
1329 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1330 return_code = deregister_disk(del_disk, drv, 1);
1331 drv->busy_configuring = 0;
1332 h->busy_configuring = 0;
1335 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1336 if (!capable(CAP_SYS_RAWIO))
1339 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1340 if (ld_buff == NULL)
1343 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1344 sizeof(ReportLunData_struct), 0, 0, 0,
1347 if (return_code == IO_OK){
1348 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
1349 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
1350 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
1351 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1352 } else{ /* reading number of logical volumes failed */
1353 printk(KERN_WARNING "cciss: report logical volume"
1354 " command failed\n");
1359 num_luns = listlength / 8; /* 8 bytes per entry */
1360 if (num_luns > CISS_MAX_LUN){
1361 num_luns = CISS_MAX_LUN;
1362 printk(KERN_WARNING "cciss: more luns configured"
1363 " on controller than can be handled by"
1367 /* Compare controller drive array to drivers drive array.
1368 * Check for updates in the drive information and any new drives
1369 * on the controller.
1371 for (i=0; i < num_luns; i++){
1377 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1379 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1381 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1383 (unsigned int)(ld_buff->LUN[i][0]);
1385 /* Find if the LUN is already in the drive array
1386 * of the controller. If so then update its info
1387 * if not is use. If it does not exist then find
1388 * the first free index and add it.
1390 for (j=0; j <= h->highest_lun; j++){
1391 if (h->drv[j].LunID == lunid){
1397 /* check if the drive was found already in the array */
1399 drv_index = cciss_find_free_drive_index(ctlr);
1400 if (drv_index == -1)
1404 h->drv[drv_index].LunID = lunid;
1405 cciss_update_drive_info(ctlr, drv_index);
1411 h->busy_configuring = 0;
1412 /* We return -1 here to tell the ACU that we have registered/updated
1413 * all of the drives that we can and to keep it from calling us
1418 printk(KERN_ERR "cciss: out of memory\n");
1422 /* This function will deregister the disk and it's queue from the
1423 * kernel. It must be called with the controller lock held and the
1424 * drv structures busy_configuring flag set. It's parameters are:
1426 * disk = This is the disk to be deregistered
1427 * drv = This is the drive_info_struct associated with the disk to be
1428 * deregistered. It contains information about the disk used
1430 * clear_all = This flag determines whether or not the disk information
1431 * is going to be completely cleared out and the highest_lun
1432 * reset. Sometimes we want to clear out information about
1433 * the disk in preperation for re-adding it. In this case
1434 * the highest_lun should be left unchanged and the LunID
1435 * should not be cleared.
1437 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1440 ctlr_info_t *h = get_host(disk);
1442 if (!capable(CAP_SYS_RAWIO))
1445 /* make sure logical volume is NOT is use */
1446 if(clear_all || (h->gendisk[0] == disk)) {
1447 if (drv->usage_count > 1)
1451 if( drv->usage_count > 0 )
1454 /* invalidate the devices and deregister the disk. If it is disk
1455 * zero do not deregister it but just zero out it's values. This
1456 * allows us to delete disk zero but keep the controller registered.
1458 if (h->gendisk[0] != disk){
1459 if (disk->flags & GENHD_FL_UP){
1460 blk_cleanup_queue(disk->queue);
1467 /* zero out the disk size info */
1469 drv->block_size = 0;
1473 drv->raid_level = -1; /* This can be used as a flag variable to
1474 * indicate that this element of the drive
1479 /* check to see if it was the last disk */
1480 if (drv == h->drv + h->highest_lun) {
1481 /* if so, find the new hightest lun */
1482 int i, newhighest =-1;
1483 for(i=0; i<h->highest_lun; i++) {
1484 /* if the disk has size > 0, it is available */
1485 if (h->drv[i].heads)
1488 h->highest_lun = newhighest;
1496 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
1498 unsigned int use_unit_num, /* 0: address the controller,
1499 1: address logical volume log_unit,
1500 2: periph device address is scsi3addr */
1501 unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
1504 ctlr_info_t *h= hba[ctlr];
1505 u64bit buff_dma_handle;
1508 c->cmd_type = CMD_IOCTL_PEND;
1509 c->Header.ReplyQueue = 0;
1511 c->Header.SGList = 1;
1512 c->Header.SGTotal= 1;
1514 c->Header.SGList = 0;
1515 c->Header.SGTotal= 0;
1517 c->Header.Tag.lower = c->busaddr;
1519 c->Request.Type.Type = cmd_type;
1520 if (cmd_type == TYPE_CMD) {
1523 /* If the logical unit number is 0 then, this is going
1524 to controller so It's a physical command
1525 mode = 0 target = 0. So we have nothing to write.
1526 otherwise, if use_unit_num == 1,
1527 mode = 1(volume set addressing) target = LUNID
1528 otherwise, if use_unit_num == 2,
1529 mode = 0(periph dev addr) target = scsi3addr */
1530 if (use_unit_num == 1) {
1531 c->Header.LUN.LogDev.VolId=
1532 h->drv[log_unit].LunID;
1533 c->Header.LUN.LogDev.Mode = 1;
1534 } else if (use_unit_num == 2) {
1535 memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
1536 c->Header.LUN.LogDev.Mode = 0;
1538 /* are we trying to read a vital product page */
1539 if(page_code != 0) {
1540 c->Request.CDB[1] = 0x01;
1541 c->Request.CDB[2] = page_code;
1543 c->Request.CDBLen = 6;
1544 c->Request.Type.Attribute = ATTR_SIMPLE;
1545 c->Request.Type.Direction = XFER_READ;
1546 c->Request.Timeout = 0;
1547 c->Request.CDB[0] = CISS_INQUIRY;
1548 c->Request.CDB[4] = size & 0xFF;
1550 case CISS_REPORT_LOG:
1551 case CISS_REPORT_PHYS:
1552 /* Talking to controller so It's a physical command
1553 mode = 00 target = 0. Nothing to write.
1555 c->Request.CDBLen = 12;
1556 c->Request.Type.Attribute = ATTR_SIMPLE;
1557 c->Request.Type.Direction = XFER_READ;
1558 c->Request.Timeout = 0;
1559 c->Request.CDB[0] = cmd;
1560 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1561 c->Request.CDB[7] = (size >> 16) & 0xFF;
1562 c->Request.CDB[8] = (size >> 8) & 0xFF;
1563 c->Request.CDB[9] = size & 0xFF;
1566 case CCISS_READ_CAPACITY:
1567 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1568 c->Header.LUN.LogDev.Mode = 1;
1569 c->Request.CDBLen = 10;
1570 c->Request.Type.Attribute = ATTR_SIMPLE;
1571 c->Request.Type.Direction = XFER_READ;
1572 c->Request.Timeout = 0;
1573 c->Request.CDB[0] = cmd;
1575 case CCISS_CACHE_FLUSH:
1576 c->Request.CDBLen = 12;
1577 c->Request.Type.Attribute = ATTR_SIMPLE;
1578 c->Request.Type.Direction = XFER_WRITE;
1579 c->Request.Timeout = 0;
1580 c->Request.CDB[0] = BMIC_WRITE;
1581 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1585 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1588 } else if (cmd_type == TYPE_MSG) {
1590 case 0: /* ABORT message */
1591 c->Request.CDBLen = 12;
1592 c->Request.Type.Attribute = ATTR_SIMPLE;
1593 c->Request.Type.Direction = XFER_WRITE;
1594 c->Request.Timeout = 0;
1595 c->Request.CDB[0] = cmd; /* abort */
1596 c->Request.CDB[1] = 0; /* abort a command */
1597 /* buff contains the tag of the command to abort */
1598 memcpy(&c->Request.CDB[4], buff, 8);
1600 case 1: /* RESET message */
1601 c->Request.CDBLen = 12;
1602 c->Request.Type.Attribute = ATTR_SIMPLE;
1603 c->Request.Type.Direction = XFER_WRITE;
1604 c->Request.Timeout = 0;
1605 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1606 c->Request.CDB[0] = cmd; /* reset */
1607 c->Request.CDB[1] = 0x04; /* reset a LUN */
1608 case 3: /* No-Op message */
1609 c->Request.CDBLen = 1;
1610 c->Request.Type.Attribute = ATTR_SIMPLE;
1611 c->Request.Type.Direction = XFER_WRITE;
1612 c->Request.Timeout = 0;
1613 c->Request.CDB[0] = cmd;
1617 "cciss%d: unknown message type %d\n",
1623 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1626 /* Fill in the scatter gather information */
1628 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1629 buff, size, PCI_DMA_BIDIRECTIONAL);
1630 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1631 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1632 c->SG[0].Len = size;
1633 c->SG[0].Ext = 0; /* we are not chaining */
1637 static int sendcmd_withirq(__u8 cmd,
1641 unsigned int use_unit_num,
1642 unsigned int log_unit,
1646 ctlr_info_t *h = hba[ctlr];
1647 CommandList_struct *c;
1648 u64bit buff_dma_handle;
1649 unsigned long flags;
1651 DECLARE_COMPLETION(wait);
1653 if ((c = cmd_alloc(h , 0)) == NULL)
1655 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1656 log_unit, page_code, NULL, cmd_type);
1657 if (return_status != IO_OK) {
1659 return return_status;
1664 /* Put the request on the tail of the queue and send it */
1665 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1669 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1671 wait_for_completion(&wait);
1673 if(c->err_info->CommandStatus != 0)
1674 { /* an error has occurred */
1675 switch(c->err_info->CommandStatus)
1677 case CMD_TARGET_STATUS:
1678 printk(KERN_WARNING "cciss: cmd %p has "
1679 " completed with errors\n", c);
1680 if( c->err_info->ScsiStatus)
1682 printk(KERN_WARNING "cciss: cmd %p "
1683 "has SCSI Status = %x\n",
1685 c->err_info->ScsiStatus);
1689 case CMD_DATA_UNDERRUN:
1690 case CMD_DATA_OVERRUN:
1691 /* expected for inquire and report lun commands */
1694 printk(KERN_WARNING "cciss: Cmd %p is "
1695 "reported invalid\n", c);
1696 return_status = IO_ERROR;
1698 case CMD_PROTOCOL_ERR:
1699 printk(KERN_WARNING "cciss: cmd %p has "
1700 "protocol error \n", c);
1701 return_status = IO_ERROR;
1703 case CMD_HARDWARE_ERR:
1704 printk(KERN_WARNING "cciss: cmd %p had "
1705 " hardware error\n", c);
1706 return_status = IO_ERROR;
1708 case CMD_CONNECTION_LOST:
1709 printk(KERN_WARNING "cciss: cmd %p had "
1710 "connection lost\n", c);
1711 return_status = IO_ERROR;
1714 printk(KERN_WARNING "cciss: cmd %p was "
1716 return_status = IO_ERROR;
1718 case CMD_ABORT_FAILED:
1719 printk(KERN_WARNING "cciss: cmd %p reports "
1720 "abort failed\n", c);
1721 return_status = IO_ERROR;
1723 case CMD_UNSOLICITED_ABORT:
1725 "cciss%d: unsolicited abort %p\n",
1727 if (c->retry_count < MAX_CMD_RETRIES) {
1729 "cciss%d: retrying %p\n",
1732 /* erase the old error information */
1733 memset(c->err_info, 0,
1734 sizeof(ErrorInfo_struct));
1735 return_status = IO_OK;
1736 INIT_COMPLETION(wait);
1739 return_status = IO_ERROR;
1742 printk(KERN_WARNING "cciss: cmd %p returned "
1743 "unknown status %x\n", c,
1744 c->err_info->CommandStatus);
1745 return_status = IO_ERROR;
1748 /* unlock the buffers from DMA */
1749 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1750 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1751 pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
1752 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1754 return(return_status);
1757 static void cciss_geometry_inquiry(int ctlr, int logvol,
1758 int withirq, unsigned int total_size,
1759 unsigned int block_size, InquiryData_struct *inq_buff,
1760 drive_info_struct *drv)
1763 memset(inq_buff, 0, sizeof(InquiryData_struct));
1765 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1766 inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
1768 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1769 sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
1770 if (return_code == IO_OK) {
1771 if(inq_buff->data_byte[8] == 0xFF) {
1773 "cciss: reading geometry failed, volume "
1774 "does not support reading geometry\n");
1775 drv->block_size = block_size;
1776 drv->nr_blocks = total_size;
1778 drv->sectors = 32; // Sectors per track
1779 drv->cylinders = total_size / 255 / 32;
1783 drv->block_size = block_size;
1784 drv->nr_blocks = total_size;
1785 drv->heads = inq_buff->data_byte[6];
1786 drv->sectors = inq_buff->data_byte[7];
1787 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1788 drv->cylinders += inq_buff->data_byte[5];
1789 drv->raid_level = inq_buff->data_byte[8];
1790 t = drv->heads * drv->sectors;
1792 drv->cylinders = total_size/t;
1795 } else { /* Get geometry failed */
1796 printk(KERN_WARNING "cciss: reading geometry failed\n");
1798 printk(KERN_INFO " heads= %d, sectors= %d, cylinders= %d\n\n",
1799 drv->heads, drv->sectors, drv->cylinders);
1802 cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
1803 int withirq, unsigned int *total_size, unsigned int *block_size)
1806 memset(buf, 0, sizeof(*buf));
1808 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1809 ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
1811 return_code = sendcmd(CCISS_READ_CAPACITY,
1812 ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
1813 if (return_code == IO_OK) {
1814 *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
1815 *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
1816 } else { /* read capacity command failed */
1817 printk(KERN_WARNING "cciss: read capacity failed\n");
1819 *block_size = BLOCK_SIZE;
1821 printk(KERN_INFO " blocks= %u block_size= %d\n",
1822 *total_size, *block_size);
1826 static int cciss_revalidate(struct gendisk *disk)
1828 ctlr_info_t *h = get_host(disk);
1829 drive_info_struct *drv = get_drv(disk);
1832 unsigned int block_size;
1833 unsigned int total_size;
1834 ReadCapdata_struct *size_buff = NULL;
1835 InquiryData_struct *inq_buff = NULL;
1837 for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
1839 if(h->drv[logvol].LunID == drv->LunID) {
1845 if (!FOUND) return 1;
1847 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1848 if (size_buff == NULL)
1850 printk(KERN_WARNING "cciss: out of memory\n");
1853 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1854 if (inq_buff == NULL)
1856 printk(KERN_WARNING "cciss: out of memory\n");
1861 cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
1862 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
1864 blk_queue_hardsect_size(drv->queue, drv->block_size);
1865 set_capacity(disk, drv->nr_blocks);
1873 * Wait polling for a command to complete.
1874 * The memory mapped FIFO is polled for the completion.
1875 * Used only at init time, interrupts from the HBA are disabled.
1877 static unsigned long pollcomplete(int ctlr)
1882 /* Wait (up to 20 seconds) for a command to complete */
1884 for (i = 20 * HZ; i > 0; i--) {
1885 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1886 if (done == FIFO_EMPTY)
1887 schedule_timeout_uninterruptible(1);
1891 /* Invalid address to tell caller we ran out of time */
1895 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
1897 /* We get in here if sendcmd() is polling for completions
1898 and gets some command back that it wasn't expecting --
1899 something other than that which it just sent down.
1900 Ordinarily, that shouldn't happen, but it can happen when
1901 the scsi tape stuff gets into error handling mode, and
1902 starts using sendcmd() to try to abort commands and
1903 reset tape drives. In that case, sendcmd may pick up
1904 completions of commands that were sent to logical drives
1905 through the block i/o system, or cciss ioctls completing, etc.
1906 In that case, we need to save those completions for later
1907 processing by the interrupt handler.
1910 #ifdef CONFIG_CISS_SCSI_TAPE
1911 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
1913 /* If it's not the scsi tape stuff doing error handling, (abort */
1914 /* or reset) then we don't expect anything weird. */
1915 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
1917 printk( KERN_WARNING "cciss cciss%d: SendCmd "
1918 "Invalid command list address returned! (%lx)\n",
1920 /* not much we can do. */
1921 #ifdef CONFIG_CISS_SCSI_TAPE
1925 /* We've sent down an abort or reset, but something else
1927 if (srl->ncompletions >= (NR_CMDS + 2)) {
1928 /* Uh oh. No room to save it for later... */
1929 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
1930 "reject list overflow, command lost!\n", ctlr);
1933 /* Save it for later */
1934 srl->complete[srl->ncompletions] = complete;
1935 srl->ncompletions++;
1941 * Send a command to the controller, and wait for it to complete.
1942 * Only used at init time.
1949 unsigned int use_unit_num, /* 0: address the controller,
1950 1: address logical volume log_unit,
1951 2: periph device address is scsi3addr */
1952 unsigned int log_unit,
1954 unsigned char *scsi3addr,
1957 CommandList_struct *c;
1959 unsigned long complete;
1960 ctlr_info_t *info_p= hba[ctlr];
1961 u64bit buff_dma_handle;
1962 int status, done = 0;
1964 if ((c = cmd_alloc(info_p, 1)) == NULL) {
1965 printk(KERN_WARNING "cciss: unable to get memory");
1968 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1969 log_unit, page_code, scsi3addr, cmd_type);
1970 if (status != IO_OK) {
1971 cmd_free(info_p, c, 1);
1979 printk(KERN_DEBUG "cciss: turning intr off\n");
1980 #endif /* CCISS_DEBUG */
1981 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
1983 /* Make sure there is room in the command FIFO */
1984 /* Actually it should be completely empty at this time */
1985 /* unless we are in here doing error handling for the scsi */
1986 /* tape side of the driver. */
1987 for (i = 200000; i > 0; i--)
1989 /* if fifo isn't full go */
1990 if (!(info_p->access.fifo_full(info_p)))
1996 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
1997 " waiting!\n", ctlr);
2002 info_p->access.submit_command(info_p, c);
2005 complete = pollcomplete(ctlr);
2008 printk(KERN_DEBUG "cciss: command completed\n");
2009 #endif /* CCISS_DEBUG */
2011 if (complete == 1) {
2012 printk( KERN_WARNING
2013 "cciss cciss%d: SendCmd Timeout out, "
2014 "No command list address returned!\n",
2021 /* This will need to change for direct lookup completions */
2022 if ( (complete & CISS_ERROR_BIT)
2023 && (complete & ~CISS_ERROR_BIT) == c->busaddr)
2025 /* if data overrun or underun on Report command
2028 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2029 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2030 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2031 ((c->err_info->CommandStatus ==
2032 CMD_DATA_OVERRUN) ||
2033 (c->err_info->CommandStatus ==
2037 complete = c->busaddr;
2039 if (c->err_info->CommandStatus ==
2040 CMD_UNSOLICITED_ABORT) {
2041 printk(KERN_WARNING "cciss%d: "
2042 "unsolicited abort %p\n",
2044 if (c->retry_count < MAX_CMD_RETRIES) {
2046 "cciss%d: retrying %p\n",
2049 /* erase the old error */
2051 memset(c->err_info, 0,
2052 sizeof(ErrorInfo_struct));
2056 "cciss%d: retried %p too "
2057 "many times\n", ctlr, c);
2061 } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
2062 printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
2066 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2067 " Error %x \n", ctlr,
2068 c->err_info->CommandStatus);
2069 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2071 " size %x\n num %x value %x\n", ctlr,
2072 c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
2073 c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
2074 c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
2079 /* This will need changing for direct lookup completions */
2080 if (complete != c->busaddr) {
2081 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2082 BUG(); /* we are pretty much hosed if we get here. */
2090 /* unlock the data buffer from DMA */
2091 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2092 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2093 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2094 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2095 #ifdef CONFIG_CISS_SCSI_TAPE
2096 /* if we saved some commands for later, process them now. */
2097 if (info_p->scsi_rejects.ncompletions > 0)
2098 do_cciss_intr(0, info_p, NULL);
2100 cmd_free(info_p, c, 1);
2104 * Map (physical) PCI mem into (virtual) kernel space
2106 static void __iomem *remap_pci_mem(ulong base, ulong size)
2108 ulong page_base = ((ulong) base) & PAGE_MASK;
2109 ulong page_offs = ((ulong) base) - page_base;
2110 void __iomem *page_remapped = ioremap(page_base, page_offs+size);
2112 return page_remapped ? (page_remapped + page_offs) : NULL;
2116 * Takes jobs of the Q and sends them to the hardware, then puts it on
2117 * the Q to wait for completion.
2119 static void start_io( ctlr_info_t *h)
2121 CommandList_struct *c;
2123 while(( c = h->reqQ) != NULL )
2125 /* can't do anything if fifo is full */
2126 if ((h->access.fifo_full(h))) {
2127 printk(KERN_WARNING "cciss: fifo full\n");
2131 /* Get the frist entry from the Request Q */
2132 removeQ(&(h->reqQ), c);
2135 /* Tell the controller execute command */
2136 h->access.submit_command(h, c);
2138 /* Put job onto the completed Q */
2139 addQ (&(h->cmpQ), c);
2143 static inline void complete_buffers(struct bio *bio, int status)
2146 struct bio *xbh = bio->bi_next;
2147 int nr_sectors = bio_sectors(bio);
2149 bio->bi_next = NULL;
2150 blk_finished_io(len);
2151 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
2156 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2157 /* Zeros out the error record and then resends the command back */
2158 /* to the controller */
2159 static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
2161 /* erase the old error information */
2162 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2164 /* add it to software queue and then send it to the controller */
2167 if(h->Qdepth > h->maxQsinceinit)
2168 h->maxQsinceinit = h->Qdepth;
2172 /* checks the status of the job and calls complete buffers to mark all
2173 * buffers for the completed job.
2175 static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
2186 if(cmd->err_info->CommandStatus != 0)
2187 { /* an error has occurred */
2188 switch(cmd->err_info->CommandStatus)
2190 unsigned char sense_key;
2191 case CMD_TARGET_STATUS:
2194 if( cmd->err_info->ScsiStatus == 0x02)
2196 printk(KERN_WARNING "cciss: cmd %p "
2197 "has CHECK CONDITION "
2198 " byte 2 = 0x%x\n", cmd,
2199 cmd->err_info->SenseInfo[2]
2201 /* check the sense key */
2203 cmd->err_info->SenseInfo[2];
2204 /* no status or recovered error */
2205 if((sense_key == 0x0) ||
2212 printk(KERN_WARNING "cciss: cmd %p "
2213 "has SCSI Status 0x%x\n",
2214 cmd, cmd->err_info->ScsiStatus);
2217 case CMD_DATA_UNDERRUN:
2218 printk(KERN_WARNING "cciss: cmd %p has"
2219 " completed with data underrun "
2222 case CMD_DATA_OVERRUN:
2223 printk(KERN_WARNING "cciss: cmd %p has"
2224 " completed with data overrun "
2228 printk(KERN_WARNING "cciss: cmd %p is "
2229 "reported invalid\n", cmd);
2232 case CMD_PROTOCOL_ERR:
2233 printk(KERN_WARNING "cciss: cmd %p has "
2234 "protocol error \n", cmd);
2237 case CMD_HARDWARE_ERR:
2238 printk(KERN_WARNING "cciss: cmd %p had "
2239 " hardware error\n", cmd);
2242 case CMD_CONNECTION_LOST:
2243 printk(KERN_WARNING "cciss: cmd %p had "
2244 "connection lost\n", cmd);
2248 printk(KERN_WARNING "cciss: cmd %p was "
2252 case CMD_ABORT_FAILED:
2253 printk(KERN_WARNING "cciss: cmd %p reports "
2254 "abort failed\n", cmd);
2257 case CMD_UNSOLICITED_ABORT:
2258 printk(KERN_WARNING "cciss%d: unsolicited "
2259 "abort %p\n", h->ctlr, cmd);
2260 if (cmd->retry_count < MAX_CMD_RETRIES) {
2263 "cciss%d: retrying %p\n",
2268 "cciss%d: %p retried too "
2269 "many times\n", h->ctlr, cmd);
2273 printk(KERN_WARNING "cciss: cmd %p timedout\n",
2278 printk(KERN_WARNING "cciss: cmd %p returned "
2279 "unknown status %x\n", cmd,
2280 cmd->err_info->CommandStatus);
2284 /* We need to return this command */
2286 resend_cciss_cmd(h,cmd);
2289 /* command did not need to be retried */
2290 /* unmap the DMA mapping for all the scatter gather elements */
2291 for(i=0; i<cmd->Header.SGList; i++) {
2292 temp64.val32.lower = cmd->SG[i].Addr.lower;
2293 temp64.val32.upper = cmd->SG[i].Addr.upper;
2294 pci_unmap_page(hba[cmd->ctlr]->pdev,
2295 temp64.val, cmd->SG[i].Len,
2296 (cmd->Request.Type.Direction == XFER_READ) ?
2297 PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
2299 complete_buffers(cmd->rq->bio, status);
2302 printk("Done with %p\n", cmd->rq);
2303 #endif /* CCISS_DEBUG */
2305 end_that_request_last(cmd->rq);
2310 * Get a request and submit it to the controller.
2312 static void do_cciss_request(request_queue_t *q)
2314 ctlr_info_t *h= q->queuedata;
2315 CommandList_struct *c;
2317 struct request *creq;
2319 struct scatterlist tmp_sg[MAXSGENTRIES];
2320 drive_info_struct *drv;
2323 /* We call start_io here in case there is a command waiting on the
2324 * queue that has not been sent.
2326 if (blk_queue_plugged(q))
2330 creq = elv_next_request(q);
2334 if (creq->nr_phys_segments > MAXSGENTRIES)
2337 if (( c = cmd_alloc(h, 1)) == NULL)
2340 blkdev_dequeue_request(creq);
2342 spin_unlock_irq(q->queue_lock);
2344 c->cmd_type = CMD_RWREQ;
2347 /* fill in the request */
2348 drv = creq->rq_disk->private_data;
2349 c->Header.ReplyQueue = 0; // unused in simple mode
2350 /* got command from pool, so use the command block index instead */
2351 /* for direct lookups. */
2352 /* The first 2 bits are reserved for controller error reporting. */
2353 c->Header.Tag.lower = (c->cmdindex << 3);
2354 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2355 c->Header.LUN.LogDev.VolId= drv->LunID;
2356 c->Header.LUN.LogDev.Mode = 1;
2357 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2358 c->Request.Type.Type = TYPE_CMD; // It is a command.
2359 c->Request.Type.Attribute = ATTR_SIMPLE;
2360 c->Request.Type.Direction =
2361 (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE;
2362 c->Request.Timeout = 0; // Don't time out
2363 c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
2364 start_blk = creq->sector;
2366 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
2367 (int) creq->nr_sectors);
2368 #endif /* CCISS_DEBUG */
2370 seg = blk_rq_map_sg(q, creq, tmp_sg);
2372 /* get the DMA records for the setup */
2373 if (c->Request.Type.Direction == XFER_READ)
2374 dir = PCI_DMA_FROMDEVICE;
2376 dir = PCI_DMA_TODEVICE;
2378 for (i=0; i<seg; i++)
2380 c->SG[i].Len = tmp_sg[i].length;
2381 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2382 tmp_sg[i].offset, tmp_sg[i].length,
2384 c->SG[i].Addr.lower = temp64.val32.lower;
2385 c->SG[i].Addr.upper = temp64.val32.upper;
2386 c->SG[i].Ext = 0; // we are not chaining
2388 /* track how many SG entries we are using */
2393 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
2394 #endif /* CCISS_DEBUG */
2396 c->Header.SGList = c->Header.SGTotal = seg;
2397 c->Request.CDB[1]= 0;
2398 c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
2399 c->Request.CDB[3]= (start_blk >> 16) & 0xff;
2400 c->Request.CDB[4]= (start_blk >> 8) & 0xff;
2401 c->Request.CDB[5]= start_blk & 0xff;
2402 c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
2403 c->Request.CDB[7]= (creq->nr_sectors >> 8) & 0xff;
2404 c->Request.CDB[8]= creq->nr_sectors & 0xff;
2405 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2407 spin_lock_irq(q->queue_lock);
2411 if(h->Qdepth > h->maxQsinceinit)
2412 h->maxQsinceinit = h->Qdepth;
2418 /* We will already have the driver lock here so not need
2424 static inline unsigned long get_next_completion(ctlr_info_t *h)
2426 #ifdef CONFIG_CISS_SCSI_TAPE
2427 /* Any rejects from sendcmd() lying around? Process them first */
2428 if (h->scsi_rejects.ncompletions == 0)
2429 return h->access.command_completed(h);
2431 struct sendcmd_reject_list *srl;
2433 srl = &h->scsi_rejects;
2434 n = --srl->ncompletions;
2435 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2437 return srl->complete[n];
2440 return h->access.command_completed(h);
2444 static inline int interrupt_pending(ctlr_info_t *h)
2446 #ifdef CONFIG_CISS_SCSI_TAPE
2447 return ( h->access.intr_pending(h)
2448 || (h->scsi_rejects.ncompletions > 0));
2450 return h->access.intr_pending(h);
2454 static inline long interrupt_not_for_us(ctlr_info_t *h)
2456 #ifdef CONFIG_CISS_SCSI_TAPE
2457 return (((h->access.intr_pending(h) == 0) ||
2458 (h->interrupts_enabled == 0))
2459 && (h->scsi_rejects.ncompletions == 0));
2461 return (((h->access.intr_pending(h) == 0) ||
2462 (h->interrupts_enabled == 0)));
2466 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
2468 ctlr_info_t *h = dev_id;
2469 CommandList_struct *c;
2470 unsigned long flags;
2473 int start_queue = h->next_to_run;
2475 if (interrupt_not_for_us(h))
2478 * If there are completed commands in the completion queue,
2479 * we had better do something about it.
2481 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2482 while (interrupt_pending(h)) {
2483 while((a = get_next_completion(h)) != FIFO_EMPTY) {
2487 if (a2 >= NR_CMDS) {
2488 printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
2489 fail_all_cmds(h->ctlr);
2493 c = h->cmd_pool + a2;
2498 if ((c = h->cmpQ) == NULL) {
2499 printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
2502 while(c->busaddr != a) {
2509 * If we've found the command, take it off the
2510 * completion Q and free it
2512 if (c->busaddr == a) {
2513 removeQ(&h->cmpQ, c);
2514 if (c->cmd_type == CMD_RWREQ) {
2515 complete_command(h, c, 0);
2516 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2517 complete(c->waiting);
2519 # ifdef CONFIG_CISS_SCSI_TAPE
2520 else if (c->cmd_type == CMD_SCSI)
2521 complete_scsi_command(c, 0, a1);
2528 /* check to see if we have maxed out the number of commands that can
2529 * be placed on the queue. If so then exit. We do this check here
2530 * in case the interrupt we serviced was from an ioctl and did not
2531 * free any new commands.
2533 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2536 /* We have room on the queue for more commands. Now we need to queue
2537 * them up. We will also keep track of the next queue to run so
2538 * that every queue gets a chance to be started first.
2540 for (j=0; j < h->highest_lun + 1; j++){
2541 int curr_queue = (start_queue + j) % (h->highest_lun + 1);
2542 /* make sure the disk has been added and the drive is real
2543 * because this can be called from the middle of init_one.
2545 if(!(h->drv[curr_queue].queue) ||
2546 !(h->drv[curr_queue].heads))
2548 blk_start_queue(h->gendisk[curr_queue]->queue);
2550 /* check to see if we have maxed out the number of commands
2551 * that can be placed on the queue.
2553 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2555 if (curr_queue == start_queue){
2556 h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
2559 h->next_to_run = curr_queue;
2563 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
2568 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2572 * We cannot read the structure directly, for portablity we must use
2574 * This is for debug only.
2577 static void print_cfg_table( CfgTable_struct *tb)
2582 printk("Controller Configuration information\n");
2583 printk("------------------------------------\n");
2585 temp_name[i] = readb(&(tb->Signature[i]));
2587 printk(" Signature = %s\n", temp_name);
2588 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2589 printk(" Transport methods supported = 0x%x\n",
2590 readl(&(tb-> TransportSupport)));
2591 printk(" Transport methods active = 0x%x\n",
2592 readl(&(tb->TransportActive)));
2593 printk(" Requested transport Method = 0x%x\n",
2594 readl(&(tb->HostWrite.TransportRequest)));
2595 printk(" Coalese Interrupt Delay = 0x%x\n",
2596 readl(&(tb->HostWrite.CoalIntDelay)));
2597 printk(" Coalese Interrupt Count = 0x%x\n",
2598 readl(&(tb->HostWrite.CoalIntCount)));
2599 printk(" Max outstanding commands = 0x%d\n",
2600 readl(&(tb->CmdsOutMax)));
2601 printk(" Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
2603 temp_name[i] = readb(&(tb->ServerName[i]));
2604 temp_name[16] = '\0';
2605 printk(" Server Name = %s\n", temp_name);
2606 printk(" Heartbeat Counter = 0x%x\n\n\n",
2607 readl(&(tb->HeartBeat)));
2609 #endif /* CCISS_DEBUG */
2611 static void release_io_mem(ctlr_info_t *c)
2613 /* if IO mem was not protected do nothing */
2614 if( c->io_mem_addr == 0)
2616 release_region(c->io_mem_addr, c->io_mem_length);
2618 c->io_mem_length = 0;
2621 static int find_PCI_BAR_index(struct pci_dev *pdev,
2622 unsigned long pci_bar_addr)
2624 int i, offset, mem_type, bar_type;
2625 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2628 for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
2629 bar_type = pci_resource_flags(pdev, i) &
2630 PCI_BASE_ADDRESS_SPACE;
2631 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2634 mem_type = pci_resource_flags(pdev, i) &
2635 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2637 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2638 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2639 offset += 4; /* 32 bit */
2641 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2644 default: /* reserved in PCI 2.2 */
2645 printk(KERN_WARNING "Base address is invalid\n");
2650 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2656 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2658 ushort subsystem_vendor_id, subsystem_device_id, command;
2659 __u32 board_id, scratchpad = 0;
2661 __u32 cfg_base_addr;
2662 __u64 cfg_base_addr_index;
2665 /* check to see if controller has been disabled */
2666 /* BEFORE trying to enable it */
2667 (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
2668 if(!(command & 0x02))
2670 printk(KERN_WARNING "cciss: controller appears to be disabled\n");
2674 if (pci_enable_device(pdev))
2676 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2680 subsystem_vendor_id = pdev->subsystem_vendor;
2681 subsystem_device_id = pdev->subsystem_device;
2682 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2683 subsystem_vendor_id);
2685 /* search for our IO range so we can protect it */
2686 for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
2688 /* is this an IO range */
2689 if( pci_resource_flags(pdev, i) & 0x01 ) {
2690 c->io_mem_addr = pci_resource_start(pdev, i);
2691 c->io_mem_length = pci_resource_end(pdev, i) -
2692 pci_resource_start(pdev, i) +1;
2694 printk("IO value found base_addr[%d] %lx %lx\n", i,
2695 c->io_mem_addr, c->io_mem_length);
2696 #endif /* CCISS_DEBUG */
2697 /* register the IO range */
2698 if(!request_region( c->io_mem_addr,
2699 c->io_mem_length, "cciss"))
2701 printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ld\n",
2702 c->io_mem_addr, c->io_mem_length);
2704 c->io_mem_length = 0;
2711 printk("command = %x\n", command);
2712 printk("irq = %x\n", pdev->irq);
2713 printk("board_id = %x\n", board_id);
2714 #endif /* CCISS_DEBUG */
2716 c->intr = pdev->irq;
2719 * Memory base addr is first addr , the second points to the config
2723 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2725 printk("address 0 = %x\n", c->paddr);
2726 #endif /* CCISS_DEBUG */
2727 c->vaddr = remap_pci_mem(c->paddr, 200);
2729 /* Wait for the board to become ready. (PCI hotplug needs this.)
2730 * We poll for up to 120 secs, once per 100ms. */
2731 for (i=0; i < 1200; i++) {
2732 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2733 if (scratchpad == CCISS_FIRMWARE_READY)
2735 set_current_state(TASK_INTERRUPTIBLE);
2736 schedule_timeout(HZ / 10); /* wait 100ms */
2738 if (scratchpad != CCISS_FIRMWARE_READY) {
2739 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
2743 /* get the address index number */
2744 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2745 cfg_base_addr &= (__u32) 0x0000ffff;
2747 printk("cfg base address = %x\n", cfg_base_addr);
2748 #endif /* CCISS_DEBUG */
2749 cfg_base_addr_index =
2750 find_PCI_BAR_index(pdev, cfg_base_addr);
2752 printk("cfg base address index = %x\n", cfg_base_addr_index);
2753 #endif /* CCISS_DEBUG */
2754 if (cfg_base_addr_index == -1) {
2755 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2760 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2762 printk("cfg offset = %x\n", cfg_offset);
2763 #endif /* CCISS_DEBUG */
2764 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2765 cfg_base_addr_index) + cfg_offset,
2766 sizeof(CfgTable_struct));
2767 c->board_id = board_id;
2770 print_cfg_table(c->cfgtable);
2771 #endif /* CCISS_DEBUG */
2773 for(i=0; i<NR_PRODUCTS; i++) {
2774 if (board_id == products[i].board_id) {
2775 c->product_name = products[i].product_name;
2776 c->access = *(products[i].access);
2780 if (i == NR_PRODUCTS) {
2781 printk(KERN_WARNING "cciss: Sorry, I don't know how"
2782 " to access the Smart Array controller %08lx\n",
2783 (unsigned long)board_id);
2786 if ( (readb(&c->cfgtable->Signature[0]) != 'C') ||
2787 (readb(&c->cfgtable->Signature[1]) != 'I') ||
2788 (readb(&c->cfgtable->Signature[2]) != 'S') ||
2789 (readb(&c->cfgtable->Signature[3]) != 'S') )
2791 printk("Does not appear to be a valid CISS config table\n");
2797 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2799 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2801 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2806 printk("Trying to put board into Simple mode\n");
2807 #endif /* CCISS_DEBUG */
2808 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2809 /* Update the field, and then ring the doorbell */
2810 writel( CFGTBL_Trans_Simple,
2811 &(c->cfgtable->HostWrite.TransportRequest));
2812 writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2814 /* under certain very rare conditions, this can take awhile.
2815 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2816 * as we enter this code.) */
2817 for(i=0;i<MAX_CONFIG_WAIT;i++) {
2818 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2820 /* delay and try again */
2821 set_current_state(TASK_INTERRUPTIBLE);
2822 schedule_timeout(10);
2826 printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
2827 #endif /* CCISS_DEBUG */
2829 print_cfg_table(c->cfgtable);
2830 #endif /* CCISS_DEBUG */
2832 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
2834 printk(KERN_WARNING "cciss: unable to get board into"
2843 * Gets information about the local volumes attached to the controller.
2845 static void cciss_getgeometry(int cntl_num)
2847 ReportLunData_struct *ld_buff;
2848 ReadCapdata_struct *size_buff;
2849 InquiryData_struct *inq_buff;
2857 ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
2858 if (ld_buff == NULL)
2860 printk(KERN_ERR "cciss: out of memory\n");
2863 memset(ld_buff, 0, sizeof(ReportLunData_struct));
2864 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
2865 if (size_buff == NULL)
2867 printk(KERN_ERR "cciss: out of memory\n");
2871 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
2872 if (inq_buff == NULL)
2874 printk(KERN_ERR "cciss: out of memory\n");
2879 /* Get the firmware version */
2880 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
2881 sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
2882 if (return_code == IO_OK)
2884 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
2885 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
2886 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
2887 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
2888 } else /* send command failed */
2890 printk(KERN_WARNING "cciss: unable to determine firmware"
2891 " version of controller\n");
2893 /* Get the number of logical volumes */
2894 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
2895 sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
2897 if( return_code == IO_OK)
2900 printk("LUN Data\n--------------------------\n");
2901 #endif /* CCISS_DEBUG */
2903 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
2904 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
2905 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
2906 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
2907 } else /* reading number of logical volumes failed */
2909 printk(KERN_WARNING "cciss: report logical volume"
2910 " command failed\n");
2913 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
2914 if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
2916 printk(KERN_ERR "ciss: only %d number of logical volumes supported\n",
2918 hba[cntl_num]->num_luns = CISS_MAX_LUN;
2921 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
2922 ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
2923 ld_buff->LUNListLength[3], hba[cntl_num]->num_luns);
2924 #endif /* CCISS_DEBUG */
2926 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
2927 // for(i=0; i< hba[cntl_num]->num_luns; i++)
2928 for(i=0; i < CISS_MAX_LUN; i++)
2930 if (i < hba[cntl_num]->num_luns){
2931 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
2933 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
2935 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
2937 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
2939 hba[cntl_num]->drv[i].LunID = lunid;
2943 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
2944 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
2945 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
2946 hba[cntl_num]->drv[i].LunID);
2947 #endif /* CCISS_DEBUG */
2948 cciss_read_capacity(cntl_num, i, size_buff, 0,
2949 &total_size, &block_size);
2950 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
2951 block_size, inq_buff, &hba[cntl_num]->drv[i]);
2953 /* initialize raid_level to indicate a free space */
2954 hba[cntl_num]->drv[i].raid_level = -1;
2962 /* Function to find the first free pointer into our hba[] array */
2963 /* Returns -1 if no free entries are left. */
2964 static int alloc_cciss_hba(void)
2966 struct gendisk *disk[NWD];
2968 for (n = 0; n < NWD; n++) {
2969 disk[n] = alloc_disk(1 << NWD_SHIFT);
2974 for(i=0; i< MAX_CTLR; i++) {
2977 p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
2980 memset(p, 0, sizeof(ctlr_info_t));
2981 for (n = 0; n < NWD; n++)
2982 p->gendisk[n] = disk[n];
2987 printk(KERN_WARNING "cciss: This driver supports a maximum"
2988 " of %d controllers.\n", MAX_CTLR);
2991 printk(KERN_ERR "cciss: out of memory.\n");
2998 static void free_hba(int i)
3000 ctlr_info_t *p = hba[i];
3004 for (n = 0; n < NWD; n++)
3005 put_disk(p->gendisk[n]);
3010 * This is it. Find all the controllers and register them. I really hate
3011 * stealing all these major device numbers.
3012 * returns the number of block devices registered.
3014 static int __devinit cciss_init_one(struct pci_dev *pdev,
3015 const struct pci_device_id *ent)
3022 printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
3023 " bus %d dev %d func %d\n",
3024 pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
3025 PCI_FUNC(pdev->devfn));
3026 i = alloc_cciss_hba();
3030 hba[i]->busy_initializing = 1;
3032 if (cciss_pci_init(hba[i], pdev) != 0)
3035 sprintf(hba[i]->devname, "cciss%d", i);
3037 hba[i]->pdev = pdev;
3039 /* configure PCI DMA stuff */
3040 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3041 printk("cciss: using DAC cycles\n");
3042 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3043 printk("cciss: not using DAC cycles\n");
3045 printk("cciss: no suitable DMA available\n");
3050 * register with the major number, or get a dynamic major number
3051 * by passing 0 as argument. This is done for greater than
3052 * 8 controller support.
3054 if (i < MAX_CTLR_ORIG)
3055 hba[i]->major = MAJOR_NR + i;
3056 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3057 if(rc == -EBUSY || rc == -EINVAL) {
3059 "cciss: Unable to get major number %d for %s "
3060 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3064 if (i >= MAX_CTLR_ORIG)
3068 /* make sure the board interrupts are off */
3069 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3070 if( request_irq(hba[i]->intr, do_cciss_intr,
3071 SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
3072 hba[i]->devname, hba[i])) {
3073 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3074 hba[i]->intr, hba[i]->devname);
3077 hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
3078 hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
3079 hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3080 &(hba[i]->cmd_pool_dhandle));
3081 hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
3082 hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3083 &(hba[i]->errinfo_pool_dhandle));
3084 if((hba[i]->cmd_pool_bits == NULL)
3085 || (hba[i]->cmd_pool == NULL)
3086 || (hba[i]->errinfo_pool == NULL)) {
3087 printk( KERN_ERR "cciss: out of memory");
3090 #ifdef CONFIG_CISS_SCSI_TAPE
3091 hba[i]->scsi_rejects.complete =
3092 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3093 (NR_CMDS + 5), GFP_KERNEL);
3094 if (hba[i]->scsi_rejects.complete == NULL) {
3095 printk( KERN_ERR "cciss: out of memory");
3099 spin_lock_init(&hba[i]->lock);
3101 /* Initialize the pdev driver private data.
3102 have it point to hba[i]. */
3103 pci_set_drvdata(pdev, hba[i]);
3104 /* command and error info recs zeroed out before
3106 memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
3109 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
3110 #endif /* CCISS_DEBUG */
3112 cciss_getgeometry(i);
3114 cciss_scsi_setup(i);
3116 /* Turn the interrupts on so we can service requests */
3117 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3120 hba[i]->busy_initializing = 0;
3122 for(j=0; j < NWD; j++) { /* mfm */
3123 drive_info_struct *drv = &(hba[i]->drv[j]);
3124 struct gendisk *disk = hba[i]->gendisk[j];
3126 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3129 "cciss: unable to allocate queue for disk %d\n",
3135 q->backing_dev_info.ra_pages = READ_AHEAD;
3136 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3138 /* This is a hardware imposed limit. */
3139 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3141 /* This is a limit in the driver and could be eliminated. */
3142 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3144 blk_queue_max_sectors(q, 512);
3146 q->queuedata = hba[i];
3147 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3148 sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
3149 disk->major = hba[i]->major;
3150 disk->first_minor = j << NWD_SHIFT;
3151 disk->fops = &cciss_fops;
3153 disk->private_data = drv;
3154 /* we must register the controller even if no disks exist */
3155 /* this is for the online array utilities */
3156 if(!drv->heads && j)
3158 blk_queue_hardsect_size(q, drv->block_size);
3159 set_capacity(disk, drv->nr_blocks);
3166 #ifdef CONFIG_CISS_SCSI_TAPE
3167 if(hba[i]->scsi_rejects.complete)
3168 kfree(hba[i]->scsi_rejects.complete);
3170 if(hba[i]->cmd_pool_bits)
3171 kfree(hba[i]->cmd_pool_bits);
3172 if(hba[i]->cmd_pool)
3173 pci_free_consistent(hba[i]->pdev,
3174 NR_CMDS * sizeof(CommandList_struct),
3175 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3176 if(hba[i]->errinfo_pool)
3177 pci_free_consistent(hba[i]->pdev,
3178 NR_CMDS * sizeof( ErrorInfo_struct),
3179 hba[i]->errinfo_pool,
3180 hba[i]->errinfo_pool_dhandle);
3181 free_irq(hba[i]->intr, hba[i]);
3183 unregister_blkdev(hba[i]->major, hba[i]->devname);
3185 release_io_mem(hba[i]);
3187 hba[i]->busy_initializing = 0;
3191 static void __devexit cciss_remove_one (struct pci_dev *pdev)
3193 ctlr_info_t *tmp_ptr;
3198 if (pci_get_drvdata(pdev) == NULL)
3200 printk( KERN_ERR "cciss: Unable to remove device \n");
3203 tmp_ptr = pci_get_drvdata(pdev);
3207 printk(KERN_ERR "cciss: device appears to "
3208 "already be removed \n");
3211 /* Turn board interrupts off and send the flush cache command */
3212 /* sendcmd will turn off interrupt, and send the flush...
3213 * To write all data in the battery backed cache to disks */
3214 memset(flush_buf, 0, 4);
3215 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3217 if(return_code != IO_OK)
3219 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3222 free_irq(hba[i]->intr, hba[i]);
3223 pci_set_drvdata(pdev, NULL);
3224 iounmap(hba[i]->vaddr);
3225 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3226 unregister_blkdev(hba[i]->major, hba[i]->devname);
3227 remove_proc_entry(hba[i]->devname, proc_cciss);
3229 /* remove it from the disk list */
3230 for (j = 0; j < NWD; j++) {
3231 struct gendisk *disk = hba[i]->gendisk[j];
3232 if (disk->flags & GENHD_FL_UP) {
3234 blk_cleanup_queue(disk->queue);
3238 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3239 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3240 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3241 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3242 kfree(hba[i]->cmd_pool_bits);
3243 #ifdef CONFIG_CISS_SCSI_TAPE
3244 kfree(hba[i]->scsi_rejects.complete);
3246 release_io_mem(hba[i]);
3250 static struct pci_driver cciss_pci_driver = {
3252 .probe = cciss_init_one,
3253 .remove = __devexit_p(cciss_remove_one),
3254 .id_table = cciss_pci_device_id, /* id_table */
3258 * This is it. Register the PCI driver information for the cards we control
3259 * the OS will call our registered routines when it finds one of our cards.
3261 static int __init cciss_init(void)
3263 printk(KERN_INFO DRIVER_NAME "\n");
3265 /* Register for our PCI devices */
3266 return pci_module_init(&cciss_pci_driver);
3269 static void __exit cciss_cleanup(void)
3273 pci_unregister_driver(&cciss_pci_driver);
3274 /* double check that all controller entrys have been removed */
3275 for (i=0; i< MAX_CTLR; i++)
3279 printk(KERN_WARNING "cciss: had to remove"
3280 " controller %d\n", i);
3281 cciss_remove_one(hba[i]->pdev);
3284 remove_proc_entry("cciss", proc_root_driver);
3287 static void fail_all_cmds(unsigned long ctlr)
3289 /* If we get here, the board is apparently dead. */
3290 ctlr_info_t *h = hba[ctlr];
3291 CommandList_struct *c;
3292 unsigned long flags;
3294 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3295 h->alive = 0; /* the controller apparently died... */
3297 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3299 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3301 /* move everything off the request queue onto the completed queue */
3302 while( (c = h->reqQ) != NULL ) {
3303 removeQ(&(h->reqQ), c);
3305 addQ (&(h->cmpQ), c);
3308 /* Now, fail everything on the completed queue with a HW error */
3309 while( (c = h->cmpQ) != NULL ) {
3310 removeQ(&h->cmpQ, c);
3311 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3312 if (c->cmd_type == CMD_RWREQ) {
3313 complete_command(h, c, 0);
3314 } else if (c->cmd_type == CMD_IOCTL_PEND)
3315 complete(c->waiting);
3316 #ifdef CONFIG_CISS_SCSI_TAPE
3317 else if (c->cmd_type == CMD_SCSI)
3318 complete_scsi_command(c, 0, 0);
3321 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3325 module_init(cciss_init);
3326 module_exit(cciss_cleanup);