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");
60 MODULE_VERSION("2.6.8");
62 #include "cciss_cmd.h"
64 #include <linux/cciss_ioctl.h>
66 /* define the PCI info for the cards we can control */
67 static const struct pci_device_id cciss_pci_device_id[] = {
68 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
69 0x0E11, 0x4070, 0, 0, 0},
70 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
71 0x0E11, 0x4080, 0, 0, 0},
72 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
73 0x0E11, 0x4082, 0, 0, 0},
74 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
75 0x0E11, 0x4083, 0, 0, 0},
76 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
77 0x0E11, 0x409A, 0, 0, 0},
78 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
79 0x0E11, 0x409B, 0, 0, 0},
80 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
81 0x0E11, 0x409C, 0, 0, 0},
82 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
83 0x0E11, 0x409D, 0, 0, 0},
84 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
85 0x0E11, 0x4091, 0, 0, 0},
86 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
87 0x103C, 0x3225, 0, 0, 0},
88 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
89 0x103c, 0x3223, 0, 0, 0},
90 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
91 0x103c, 0x3234, 0, 0, 0},
92 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
93 0x103c, 0x3235, 0, 0, 0},
94 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
95 0x103c, 0x3211, 0, 0, 0},
96 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
97 0x103c, 0x3212, 0, 0, 0},
98 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
99 0x103c, 0x3213, 0, 0, 0},
100 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
101 0x103c, 0x3214, 0, 0, 0},
102 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
103 0x103c, 0x3215, 0, 0, 0},
106 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
108 #define NR_PRODUCTS ARRAY_SIZE(products)
110 /* board_id = Subsystem Device ID & Vendor ID
111 * product = Marketing Name for the board
112 * access = Address of the struct of function pointers
114 static struct board_type products[] = {
115 { 0x40700E11, "Smart Array 5300", &SA5_access },
116 { 0x40800E11, "Smart Array 5i", &SA5B_access},
117 { 0x40820E11, "Smart Array 532", &SA5B_access},
118 { 0x40830E11, "Smart Array 5312", &SA5B_access},
119 { 0x409A0E11, "Smart Array 641", &SA5_access},
120 { 0x409B0E11, "Smart Array 642", &SA5_access},
121 { 0x409C0E11, "Smart Array 6400", &SA5_access},
122 { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
123 { 0x40910E11, "Smart Array 6i", &SA5_access},
124 { 0x3225103C, "Smart Array P600", &SA5_access},
125 { 0x3223103C, "Smart Array P800", &SA5_access},
126 { 0x3234103C, "Smart Array P400", &SA5_access},
127 { 0x3235103C, "Smart Array P400i", &SA5_access},
128 { 0x3211103C, "Smart Array E200i", &SA5_access},
129 { 0x3212103C, "Smart Array E200", &SA5_access},
130 { 0x3213103C, "Smart Array E200i", &SA5_access},
131 { 0x3214103C, "Smart Array E200i", &SA5_access},
132 { 0x3215103C, "Smart Array E200i", &SA5_access},
135 /* How long to wait (in millesconds) for board to go into simple mode */
136 #define MAX_CONFIG_WAIT 30000
137 #define MAX_IOCTL_CONFIG_WAIT 1000
139 /*define how many times we will try a command because of bus resets */
140 #define MAX_CMD_RETRIES 3
142 #define READ_AHEAD 1024
143 #define NR_CMDS 384 /* #commands that can be outstanding */
146 /* Originally cciss driver only supports 8 major numbers */
147 #define MAX_CTLR_ORIG 8
150 static ctlr_info_t *hba[MAX_CTLR];
152 static void do_cciss_request(request_queue_t *q);
153 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
154 static int cciss_open(struct inode *inode, struct file *filep);
155 static int cciss_release(struct inode *inode, struct file *filep);
156 static int cciss_ioctl(struct inode *inode, struct file *filep,
157 unsigned int cmd, unsigned long arg);
158 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
160 static int revalidate_allvol(ctlr_info_t *host);
161 static int cciss_revalidate(struct gendisk *disk);
162 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
163 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
165 static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
166 int withirq, unsigned int *total_size, unsigned int *block_size);
167 static void cciss_geometry_inquiry(int ctlr, int logvol,
168 int withirq, unsigned int total_size,
169 unsigned int block_size, InquiryData_struct *inq_buff,
170 drive_info_struct *drv);
171 static void cciss_getgeometry(int cntl_num);
172 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, __u32);
173 static void start_io( ctlr_info_t *h);
174 static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
175 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
176 unsigned char *scsi3addr, int cmd_type);
177 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
178 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
181 static void fail_all_cmds(unsigned long ctlr);
183 #ifdef CONFIG_PROC_FS
184 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
185 int length, int *eof, void *data);
186 static void cciss_procinit(int i);
188 static void cciss_procinit(int i) {}
189 #endif /* CONFIG_PROC_FS */
192 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
195 static struct block_device_operations cciss_fops = {
196 .owner = THIS_MODULE,
198 .release = cciss_release,
199 .ioctl = cciss_ioctl,
200 .getgeo = cciss_getgeo,
202 .compat_ioctl = cciss_compat_ioctl,
204 .revalidate_disk= cciss_revalidate,
208 * Enqueuing and dequeuing functions for cmdlists.
210 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
214 c->next = c->prev = c;
216 c->prev = (*Qptr)->prev;
218 (*Qptr)->prev->next = c;
223 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
224 CommandList_struct *c)
226 if (c && c->next != c) {
227 if (*Qptr == c) *Qptr = c->next;
228 c->prev->next = c->next;
229 c->next->prev = c->prev;
236 #include "cciss_scsi.c" /* For SCSI tape support */
238 #ifdef CONFIG_PROC_FS
241 * Report information about this controller.
243 #define ENG_GIG 1000000000
244 #define ENG_GIG_FACTOR (ENG_GIG/512)
245 #define RAID_UNKNOWN 6
246 static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
249 static struct proc_dir_entry *proc_cciss;
251 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
252 int length, int *eof, void *data)
257 ctlr_info_t *h = (ctlr_info_t*)data;
258 drive_info_struct *drv;
260 sector_t vol_sz, vol_sz_frac;
264 /* prevent displaying bogus info during configuration
265 * or deconfiguration of a logical volume
267 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
268 if (h->busy_configuring) {
269 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
272 h->busy_configuring = 1;
273 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
275 size = sprintf(buffer, "%s: HP %s Controller\n"
276 "Board ID: 0x%08lx\n"
277 "Firmware Version: %c%c%c%c\n"
279 "Logical drives: %d\n"
280 "Current Q depth: %d\n"
281 "Current # commands on controller: %d\n"
282 "Max Q depth since init: %d\n"
283 "Max # commands on controller since init: %d\n"
284 "Max SG entries since init: %d\n\n",
287 (unsigned long)h->board_id,
288 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
289 (unsigned int)h->intr[SIMPLE_MODE_INT],
291 h->Qdepth, h->commands_outstanding,
292 h->maxQsinceinit, h->max_outstanding, h->maxSG);
294 pos += size; len += size;
295 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
296 for(i=0; i<=h->highest_lun; i++) {
302 vol_sz = drv->nr_blocks;
303 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
305 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
307 if (drv->raid_level > 5)
308 drv->raid_level = RAID_UNKNOWN;
309 size = sprintf(buffer+len, "cciss/c%dd%d:"
310 "\t%4u.%02uGB\tRAID %s\n",
311 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
312 raid_label[drv->raid_level]);
313 pos += size; len += size;
317 *start = buffer+offset;
321 h->busy_configuring = 0;
326 cciss_proc_write(struct file *file, const char __user *buffer,
327 unsigned long count, void *data)
329 unsigned char cmd[80];
331 #ifdef CONFIG_CISS_SCSI_TAPE
332 ctlr_info_t *h = (ctlr_info_t *) data;
336 if (count > sizeof(cmd)-1) return -EINVAL;
337 if (copy_from_user(cmd, buffer, count)) return -EFAULT;
339 len = strlen(cmd); // above 3 lines ensure safety
340 if (len && cmd[len-1] == '\n')
342 # ifdef CONFIG_CISS_SCSI_TAPE
343 if (strcmp("engage scsi", cmd)==0) {
344 rc = cciss_engage_scsi(h->ctlr);
345 if (rc != 0) return -rc;
348 /* might be nice to have "disengage" too, but it's not
349 safely possible. (only 1 module use count, lock issues.) */
355 * Get us a file in /proc/cciss that says something about each controller.
356 * Create /proc/cciss if it doesn't exist yet.
358 static void __devinit cciss_procinit(int i)
360 struct proc_dir_entry *pde;
362 if (proc_cciss == NULL) {
363 proc_cciss = proc_mkdir("cciss", proc_root_driver);
368 pde = create_proc_read_entry(hba[i]->devname,
369 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
370 proc_cciss, cciss_proc_get_info, hba[i]);
371 pde->write_proc = cciss_proc_write;
373 #endif /* CONFIG_PROC_FS */
376 * For operations that cannot sleep, a command block is allocated at init,
377 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
378 * which ones are free or in use. For operations that can wait for kmalloc
379 * to possible sleep, this routine can be called with get_from_pool set to 0.
380 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
382 static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
384 CommandList_struct *c;
387 dma_addr_t cmd_dma_handle, err_dma_handle;
391 c = (CommandList_struct *) pci_alloc_consistent(
392 h->pdev, sizeof(CommandList_struct), &cmd_dma_handle);
395 memset(c, 0, sizeof(CommandList_struct));
399 c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
400 h->pdev, sizeof(ErrorInfo_struct),
403 if (c->err_info == NULL)
405 pci_free_consistent(h->pdev,
406 sizeof(CommandList_struct), c, cmd_dma_handle);
409 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
410 } else /* get it out of the controllers pool */
413 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
416 } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
418 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
421 memset(c, 0, sizeof(CommandList_struct));
422 cmd_dma_handle = h->cmd_pool_dhandle
423 + i*sizeof(CommandList_struct);
424 c->err_info = h->errinfo_pool + i;
425 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
426 err_dma_handle = h->errinfo_pool_dhandle
427 + i*sizeof(ErrorInfo_struct);
433 c->busaddr = (__u32) cmd_dma_handle;
434 temp64.val = (__u64) err_dma_handle;
435 c->ErrDesc.Addr.lower = temp64.val32.lower;
436 c->ErrDesc.Addr.upper = temp64.val32.upper;
437 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
446 * Frees a command block that was previously allocated with cmd_alloc().
448 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
455 temp64.val32.lower = c->ErrDesc.Addr.lower;
456 temp64.val32.upper = c->ErrDesc.Addr.upper;
457 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
458 c->err_info, (dma_addr_t) temp64.val);
459 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
460 c, (dma_addr_t) c->busaddr);
464 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
469 static inline ctlr_info_t *get_host(struct gendisk *disk)
471 return disk->queue->queuedata;
474 static inline drive_info_struct *get_drv(struct gendisk *disk)
476 return disk->private_data;
480 * Open. Make sure the device is really there.
482 static int cciss_open(struct inode *inode, struct file *filep)
484 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
485 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
488 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
489 #endif /* CCISS_DEBUG */
491 if (host->busy_initializing || drv->busy_configuring)
494 * Root is allowed to open raw volume zero even if it's not configured
495 * so array config can still work. Root is also allowed to open any
496 * volume that has a LUN ID, so it can issue IOCTL to reread the
497 * disk information. I don't think I really like this
498 * but I'm already using way to many device nodes to claim another one
499 * for "raw controller".
501 if (drv->nr_blocks == 0) {
502 if (iminor(inode) != 0) { /* not node 0? */
503 /* if not node 0 make sure it is a partition = 0 */
504 if (iminor(inode) & 0x0f) {
506 /* if it is, make sure we have a LUN ID */
507 } else if (drv->LunID == 0) {
511 if (!capable(CAP_SYS_ADMIN))
521 static int cciss_release(struct inode *inode, struct file *filep)
523 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
524 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
527 printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
528 #endif /* CCISS_DEBUG */
537 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
541 ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
546 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
547 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
549 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
552 case CCISS_GETPCIINFO:
553 case CCISS_GETINTINFO:
554 case CCISS_SETINTINFO:
555 case CCISS_GETNODENAME:
556 case CCISS_SETNODENAME:
557 case CCISS_GETHEARTBEAT:
558 case CCISS_GETBUSTYPES:
559 case CCISS_GETFIRMVER:
560 case CCISS_GETDRIVVER:
561 case CCISS_REVALIDVOLS:
562 case CCISS_DEREGDISK:
563 case CCISS_REGNEWDISK:
565 case CCISS_RESCANDISK:
566 case CCISS_GETLUNINFO:
567 return do_ioctl(f, cmd, arg);
569 case CCISS_PASSTHRU32:
570 return cciss_ioctl32_passthru(f, cmd, arg);
571 case CCISS_BIG_PASSTHRU32:
572 return cciss_ioctl32_big_passthru(f, cmd, arg);
579 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
581 IOCTL32_Command_struct __user *arg32 =
582 (IOCTL32_Command_struct __user *) arg;
583 IOCTL_Command_struct arg64;
584 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
589 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
590 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
591 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
592 err |= get_user(arg64.buf_size, &arg32->buf_size);
593 err |= get_user(cp, &arg32->buf);
594 arg64.buf = compat_ptr(cp);
595 err |= copy_to_user(p, &arg64, sizeof(arg64));
600 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
603 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
609 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
611 BIG_IOCTL32_Command_struct __user *arg32 =
612 (BIG_IOCTL32_Command_struct __user *) arg;
613 BIG_IOCTL_Command_struct arg64;
614 BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
619 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
620 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
621 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
622 err |= get_user(arg64.buf_size, &arg32->buf_size);
623 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
624 err |= get_user(cp, &arg32->buf);
625 arg64.buf = compat_ptr(cp);
626 err |= copy_to_user(p, &arg64, sizeof(arg64));
631 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
634 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
641 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
643 drive_info_struct *drv = get_drv(bdev->bd_disk);
648 geo->heads = drv->heads;
649 geo->sectors = drv->sectors;
650 geo->cylinders = drv->cylinders;
657 static int cciss_ioctl(struct inode *inode, struct file *filep,
658 unsigned int cmd, unsigned long arg)
660 struct block_device *bdev = inode->i_bdev;
661 struct gendisk *disk = bdev->bd_disk;
662 ctlr_info_t *host = get_host(disk);
663 drive_info_struct *drv = get_drv(disk);
664 int ctlr = host->ctlr;
665 void __user *argp = (void __user *)arg;
668 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
669 #endif /* CCISS_DEBUG */
672 case CCISS_GETPCIINFO:
674 cciss_pci_info_struct pciinfo;
676 if (!arg) return -EINVAL;
677 pciinfo.domain = pci_domain_nr(host->pdev->bus);
678 pciinfo.bus = host->pdev->bus->number;
679 pciinfo.dev_fn = host->pdev->devfn;
680 pciinfo.board_id = host->board_id;
681 if (copy_to_user(argp, &pciinfo, sizeof( cciss_pci_info_struct )))
685 case CCISS_GETINTINFO:
687 cciss_coalint_struct intinfo;
688 if (!arg) return -EINVAL;
689 intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
690 intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
691 if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
695 case CCISS_SETINTINFO:
697 cciss_coalint_struct intinfo;
701 if (!arg) return -EINVAL;
702 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
703 if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
705 if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
708 // printk("cciss_ioctl: delay and count cannot be 0\n");
711 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
712 /* Update the field, and then ring the doorbell */
713 writel( intinfo.delay,
714 &(host->cfgtable->HostWrite.CoalIntDelay));
715 writel( intinfo.count,
716 &(host->cfgtable->HostWrite.CoalIntCount));
717 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
719 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
720 if (!(readl(host->vaddr + SA5_DOORBELL)
723 /* delay and try again */
726 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
727 if (i >= MAX_IOCTL_CONFIG_WAIT)
731 case CCISS_GETNODENAME:
733 NodeName_type NodeName;
736 if (!arg) return -EINVAL;
738 NodeName[i] = readb(&host->cfgtable->ServerName[i]);
739 if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
743 case CCISS_SETNODENAME:
745 NodeName_type NodeName;
749 if (!arg) return -EINVAL;
750 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
752 if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
755 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
757 /* Update the field, and then ring the doorbell */
759 writeb( NodeName[i], &host->cfgtable->ServerName[i]);
761 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
763 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
764 if (!(readl(host->vaddr + SA5_DOORBELL)
767 /* delay and try again */
770 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
771 if (i >= MAX_IOCTL_CONFIG_WAIT)
776 case CCISS_GETHEARTBEAT:
778 Heartbeat_type heartbeat;
780 if (!arg) return -EINVAL;
781 heartbeat = readl(&host->cfgtable->HeartBeat);
782 if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
786 case CCISS_GETBUSTYPES:
788 BusTypes_type BusTypes;
790 if (!arg) return -EINVAL;
791 BusTypes = readl(&host->cfgtable->BusTypes);
792 if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
796 case CCISS_GETFIRMVER:
798 FirmwareVer_type firmware;
800 if (!arg) return -EINVAL;
801 memcpy(firmware, host->firm_ver, 4);
803 if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
807 case CCISS_GETDRIVVER:
809 DriverVer_type DriverVer = DRIVER_VERSION;
811 if (!arg) return -EINVAL;
813 if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
818 case CCISS_REVALIDVOLS:
819 if (bdev != bdev->bd_contains || drv != host->drv)
821 return revalidate_allvol(host);
823 case CCISS_GETLUNINFO: {
824 LogvolInfo_struct luninfo;
826 luninfo.LunID = drv->LunID;
827 luninfo.num_opens = drv->usage_count;
828 luninfo.num_parts = 0;
829 if (copy_to_user(argp, &luninfo,
830 sizeof(LogvolInfo_struct)))
834 case CCISS_DEREGDISK:
835 return rebuild_lun_table(host, disk);
838 return rebuild_lun_table(host, NULL);
842 IOCTL_Command_struct iocommand;
843 CommandList_struct *c;
847 DECLARE_COMPLETION(wait);
849 if (!arg) return -EINVAL;
851 if (!capable(CAP_SYS_RAWIO)) return -EPERM;
853 if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
855 if((iocommand.buf_size < 1) &&
856 (iocommand.Request.Type.Direction != XFER_NONE))
860 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
861 /* Check kmalloc limits */
862 if(iocommand.buf_size > 128000)
865 if(iocommand.buf_size > 0)
867 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
871 if (iocommand.Request.Type.Direction == XFER_WRITE)
873 /* Copy the data into the buffer we created */
874 if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
880 memset(buff, 0, iocommand.buf_size);
882 if ((c = cmd_alloc(host , 0)) == NULL)
887 // Fill in the command type
888 c->cmd_type = CMD_IOCTL_PEND;
889 // Fill in Command Header
890 c->Header.ReplyQueue = 0; // unused in simple mode
891 if( iocommand.buf_size > 0) // buffer to fill
893 c->Header.SGList = 1;
894 c->Header.SGTotal= 1;
895 } else // no buffers to fill
897 c->Header.SGList = 0;
898 c->Header.SGTotal= 0;
900 c->Header.LUN = iocommand.LUN_info;
901 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
903 // Fill in Request block
904 c->Request = iocommand.Request;
906 // Fill in the scatter gather information
907 if (iocommand.buf_size > 0 )
909 temp64.val = pci_map_single( host->pdev, buff,
911 PCI_DMA_BIDIRECTIONAL);
912 c->SG[0].Addr.lower = temp64.val32.lower;
913 c->SG[0].Addr.upper = temp64.val32.upper;
914 c->SG[0].Len = iocommand.buf_size;
915 c->SG[0].Ext = 0; // we are not chaining
919 /* Put the request on the tail of the request queue */
920 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
921 addQ(&host->reqQ, c);
924 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
926 wait_for_completion(&wait);
928 /* unlock the buffers from DMA */
929 temp64.val32.lower = c->SG[0].Addr.lower;
930 temp64.val32.upper = c->SG[0].Addr.upper;
931 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
932 iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
934 /* Copy the error information out */
935 iocommand.error_info = *(c->err_info);
936 if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
939 cmd_free(host, c, 0);
943 if (iocommand.Request.Type.Direction == XFER_READ)
945 /* Copy the data out of the buffer we created */
946 if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
949 cmd_free(host, c, 0);
954 cmd_free(host, c, 0);
957 case CCISS_BIG_PASSTHRU: {
958 BIG_IOCTL_Command_struct *ioc;
959 CommandList_struct *c;
960 unsigned char **buff = NULL;
961 int *buff_size = NULL;
967 DECLARE_COMPLETION(wait);
970 BYTE __user *data_ptr;
974 if (!capable(CAP_SYS_RAWIO))
976 ioc = (BIG_IOCTL_Command_struct *)
977 kmalloc(sizeof(*ioc), GFP_KERNEL);
982 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
986 if ((ioc->buf_size < 1) &&
987 (ioc->Request.Type.Direction != XFER_NONE)) {
991 /* Check kmalloc limits using all SGs */
992 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
996 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1000 buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1005 buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int),
1011 left = ioc->buf_size;
1012 data_ptr = ioc->buf;
1014 sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
1015 buff_size[sg_used] = sz;
1016 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1017 if (buff[sg_used] == NULL) {
1021 if (ioc->Request.Type.Direction == XFER_WRITE) {
1022 if (copy_from_user(buff[sg_used], data_ptr, sz)) {
1027 memset(buff[sg_used], 0, sz);
1033 if ((c = cmd_alloc(host , 0)) == NULL) {
1037 c->cmd_type = CMD_IOCTL_PEND;
1038 c->Header.ReplyQueue = 0;
1040 if( ioc->buf_size > 0) {
1041 c->Header.SGList = sg_used;
1042 c->Header.SGTotal= sg_used;
1044 c->Header.SGList = 0;
1045 c->Header.SGTotal= 0;
1047 c->Header.LUN = ioc->LUN_info;
1048 c->Header.Tag.lower = c->busaddr;
1050 c->Request = ioc->Request;
1051 if (ioc->buf_size > 0 ) {
1053 for(i=0; i<sg_used; i++) {
1054 temp64.val = pci_map_single( host->pdev, buff[i],
1056 PCI_DMA_BIDIRECTIONAL);
1057 c->SG[i].Addr.lower = temp64.val32.lower;
1058 c->SG[i].Addr.upper = temp64.val32.upper;
1059 c->SG[i].Len = buff_size[i];
1060 c->SG[i].Ext = 0; /* we are not chaining */
1064 /* Put the request on the tail of the request queue */
1065 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1066 addQ(&host->reqQ, c);
1069 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1070 wait_for_completion(&wait);
1071 /* unlock the buffers from DMA */
1072 for(i=0; i<sg_used; i++) {
1073 temp64.val32.lower = c->SG[i].Addr.lower;
1074 temp64.val32.upper = c->SG[i].Addr.upper;
1075 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
1076 buff_size[i], PCI_DMA_BIDIRECTIONAL);
1078 /* Copy the error information out */
1079 ioc->error_info = *(c->err_info);
1080 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1081 cmd_free(host, c, 0);
1085 if (ioc->Request.Type.Direction == XFER_READ) {
1086 /* Copy the data out of the buffer we created */
1087 BYTE __user *ptr = ioc->buf;
1088 for(i=0; i< sg_used; i++) {
1089 if (copy_to_user(ptr, buff[i], buff_size[i])) {
1090 cmd_free(host, c, 0);
1094 ptr += buff_size[i];
1097 cmd_free(host, c, 0);
1101 for(i=0; i<sg_used; i++)
1116 * revalidate_allvol is for online array config utilities. After a
1117 * utility reconfigures the drives in the array, it can use this function
1118 * (through an ioctl) to make the driver zap any previous disk structs for
1119 * that controller and get new ones.
1121 * Right now I'm using the getgeometry() function to do this, but this
1122 * function should probably be finer grained and allow you to revalidate one
1123 * particualar logical volume (instead of all of them on a particular
1126 static int revalidate_allvol(ctlr_info_t *host)
1128 int ctlr = host->ctlr, i;
1129 unsigned long flags;
1131 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1132 if (host->usage_count > 1) {
1133 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1134 printk(KERN_WARNING "cciss: Device busy for volume"
1135 " revalidation (usage=%d)\n", host->usage_count);
1138 host->usage_count++;
1139 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1141 for(i=0; i< NWD; i++) {
1142 struct gendisk *disk = host->gendisk[i];
1144 request_queue_t *q = disk->queue;
1146 if (disk->flags & GENHD_FL_UP)
1149 blk_cleanup_queue(q);
1154 * Set the partition and block size structures for all volumes
1155 * on this controller to zero. We will reread all of this data
1157 memset(host->drv, 0, sizeof(drive_info_struct)
1160 * Tell the array controller not to give us any interrupts while
1161 * we check the new geometry. Then turn interrupts back on when
1164 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1165 cciss_getgeometry(ctlr);
1166 host->access.set_intr_mask(host, CCISS_INTR_ON);
1168 /* Loop through each real device */
1169 for (i = 0; i < NWD; i++) {
1170 struct gendisk *disk = host->gendisk[i];
1171 drive_info_struct *drv = &(host->drv[i]);
1172 /* we must register the controller even if no disks exist */
1173 /* this is for the online array utilities */
1174 if (!drv->heads && i)
1176 blk_queue_hardsect_size(drv->queue, drv->block_size);
1177 set_capacity(disk, drv->nr_blocks);
1180 host->usage_count--;
1184 static inline void complete_buffers(struct bio *bio, int status)
1187 struct bio *xbh = bio->bi_next;
1188 int nr_sectors = bio_sectors(bio);
1190 bio->bi_next = NULL;
1191 blk_finished_io(len);
1192 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
1198 static void cciss_softirq_done(struct request *rq)
1200 CommandList_struct *cmd = rq->completion_data;
1201 ctlr_info_t *h = hba[cmd->ctlr];
1202 unsigned long flags;
1206 if (cmd->Request.Type.Direction == XFER_READ)
1207 ddir = PCI_DMA_FROMDEVICE;
1209 ddir = PCI_DMA_TODEVICE;
1211 /* command did not need to be retried */
1212 /* unmap the DMA mapping for all the scatter gather elements */
1213 for(i=0; i<cmd->Header.SGList; i++) {
1214 temp64.val32.lower = cmd->SG[i].Addr.lower;
1215 temp64.val32.upper = cmd->SG[i].Addr.upper;
1216 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1219 complete_buffers(rq->bio, rq->errors);
1222 printk("Done with %p\n", rq);
1223 #endif /* CCISS_DEBUG */
1225 spin_lock_irqsave(&h->lock, flags);
1226 end_that_request_last(rq, rq->errors);
1228 spin_unlock_irqrestore(&h->lock, flags);
1231 /* This function will check the usage_count of the drive to be updated/added.
1232 * If the usage_count is zero then the drive information will be updated and
1233 * the disk will be re-registered with the kernel. If not then it will be
1234 * left alone for the next reboot. The exception to this is disk 0 which
1235 * will always be left registered with the kernel since it is also the
1236 * controller node. Any changes to disk 0 will show up on the next
1239 static void cciss_update_drive_info(int ctlr, int drv_index)
1241 ctlr_info_t *h = hba[ctlr];
1242 struct gendisk *disk;
1243 ReadCapdata_struct *size_buff = NULL;
1244 InquiryData_struct *inq_buff = NULL;
1245 unsigned int block_size;
1246 unsigned int total_size;
1247 unsigned long flags = 0;
1250 /* if the disk already exists then deregister it before proceeding*/
1251 if (h->drv[drv_index].raid_level != -1){
1252 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1253 h->drv[drv_index].busy_configuring = 1;
1254 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1255 ret = deregister_disk(h->gendisk[drv_index],
1256 &h->drv[drv_index], 0);
1257 h->drv[drv_index].busy_configuring = 0;
1260 /* If the disk is in use return */
1265 /* Get information about the disk and modify the driver sturcture */
1266 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1267 if (size_buff == NULL)
1269 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1270 if (inq_buff == NULL)
1273 cciss_read_capacity(ctlr, drv_index, size_buff, 1,
1274 &total_size, &block_size);
1275 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1276 inq_buff, &h->drv[drv_index]);
1279 disk = h->gendisk[drv_index];
1280 set_capacity(disk, h->drv[drv_index].nr_blocks);
1283 /* if it's the controller it's already added */
1285 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1287 /* Set up queue information */
1288 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1289 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1291 /* This is a hardware imposed limit. */
1292 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1294 /* This is a limit in the driver and could be eliminated. */
1295 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1297 blk_queue_max_sectors(disk->queue, 512);
1299 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1301 disk->queue->queuedata = hba[ctlr];
1303 blk_queue_hardsect_size(disk->queue,
1304 hba[ctlr]->drv[drv_index].block_size);
1306 h->drv[drv_index].queue = disk->queue;
1315 printk(KERN_ERR "cciss: out of memory\n");
1319 /* This function will find the first index of the controllers drive array
1320 * that has a -1 for the raid_level and will return that index. This is
1321 * where new drives will be added. If the index to be returned is greater
1322 * than the highest_lun index for the controller then highest_lun is set
1323 * to this new index. If there are no available indexes then -1 is returned.
1325 static int cciss_find_free_drive_index(int ctlr)
1329 for (i=0; i < CISS_MAX_LUN; i++){
1330 if (hba[ctlr]->drv[i].raid_level == -1){
1331 if (i > hba[ctlr]->highest_lun)
1332 hba[ctlr]->highest_lun = i;
1339 /* This function will add and remove logical drives from the Logical
1340 * drive array of the controller and maintain persistancy of ordering
1341 * so that mount points are preserved until the next reboot. This allows
1342 * for the removal of logical drives in the middle of the drive array
1343 * without a re-ordering of those drives.
1345 * h = The controller to perform the operations on
1346 * del_disk = The disk to remove if specified. If the value given
1347 * is NULL then no disk is removed.
1349 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1353 ReportLunData_struct *ld_buff = NULL;
1354 drive_info_struct *drv = NULL;
1361 unsigned long flags;
1363 /* Set busy_configuring flag for this operation */
1364 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1365 if (h->num_luns >= CISS_MAX_LUN){
1366 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1370 if (h->busy_configuring){
1371 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1374 h->busy_configuring = 1;
1376 /* if del_disk is NULL then we are being called to add a new disk
1377 * and update the logical drive table. If it is not NULL then
1378 * we will check if the disk is in use or not.
1380 if (del_disk != NULL){
1381 drv = get_drv(del_disk);
1382 drv->busy_configuring = 1;
1383 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1384 return_code = deregister_disk(del_disk, drv, 1);
1385 drv->busy_configuring = 0;
1386 h->busy_configuring = 0;
1389 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1390 if (!capable(CAP_SYS_RAWIO))
1393 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1394 if (ld_buff == NULL)
1397 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1398 sizeof(ReportLunData_struct), 0, 0, 0,
1401 if (return_code == IO_OK){
1402 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
1403 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
1404 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
1405 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1406 } else{ /* reading number of logical volumes failed */
1407 printk(KERN_WARNING "cciss: report logical volume"
1408 " command failed\n");
1413 num_luns = listlength / 8; /* 8 bytes per entry */
1414 if (num_luns > CISS_MAX_LUN){
1415 num_luns = CISS_MAX_LUN;
1416 printk(KERN_WARNING "cciss: more luns configured"
1417 " on controller than can be handled by"
1421 /* Compare controller drive array to drivers drive array.
1422 * Check for updates in the drive information and any new drives
1423 * on the controller.
1425 for (i=0; i < num_luns; i++){
1431 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1433 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1435 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1437 (unsigned int)(ld_buff->LUN[i][0]);
1439 /* Find if the LUN is already in the drive array
1440 * of the controller. If so then update its info
1441 * if not is use. If it does not exist then find
1442 * the first free index and add it.
1444 for (j=0; j <= h->highest_lun; j++){
1445 if (h->drv[j].LunID == lunid){
1451 /* check if the drive was found already in the array */
1453 drv_index = cciss_find_free_drive_index(ctlr);
1454 if (drv_index == -1)
1458 h->drv[drv_index].LunID = lunid;
1459 cciss_update_drive_info(ctlr, drv_index);
1465 h->busy_configuring = 0;
1466 /* We return -1 here to tell the ACU that we have registered/updated
1467 * all of the drives that we can and to keep it from calling us
1472 printk(KERN_ERR "cciss: out of memory\n");
1476 /* This function will deregister the disk and it's queue from the
1477 * kernel. It must be called with the controller lock held and the
1478 * drv structures busy_configuring flag set. It's parameters are:
1480 * disk = This is the disk to be deregistered
1481 * drv = This is the drive_info_struct associated with the disk to be
1482 * deregistered. It contains information about the disk used
1484 * clear_all = This flag determines whether or not the disk information
1485 * is going to be completely cleared out and the highest_lun
1486 * reset. Sometimes we want to clear out information about
1487 * the disk in preperation for re-adding it. In this case
1488 * the highest_lun should be left unchanged and the LunID
1489 * should not be cleared.
1491 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1494 ctlr_info_t *h = get_host(disk);
1496 if (!capable(CAP_SYS_RAWIO))
1499 /* make sure logical volume is NOT is use */
1500 if(clear_all || (h->gendisk[0] == disk)) {
1501 if (drv->usage_count > 1)
1505 if( drv->usage_count > 0 )
1508 /* invalidate the devices and deregister the disk. If it is disk
1509 * zero do not deregister it but just zero out it's values. This
1510 * allows us to delete disk zero but keep the controller registered.
1512 if (h->gendisk[0] != disk){
1514 request_queue_t *q = disk->queue;
1515 if (disk->flags & GENHD_FL_UP)
1518 blk_cleanup_queue(q);
1525 /* zero out the disk size info */
1527 drv->block_size = 0;
1531 drv->raid_level = -1; /* This can be used as a flag variable to
1532 * indicate that this element of the drive
1537 /* check to see if it was the last disk */
1538 if (drv == h->drv + h->highest_lun) {
1539 /* if so, find the new hightest lun */
1540 int i, newhighest =-1;
1541 for(i=0; i<h->highest_lun; i++) {
1542 /* if the disk has size > 0, it is available */
1543 if (h->drv[i].heads)
1546 h->highest_lun = newhighest;
1554 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
1556 unsigned int use_unit_num, /* 0: address the controller,
1557 1: address logical volume log_unit,
1558 2: periph device address is scsi3addr */
1559 unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
1562 ctlr_info_t *h= hba[ctlr];
1563 u64bit buff_dma_handle;
1566 c->cmd_type = CMD_IOCTL_PEND;
1567 c->Header.ReplyQueue = 0;
1569 c->Header.SGList = 1;
1570 c->Header.SGTotal= 1;
1572 c->Header.SGList = 0;
1573 c->Header.SGTotal= 0;
1575 c->Header.Tag.lower = c->busaddr;
1577 c->Request.Type.Type = cmd_type;
1578 if (cmd_type == TYPE_CMD) {
1581 /* If the logical unit number is 0 then, this is going
1582 to controller so It's a physical command
1583 mode = 0 target = 0. So we have nothing to write.
1584 otherwise, if use_unit_num == 1,
1585 mode = 1(volume set addressing) target = LUNID
1586 otherwise, if use_unit_num == 2,
1587 mode = 0(periph dev addr) target = scsi3addr */
1588 if (use_unit_num == 1) {
1589 c->Header.LUN.LogDev.VolId=
1590 h->drv[log_unit].LunID;
1591 c->Header.LUN.LogDev.Mode = 1;
1592 } else if (use_unit_num == 2) {
1593 memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
1594 c->Header.LUN.LogDev.Mode = 0;
1596 /* are we trying to read a vital product page */
1597 if(page_code != 0) {
1598 c->Request.CDB[1] = 0x01;
1599 c->Request.CDB[2] = page_code;
1601 c->Request.CDBLen = 6;
1602 c->Request.Type.Attribute = ATTR_SIMPLE;
1603 c->Request.Type.Direction = XFER_READ;
1604 c->Request.Timeout = 0;
1605 c->Request.CDB[0] = CISS_INQUIRY;
1606 c->Request.CDB[4] = size & 0xFF;
1608 case CISS_REPORT_LOG:
1609 case CISS_REPORT_PHYS:
1610 /* Talking to controller so It's a physical command
1611 mode = 00 target = 0. Nothing to write.
1613 c->Request.CDBLen = 12;
1614 c->Request.Type.Attribute = ATTR_SIMPLE;
1615 c->Request.Type.Direction = XFER_READ;
1616 c->Request.Timeout = 0;
1617 c->Request.CDB[0] = cmd;
1618 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1619 c->Request.CDB[7] = (size >> 16) & 0xFF;
1620 c->Request.CDB[8] = (size >> 8) & 0xFF;
1621 c->Request.CDB[9] = size & 0xFF;
1624 case CCISS_READ_CAPACITY:
1625 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1626 c->Header.LUN.LogDev.Mode = 1;
1627 c->Request.CDBLen = 10;
1628 c->Request.Type.Attribute = ATTR_SIMPLE;
1629 c->Request.Type.Direction = XFER_READ;
1630 c->Request.Timeout = 0;
1631 c->Request.CDB[0] = cmd;
1633 case CCISS_CACHE_FLUSH:
1634 c->Request.CDBLen = 12;
1635 c->Request.Type.Attribute = ATTR_SIMPLE;
1636 c->Request.Type.Direction = XFER_WRITE;
1637 c->Request.Timeout = 0;
1638 c->Request.CDB[0] = BMIC_WRITE;
1639 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1643 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1646 } else if (cmd_type == TYPE_MSG) {
1648 case 0: /* ABORT message */
1649 c->Request.CDBLen = 12;
1650 c->Request.Type.Attribute = ATTR_SIMPLE;
1651 c->Request.Type.Direction = XFER_WRITE;
1652 c->Request.Timeout = 0;
1653 c->Request.CDB[0] = cmd; /* abort */
1654 c->Request.CDB[1] = 0; /* abort a command */
1655 /* buff contains the tag of the command to abort */
1656 memcpy(&c->Request.CDB[4], buff, 8);
1658 case 1: /* RESET message */
1659 c->Request.CDBLen = 12;
1660 c->Request.Type.Attribute = ATTR_SIMPLE;
1661 c->Request.Type.Direction = XFER_WRITE;
1662 c->Request.Timeout = 0;
1663 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1664 c->Request.CDB[0] = cmd; /* reset */
1665 c->Request.CDB[1] = 0x04; /* reset a LUN */
1666 case 3: /* No-Op message */
1667 c->Request.CDBLen = 1;
1668 c->Request.Type.Attribute = ATTR_SIMPLE;
1669 c->Request.Type.Direction = XFER_WRITE;
1670 c->Request.Timeout = 0;
1671 c->Request.CDB[0] = cmd;
1675 "cciss%d: unknown message type %d\n",
1681 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1684 /* Fill in the scatter gather information */
1686 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1687 buff, size, PCI_DMA_BIDIRECTIONAL);
1688 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1689 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1690 c->SG[0].Len = size;
1691 c->SG[0].Ext = 0; /* we are not chaining */
1695 static int sendcmd_withirq(__u8 cmd,
1699 unsigned int use_unit_num,
1700 unsigned int log_unit,
1704 ctlr_info_t *h = hba[ctlr];
1705 CommandList_struct *c;
1706 u64bit buff_dma_handle;
1707 unsigned long flags;
1709 DECLARE_COMPLETION(wait);
1711 if ((c = cmd_alloc(h , 0)) == NULL)
1713 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1714 log_unit, page_code, NULL, cmd_type);
1715 if (return_status != IO_OK) {
1717 return return_status;
1722 /* Put the request on the tail of the queue and send it */
1723 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1727 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1729 wait_for_completion(&wait);
1731 if(c->err_info->CommandStatus != 0)
1732 { /* an error has occurred */
1733 switch(c->err_info->CommandStatus)
1735 case CMD_TARGET_STATUS:
1736 printk(KERN_WARNING "cciss: cmd %p has "
1737 " completed with errors\n", c);
1738 if( c->err_info->ScsiStatus)
1740 printk(KERN_WARNING "cciss: cmd %p "
1741 "has SCSI Status = %x\n",
1743 c->err_info->ScsiStatus);
1747 case CMD_DATA_UNDERRUN:
1748 case CMD_DATA_OVERRUN:
1749 /* expected for inquire and report lun commands */
1752 printk(KERN_WARNING "cciss: Cmd %p is "
1753 "reported invalid\n", c);
1754 return_status = IO_ERROR;
1756 case CMD_PROTOCOL_ERR:
1757 printk(KERN_WARNING "cciss: cmd %p has "
1758 "protocol error \n", c);
1759 return_status = IO_ERROR;
1761 case CMD_HARDWARE_ERR:
1762 printk(KERN_WARNING "cciss: cmd %p had "
1763 " hardware error\n", c);
1764 return_status = IO_ERROR;
1766 case CMD_CONNECTION_LOST:
1767 printk(KERN_WARNING "cciss: cmd %p had "
1768 "connection lost\n", c);
1769 return_status = IO_ERROR;
1772 printk(KERN_WARNING "cciss: cmd %p was "
1774 return_status = IO_ERROR;
1776 case CMD_ABORT_FAILED:
1777 printk(KERN_WARNING "cciss: cmd %p reports "
1778 "abort failed\n", c);
1779 return_status = IO_ERROR;
1781 case CMD_UNSOLICITED_ABORT:
1783 "cciss%d: unsolicited abort %p\n",
1785 if (c->retry_count < MAX_CMD_RETRIES) {
1787 "cciss%d: retrying %p\n",
1790 /* erase the old error information */
1791 memset(c->err_info, 0,
1792 sizeof(ErrorInfo_struct));
1793 return_status = IO_OK;
1794 INIT_COMPLETION(wait);
1797 return_status = IO_ERROR;
1800 printk(KERN_WARNING "cciss: cmd %p returned "
1801 "unknown status %x\n", c,
1802 c->err_info->CommandStatus);
1803 return_status = IO_ERROR;
1806 /* unlock the buffers from DMA */
1807 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1808 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1809 pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
1810 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1812 return(return_status);
1815 static void cciss_geometry_inquiry(int ctlr, int logvol,
1816 int withirq, unsigned int total_size,
1817 unsigned int block_size, InquiryData_struct *inq_buff,
1818 drive_info_struct *drv)
1821 memset(inq_buff, 0, sizeof(InquiryData_struct));
1823 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1824 inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
1826 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1827 sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
1828 if (return_code == IO_OK) {
1829 if(inq_buff->data_byte[8] == 0xFF) {
1831 "cciss: reading geometry failed, volume "
1832 "does not support reading geometry\n");
1833 drv->block_size = block_size;
1834 drv->nr_blocks = total_size;
1836 drv->sectors = 32; // Sectors per track
1837 drv->cylinders = total_size / 255 / 32;
1841 drv->block_size = block_size;
1842 drv->nr_blocks = total_size;
1843 drv->heads = inq_buff->data_byte[6];
1844 drv->sectors = inq_buff->data_byte[7];
1845 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1846 drv->cylinders += inq_buff->data_byte[5];
1847 drv->raid_level = inq_buff->data_byte[8];
1848 t = drv->heads * drv->sectors;
1850 drv->cylinders = total_size/t;
1853 } else { /* Get geometry failed */
1854 printk(KERN_WARNING "cciss: reading geometry failed\n");
1856 printk(KERN_INFO " heads= %d, sectors= %d, cylinders= %d\n\n",
1857 drv->heads, drv->sectors, drv->cylinders);
1860 cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
1861 int withirq, unsigned int *total_size, unsigned int *block_size)
1864 memset(buf, 0, sizeof(*buf));
1866 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1867 ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
1869 return_code = sendcmd(CCISS_READ_CAPACITY,
1870 ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
1871 if (return_code == IO_OK) {
1872 *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
1873 *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
1874 } else { /* read capacity command failed */
1875 printk(KERN_WARNING "cciss: read capacity failed\n");
1877 *block_size = BLOCK_SIZE;
1879 printk(KERN_INFO " blocks= %u block_size= %d\n",
1880 *total_size, *block_size);
1884 static int cciss_revalidate(struct gendisk *disk)
1886 ctlr_info_t *h = get_host(disk);
1887 drive_info_struct *drv = get_drv(disk);
1890 unsigned int block_size;
1891 unsigned int total_size;
1892 ReadCapdata_struct *size_buff = NULL;
1893 InquiryData_struct *inq_buff = NULL;
1895 for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
1897 if(h->drv[logvol].LunID == drv->LunID) {
1903 if (!FOUND) return 1;
1905 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1906 if (size_buff == NULL)
1908 printk(KERN_WARNING "cciss: out of memory\n");
1911 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1912 if (inq_buff == NULL)
1914 printk(KERN_WARNING "cciss: out of memory\n");
1919 cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
1920 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
1922 blk_queue_hardsect_size(drv->queue, drv->block_size);
1923 set_capacity(disk, drv->nr_blocks);
1931 * Wait polling for a command to complete.
1932 * The memory mapped FIFO is polled for the completion.
1933 * Used only at init time, interrupts from the HBA are disabled.
1935 static unsigned long pollcomplete(int ctlr)
1940 /* Wait (up to 20 seconds) for a command to complete */
1942 for (i = 20 * HZ; i > 0; i--) {
1943 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1944 if (done == FIFO_EMPTY)
1945 schedule_timeout_uninterruptible(1);
1949 /* Invalid address to tell caller we ran out of time */
1953 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
1955 /* We get in here if sendcmd() is polling for completions
1956 and gets some command back that it wasn't expecting --
1957 something other than that which it just sent down.
1958 Ordinarily, that shouldn't happen, but it can happen when
1959 the scsi tape stuff gets into error handling mode, and
1960 starts using sendcmd() to try to abort commands and
1961 reset tape drives. In that case, sendcmd may pick up
1962 completions of commands that were sent to logical drives
1963 through the block i/o system, or cciss ioctls completing, etc.
1964 In that case, we need to save those completions for later
1965 processing by the interrupt handler.
1968 #ifdef CONFIG_CISS_SCSI_TAPE
1969 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
1971 /* If it's not the scsi tape stuff doing error handling, (abort */
1972 /* or reset) then we don't expect anything weird. */
1973 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
1975 printk( KERN_WARNING "cciss cciss%d: SendCmd "
1976 "Invalid command list address returned! (%lx)\n",
1978 /* not much we can do. */
1979 #ifdef CONFIG_CISS_SCSI_TAPE
1983 /* We've sent down an abort or reset, but something else
1985 if (srl->ncompletions >= (NR_CMDS + 2)) {
1986 /* Uh oh. No room to save it for later... */
1987 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
1988 "reject list overflow, command lost!\n", ctlr);
1991 /* Save it for later */
1992 srl->complete[srl->ncompletions] = complete;
1993 srl->ncompletions++;
1999 * Send a command to the controller, and wait for it to complete.
2000 * Only used at init time.
2007 unsigned int use_unit_num, /* 0: address the controller,
2008 1: address logical volume log_unit,
2009 2: periph device address is scsi3addr */
2010 unsigned int log_unit,
2012 unsigned char *scsi3addr,
2015 CommandList_struct *c;
2017 unsigned long complete;
2018 ctlr_info_t *info_p= hba[ctlr];
2019 u64bit buff_dma_handle;
2020 int status, done = 0;
2022 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2023 printk(KERN_WARNING "cciss: unable to get memory");
2026 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2027 log_unit, page_code, scsi3addr, cmd_type);
2028 if (status != IO_OK) {
2029 cmd_free(info_p, c, 1);
2037 printk(KERN_DEBUG "cciss: turning intr off\n");
2038 #endif /* CCISS_DEBUG */
2039 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2041 /* Make sure there is room in the command FIFO */
2042 /* Actually it should be completely empty at this time */
2043 /* unless we are in here doing error handling for the scsi */
2044 /* tape side of the driver. */
2045 for (i = 200000; i > 0; i--)
2047 /* if fifo isn't full go */
2048 if (!(info_p->access.fifo_full(info_p)))
2054 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2055 " waiting!\n", ctlr);
2060 info_p->access.submit_command(info_p, c);
2063 complete = pollcomplete(ctlr);
2066 printk(KERN_DEBUG "cciss: command completed\n");
2067 #endif /* CCISS_DEBUG */
2069 if (complete == 1) {
2070 printk( KERN_WARNING
2071 "cciss cciss%d: SendCmd Timeout out, "
2072 "No command list address returned!\n",
2079 /* This will need to change for direct lookup completions */
2080 if ( (complete & CISS_ERROR_BIT)
2081 && (complete & ~CISS_ERROR_BIT) == c->busaddr)
2083 /* if data overrun or underun on Report command
2086 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2087 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2088 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2089 ((c->err_info->CommandStatus ==
2090 CMD_DATA_OVERRUN) ||
2091 (c->err_info->CommandStatus ==
2095 complete = c->busaddr;
2097 if (c->err_info->CommandStatus ==
2098 CMD_UNSOLICITED_ABORT) {
2099 printk(KERN_WARNING "cciss%d: "
2100 "unsolicited abort %p\n",
2102 if (c->retry_count < MAX_CMD_RETRIES) {
2104 "cciss%d: retrying %p\n",
2107 /* erase the old error */
2109 memset(c->err_info, 0,
2110 sizeof(ErrorInfo_struct));
2114 "cciss%d: retried %p too "
2115 "many times\n", ctlr, c);
2119 } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
2120 printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
2124 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2125 " Error %x \n", ctlr,
2126 c->err_info->CommandStatus);
2127 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2129 " size %x\n num %x value %x\n", ctlr,
2130 c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
2131 c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
2132 c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
2137 /* This will need changing for direct lookup completions */
2138 if (complete != c->busaddr) {
2139 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2140 BUG(); /* we are pretty much hosed if we get here. */
2148 /* unlock the data buffer from DMA */
2149 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2150 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2151 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2152 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2153 #ifdef CONFIG_CISS_SCSI_TAPE
2154 /* if we saved some commands for later, process them now. */
2155 if (info_p->scsi_rejects.ncompletions > 0)
2156 do_cciss_intr(0, info_p, NULL);
2158 cmd_free(info_p, c, 1);
2162 * Map (physical) PCI mem into (virtual) kernel space
2164 static void __iomem *remap_pci_mem(ulong base, ulong size)
2166 ulong page_base = ((ulong) base) & PAGE_MASK;
2167 ulong page_offs = ((ulong) base) - page_base;
2168 void __iomem *page_remapped = ioremap(page_base, page_offs+size);
2170 return page_remapped ? (page_remapped + page_offs) : NULL;
2174 * Takes jobs of the Q and sends them to the hardware, then puts it on
2175 * the Q to wait for completion.
2177 static void start_io( ctlr_info_t *h)
2179 CommandList_struct *c;
2181 while(( c = h->reqQ) != NULL )
2183 /* can't do anything if fifo is full */
2184 if ((h->access.fifo_full(h))) {
2185 printk(KERN_WARNING "cciss: fifo full\n");
2189 /* Get the first entry from the Request Q */
2190 removeQ(&(h->reqQ), c);
2193 /* Tell the controller execute command */
2194 h->access.submit_command(h, c);
2196 /* Put job onto the completed Q */
2197 addQ (&(h->cmpQ), c);
2200 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2201 /* Zeros out the error record and then resends the command back */
2202 /* to the controller */
2203 static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
2205 /* erase the old error information */
2206 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2208 /* add it to software queue and then send it to the controller */
2211 if(h->Qdepth > h->maxQsinceinit)
2212 h->maxQsinceinit = h->Qdepth;
2217 /* checks the status of the job and calls complete buffers to mark all
2218 * buffers for the completed job. Note that this function does not need
2219 * to hold the hba/queue lock.
2221 static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
2230 if(cmd->err_info->CommandStatus != 0)
2231 { /* an error has occurred */
2232 switch(cmd->err_info->CommandStatus)
2234 unsigned char sense_key;
2235 case CMD_TARGET_STATUS:
2238 if( cmd->err_info->ScsiStatus == 0x02)
2240 printk(KERN_WARNING "cciss: cmd %p "
2241 "has CHECK CONDITION "
2242 " byte 2 = 0x%x\n", cmd,
2243 cmd->err_info->SenseInfo[2]
2245 /* check the sense key */
2247 cmd->err_info->SenseInfo[2];
2248 /* no status or recovered error */
2249 if((sense_key == 0x0) ||
2256 printk(KERN_WARNING "cciss: cmd %p "
2257 "has SCSI Status 0x%x\n",
2258 cmd, cmd->err_info->ScsiStatus);
2261 case CMD_DATA_UNDERRUN:
2262 printk(KERN_WARNING "cciss: cmd %p has"
2263 " completed with data underrun "
2266 case CMD_DATA_OVERRUN:
2267 printk(KERN_WARNING "cciss: cmd %p has"
2268 " completed with data overrun "
2272 printk(KERN_WARNING "cciss: cmd %p is "
2273 "reported invalid\n", cmd);
2276 case CMD_PROTOCOL_ERR:
2277 printk(KERN_WARNING "cciss: cmd %p has "
2278 "protocol error \n", cmd);
2281 case CMD_HARDWARE_ERR:
2282 printk(KERN_WARNING "cciss: cmd %p had "
2283 " hardware error\n", cmd);
2286 case CMD_CONNECTION_LOST:
2287 printk(KERN_WARNING "cciss: cmd %p had "
2288 "connection lost\n", cmd);
2292 printk(KERN_WARNING "cciss: cmd %p was "
2296 case CMD_ABORT_FAILED:
2297 printk(KERN_WARNING "cciss: cmd %p reports "
2298 "abort failed\n", cmd);
2301 case CMD_UNSOLICITED_ABORT:
2302 printk(KERN_WARNING "cciss%d: unsolicited "
2303 "abort %p\n", h->ctlr, cmd);
2304 if (cmd->retry_count < MAX_CMD_RETRIES) {
2307 "cciss%d: retrying %p\n",
2312 "cciss%d: %p retried too "
2313 "many times\n", h->ctlr, cmd);
2317 printk(KERN_WARNING "cciss: cmd %p timedout\n",
2322 printk(KERN_WARNING "cciss: cmd %p returned "
2323 "unknown status %x\n", cmd,
2324 cmd->err_info->CommandStatus);
2328 /* We need to return this command */
2330 resend_cciss_cmd(h,cmd);
2334 cmd->rq->completion_data = cmd;
2335 cmd->rq->errors = status;
2336 blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
2337 blk_complete_request(cmd->rq);
2341 * Get a request and submit it to the controller.
2343 static void do_cciss_request(request_queue_t *q)
2345 ctlr_info_t *h= q->queuedata;
2346 CommandList_struct *c;
2348 struct request *creq;
2350 struct scatterlist tmp_sg[MAXSGENTRIES];
2351 drive_info_struct *drv;
2354 /* We call start_io here in case there is a command waiting on the
2355 * queue that has not been sent.
2357 if (blk_queue_plugged(q))
2361 creq = elv_next_request(q);
2365 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2367 if (( c = cmd_alloc(h, 1)) == NULL)
2370 blkdev_dequeue_request(creq);
2372 spin_unlock_irq(q->queue_lock);
2374 c->cmd_type = CMD_RWREQ;
2377 /* fill in the request */
2378 drv = creq->rq_disk->private_data;
2379 c->Header.ReplyQueue = 0; // unused in simple mode
2380 /* got command from pool, so use the command block index instead */
2381 /* for direct lookups. */
2382 /* The first 2 bits are reserved for controller error reporting. */
2383 c->Header.Tag.lower = (c->cmdindex << 3);
2384 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2385 c->Header.LUN.LogDev.VolId= drv->LunID;
2386 c->Header.LUN.LogDev.Mode = 1;
2387 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2388 c->Request.Type.Type = TYPE_CMD; // It is a command.
2389 c->Request.Type.Attribute = ATTR_SIMPLE;
2390 c->Request.Type.Direction =
2391 (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE;
2392 c->Request.Timeout = 0; // Don't time out
2393 c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
2394 start_blk = creq->sector;
2396 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
2397 (int) creq->nr_sectors);
2398 #endif /* CCISS_DEBUG */
2400 seg = blk_rq_map_sg(q, creq, tmp_sg);
2402 /* get the DMA records for the setup */
2403 if (c->Request.Type.Direction == XFER_READ)
2404 dir = PCI_DMA_FROMDEVICE;
2406 dir = PCI_DMA_TODEVICE;
2408 for (i=0; i<seg; i++)
2410 c->SG[i].Len = tmp_sg[i].length;
2411 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2412 tmp_sg[i].offset, tmp_sg[i].length,
2414 c->SG[i].Addr.lower = temp64.val32.lower;
2415 c->SG[i].Addr.upper = temp64.val32.upper;
2416 c->SG[i].Ext = 0; // we are not chaining
2418 /* track how many SG entries we are using */
2423 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
2424 #endif /* CCISS_DEBUG */
2426 c->Header.SGList = c->Header.SGTotal = seg;
2427 c->Request.CDB[1]= 0;
2428 c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
2429 c->Request.CDB[3]= (start_blk >> 16) & 0xff;
2430 c->Request.CDB[4]= (start_blk >> 8) & 0xff;
2431 c->Request.CDB[5]= start_blk & 0xff;
2432 c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
2433 c->Request.CDB[7]= (creq->nr_sectors >> 8) & 0xff;
2434 c->Request.CDB[8]= creq->nr_sectors & 0xff;
2435 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2437 spin_lock_irq(q->queue_lock);
2441 if(h->Qdepth > h->maxQsinceinit)
2442 h->maxQsinceinit = h->Qdepth;
2448 /* We will already have the driver lock here so not need
2454 static inline unsigned long get_next_completion(ctlr_info_t *h)
2456 #ifdef CONFIG_CISS_SCSI_TAPE
2457 /* Any rejects from sendcmd() lying around? Process them first */
2458 if (h->scsi_rejects.ncompletions == 0)
2459 return h->access.command_completed(h);
2461 struct sendcmd_reject_list *srl;
2463 srl = &h->scsi_rejects;
2464 n = --srl->ncompletions;
2465 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2467 return srl->complete[n];
2470 return h->access.command_completed(h);
2474 static inline int interrupt_pending(ctlr_info_t *h)
2476 #ifdef CONFIG_CISS_SCSI_TAPE
2477 return ( h->access.intr_pending(h)
2478 || (h->scsi_rejects.ncompletions > 0));
2480 return h->access.intr_pending(h);
2484 static inline long interrupt_not_for_us(ctlr_info_t *h)
2486 #ifdef CONFIG_CISS_SCSI_TAPE
2487 return (((h->access.intr_pending(h) == 0) ||
2488 (h->interrupts_enabled == 0))
2489 && (h->scsi_rejects.ncompletions == 0));
2491 return (((h->access.intr_pending(h) == 0) ||
2492 (h->interrupts_enabled == 0)));
2496 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
2498 ctlr_info_t *h = dev_id;
2499 CommandList_struct *c;
2500 unsigned long flags;
2503 int start_queue = h->next_to_run;
2505 if (interrupt_not_for_us(h))
2508 * If there are completed commands in the completion queue,
2509 * we had better do something about it.
2511 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2512 while (interrupt_pending(h)) {
2513 while((a = get_next_completion(h)) != FIFO_EMPTY) {
2517 if (a2 >= NR_CMDS) {
2518 printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
2519 fail_all_cmds(h->ctlr);
2523 c = h->cmd_pool + a2;
2528 if ((c = h->cmpQ) == NULL) {
2529 printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
2532 while(c->busaddr != a) {
2539 * If we've found the command, take it off the
2540 * completion Q and free it
2542 if (c->busaddr == a) {
2543 removeQ(&h->cmpQ, c);
2544 if (c->cmd_type == CMD_RWREQ) {
2545 complete_command(h, c, 0);
2546 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2547 complete(c->waiting);
2549 # ifdef CONFIG_CISS_SCSI_TAPE
2550 else if (c->cmd_type == CMD_SCSI)
2551 complete_scsi_command(c, 0, a1);
2558 /* check to see if we have maxed out the number of commands that can
2559 * be placed on the queue. If so then exit. We do this check here
2560 * in case the interrupt we serviced was from an ioctl and did not
2561 * free any new commands.
2563 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2566 /* We have room on the queue for more commands. Now we need to queue
2567 * them up. We will also keep track of the next queue to run so
2568 * that every queue gets a chance to be started first.
2570 for (j=0; j < h->highest_lun + 1; j++){
2571 int curr_queue = (start_queue + j) % (h->highest_lun + 1);
2572 /* make sure the disk has been added and the drive is real
2573 * because this can be called from the middle of init_one.
2575 if(!(h->drv[curr_queue].queue) ||
2576 !(h->drv[curr_queue].heads))
2578 blk_start_queue(h->gendisk[curr_queue]->queue);
2580 /* check to see if we have maxed out the number of commands
2581 * that can be placed on the queue.
2583 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2585 if (curr_queue == start_queue){
2586 h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
2589 h->next_to_run = curr_queue;
2593 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
2598 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2602 * We cannot read the structure directly, for portablity we must use
2604 * This is for debug only.
2607 static void print_cfg_table( CfgTable_struct *tb)
2612 printk("Controller Configuration information\n");
2613 printk("------------------------------------\n");
2615 temp_name[i] = readb(&(tb->Signature[i]));
2617 printk(" Signature = %s\n", temp_name);
2618 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2619 printk(" Transport methods supported = 0x%x\n",
2620 readl(&(tb-> TransportSupport)));
2621 printk(" Transport methods active = 0x%x\n",
2622 readl(&(tb->TransportActive)));
2623 printk(" Requested transport Method = 0x%x\n",
2624 readl(&(tb->HostWrite.TransportRequest)));
2625 printk(" Coalese Interrupt Delay = 0x%x\n",
2626 readl(&(tb->HostWrite.CoalIntDelay)));
2627 printk(" Coalese Interrupt Count = 0x%x\n",
2628 readl(&(tb->HostWrite.CoalIntCount)));
2629 printk(" Max outstanding commands = 0x%d\n",
2630 readl(&(tb->CmdsOutMax)));
2631 printk(" Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
2633 temp_name[i] = readb(&(tb->ServerName[i]));
2634 temp_name[16] = '\0';
2635 printk(" Server Name = %s\n", temp_name);
2636 printk(" Heartbeat Counter = 0x%x\n\n\n",
2637 readl(&(tb->HeartBeat)));
2639 #endif /* CCISS_DEBUG */
2641 static void release_io_mem(ctlr_info_t *c)
2643 /* if IO mem was not protected do nothing */
2644 if( c->io_mem_addr == 0)
2646 release_region(c->io_mem_addr, c->io_mem_length);
2648 c->io_mem_length = 0;
2651 static int find_PCI_BAR_index(struct pci_dev *pdev,
2652 unsigned long pci_bar_addr)
2654 int i, offset, mem_type, bar_type;
2655 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2658 for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
2659 bar_type = pci_resource_flags(pdev, i) &
2660 PCI_BASE_ADDRESS_SPACE;
2661 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2664 mem_type = pci_resource_flags(pdev, i) &
2665 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2667 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2668 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2669 offset += 4; /* 32 bit */
2671 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2674 default: /* reserved in PCI 2.2 */
2675 printk(KERN_WARNING "Base address is invalid\n");
2680 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2686 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
2687 * controllers that are capable. If not, we use IO-APIC mode.
2690 static void __devinit cciss_interrupt_mode(ctlr_info_t *c, struct pci_dev *pdev, __u32 board_id)
2692 #ifdef CONFIG_PCI_MSI
2694 struct msix_entry cciss_msix_entries[4] = {{0,0}, {0,1},
2697 /* Some boards advertise MSI but don't really support it */
2698 if ((board_id == 0x40700E11) ||
2699 (board_id == 0x40800E11) ||
2700 (board_id == 0x40820E11) ||
2701 (board_id == 0x40830E11))
2702 goto default_int_mode;
2704 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2705 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2707 c->intr[0] = cciss_msix_entries[0].vector;
2708 c->intr[1] = cciss_msix_entries[1].vector;
2709 c->intr[2] = cciss_msix_entries[2].vector;
2710 c->intr[3] = cciss_msix_entries[3].vector;
2715 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2716 "available\n", err);
2718 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2722 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2723 if (!pci_enable_msi(pdev)) {
2724 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2728 printk(KERN_WARNING "cciss: MSI init failed\n");
2729 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2734 #endif /* CONFIG_PCI_MSI */
2735 /* if we get here we're going to use the default interrupt mode */
2736 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2740 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2742 ushort subsystem_vendor_id, subsystem_device_id, command;
2743 __u32 board_id, scratchpad = 0;
2745 __u32 cfg_base_addr;
2746 __u64 cfg_base_addr_index;
2749 /* check to see if controller has been disabled */
2750 /* BEFORE trying to enable it */
2751 (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
2752 if(!(command & 0x02))
2754 printk(KERN_WARNING "cciss: controller appears to be disabled\n");
2758 if (pci_enable_device(pdev))
2760 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2764 subsystem_vendor_id = pdev->subsystem_vendor;
2765 subsystem_device_id = pdev->subsystem_device;
2766 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2767 subsystem_vendor_id);
2769 /* search for our IO range so we can protect it */
2770 for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
2772 /* is this an IO range */
2773 if( pci_resource_flags(pdev, i) & 0x01 ) {
2774 c->io_mem_addr = pci_resource_start(pdev, i);
2775 c->io_mem_length = pci_resource_end(pdev, i) -
2776 pci_resource_start(pdev, i) +1;
2778 printk("IO value found base_addr[%d] %lx %lx\n", i,
2779 c->io_mem_addr, c->io_mem_length);
2780 #endif /* CCISS_DEBUG */
2781 /* register the IO range */
2782 if(!request_region( c->io_mem_addr,
2783 c->io_mem_length, "cciss"))
2785 printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ld\n",
2786 c->io_mem_addr, c->io_mem_length);
2788 c->io_mem_length = 0;
2795 printk("command = %x\n", command);
2796 printk("irq = %x\n", pdev->irq);
2797 printk("board_id = %x\n", board_id);
2798 #endif /* CCISS_DEBUG */
2800 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2801 * else we use the IO-APIC interrupt assigned to us by system ROM.
2803 cciss_interrupt_mode(c, pdev, board_id);
2806 * Memory base addr is first addr , the second points to the config
2810 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2812 printk("address 0 = %x\n", c->paddr);
2813 #endif /* CCISS_DEBUG */
2814 c->vaddr = remap_pci_mem(c->paddr, 200);
2816 /* Wait for the board to become ready. (PCI hotplug needs this.)
2817 * We poll for up to 120 secs, once per 100ms. */
2818 for (i=0; i < 1200; i++) {
2819 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2820 if (scratchpad == CCISS_FIRMWARE_READY)
2822 set_current_state(TASK_INTERRUPTIBLE);
2823 schedule_timeout(HZ / 10); /* wait 100ms */
2825 if (scratchpad != CCISS_FIRMWARE_READY) {
2826 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
2830 /* get the address index number */
2831 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2832 cfg_base_addr &= (__u32) 0x0000ffff;
2834 printk("cfg base address = %x\n", cfg_base_addr);
2835 #endif /* CCISS_DEBUG */
2836 cfg_base_addr_index =
2837 find_PCI_BAR_index(pdev, cfg_base_addr);
2839 printk("cfg base address index = %x\n", cfg_base_addr_index);
2840 #endif /* CCISS_DEBUG */
2841 if (cfg_base_addr_index == -1) {
2842 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2847 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2849 printk("cfg offset = %x\n", cfg_offset);
2850 #endif /* CCISS_DEBUG */
2851 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2852 cfg_base_addr_index) + cfg_offset,
2853 sizeof(CfgTable_struct));
2854 c->board_id = board_id;
2857 print_cfg_table(c->cfgtable);
2858 #endif /* CCISS_DEBUG */
2860 for(i=0; i<NR_PRODUCTS; i++) {
2861 if (board_id == products[i].board_id) {
2862 c->product_name = products[i].product_name;
2863 c->access = *(products[i].access);
2867 if (i == NR_PRODUCTS) {
2868 printk(KERN_WARNING "cciss: Sorry, I don't know how"
2869 " to access the Smart Array controller %08lx\n",
2870 (unsigned long)board_id);
2873 if ( (readb(&c->cfgtable->Signature[0]) != 'C') ||
2874 (readb(&c->cfgtable->Signature[1]) != 'I') ||
2875 (readb(&c->cfgtable->Signature[2]) != 'S') ||
2876 (readb(&c->cfgtable->Signature[3]) != 'S') )
2878 printk("Does not appear to be a valid CISS config table\n");
2884 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2886 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2888 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2893 printk("Trying to put board into Simple mode\n");
2894 #endif /* CCISS_DEBUG */
2895 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2896 /* Update the field, and then ring the doorbell */
2897 writel( CFGTBL_Trans_Simple,
2898 &(c->cfgtable->HostWrite.TransportRequest));
2899 writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2901 /* under certain very rare conditions, this can take awhile.
2902 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2903 * as we enter this code.) */
2904 for(i=0;i<MAX_CONFIG_WAIT;i++) {
2905 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2907 /* delay and try again */
2908 set_current_state(TASK_INTERRUPTIBLE);
2909 schedule_timeout(10);
2913 printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
2914 #endif /* CCISS_DEBUG */
2916 print_cfg_table(c->cfgtable);
2917 #endif /* CCISS_DEBUG */
2919 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
2921 printk(KERN_WARNING "cciss: unable to get board into"
2930 * Gets information about the local volumes attached to the controller.
2932 static void cciss_getgeometry(int cntl_num)
2934 ReportLunData_struct *ld_buff;
2935 ReadCapdata_struct *size_buff;
2936 InquiryData_struct *inq_buff;
2944 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
2945 if (ld_buff == NULL)
2947 printk(KERN_ERR "cciss: out of memory\n");
2950 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
2951 if (size_buff == NULL)
2953 printk(KERN_ERR "cciss: out of memory\n");
2957 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
2958 if (inq_buff == NULL)
2960 printk(KERN_ERR "cciss: out of memory\n");
2965 /* Get the firmware version */
2966 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
2967 sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
2968 if (return_code == IO_OK)
2970 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
2971 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
2972 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
2973 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
2974 } else /* send command failed */
2976 printk(KERN_WARNING "cciss: unable to determine firmware"
2977 " version of controller\n");
2979 /* Get the number of logical volumes */
2980 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
2981 sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
2983 if( return_code == IO_OK)
2986 printk("LUN Data\n--------------------------\n");
2987 #endif /* CCISS_DEBUG */
2989 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
2990 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
2991 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
2992 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
2993 } else /* reading number of logical volumes failed */
2995 printk(KERN_WARNING "cciss: report logical volume"
2996 " command failed\n");
2999 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
3000 if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
3002 printk(KERN_ERR "ciss: only %d number of logical volumes supported\n",
3004 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3007 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
3008 ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
3009 ld_buff->LUNListLength[3], hba[cntl_num]->num_luns);
3010 #endif /* CCISS_DEBUG */
3012 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
3013 // for(i=0; i< hba[cntl_num]->num_luns; i++)
3014 for(i=0; i < CISS_MAX_LUN; i++)
3016 if (i < hba[cntl_num]->num_luns){
3017 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3019 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3021 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3023 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3025 hba[cntl_num]->drv[i].LunID = lunid;
3029 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
3030 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3031 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3032 hba[cntl_num]->drv[i].LunID);
3033 #endif /* CCISS_DEBUG */
3034 cciss_read_capacity(cntl_num, i, size_buff, 0,
3035 &total_size, &block_size);
3036 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3037 block_size, inq_buff, &hba[cntl_num]->drv[i]);
3039 /* initialize raid_level to indicate a free space */
3040 hba[cntl_num]->drv[i].raid_level = -1;
3048 /* Function to find the first free pointer into our hba[] array */
3049 /* Returns -1 if no free entries are left. */
3050 static int alloc_cciss_hba(void)
3052 struct gendisk *disk[NWD];
3054 for (n = 0; n < NWD; n++) {
3055 disk[n] = alloc_disk(1 << NWD_SHIFT);
3060 for(i=0; i< MAX_CTLR; i++) {
3063 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3066 for (n = 0; n < NWD; n++)
3067 p->gendisk[n] = disk[n];
3072 printk(KERN_WARNING "cciss: This driver supports a maximum"
3073 " of %d controllers.\n", MAX_CTLR);
3076 printk(KERN_ERR "cciss: out of memory.\n");
3083 static void free_hba(int i)
3085 ctlr_info_t *p = hba[i];
3089 for (n = 0; n < NWD; n++)
3090 put_disk(p->gendisk[n]);
3095 * This is it. Find all the controllers and register them. I really hate
3096 * stealing all these major device numbers.
3097 * returns the number of block devices registered.
3099 static int __devinit cciss_init_one(struct pci_dev *pdev,
3100 const struct pci_device_id *ent)
3107 printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
3108 " bus %d dev %d func %d\n",
3109 pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
3110 PCI_FUNC(pdev->devfn));
3111 i = alloc_cciss_hba();
3115 hba[i]->busy_initializing = 1;
3117 if (cciss_pci_init(hba[i], pdev) != 0)
3120 sprintf(hba[i]->devname, "cciss%d", i);
3122 hba[i]->pdev = pdev;
3124 /* configure PCI DMA stuff */
3125 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3126 printk("cciss: using DAC cycles\n");
3127 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3128 printk("cciss: not using DAC cycles\n");
3130 printk("cciss: no suitable DMA available\n");
3135 * register with the major number, or get a dynamic major number
3136 * by passing 0 as argument. This is done for greater than
3137 * 8 controller support.
3139 if (i < MAX_CTLR_ORIG)
3140 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3141 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3142 if(rc == -EBUSY || rc == -EINVAL) {
3144 "cciss: Unable to get major number %d for %s "
3145 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3149 if (i >= MAX_CTLR_ORIG)
3153 /* make sure the board interrupts are off */
3154 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3155 if( request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3156 SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
3157 hba[i]->devname, hba[i])) {
3158 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3159 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3162 hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
3163 hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
3164 hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3165 &(hba[i]->cmd_pool_dhandle));
3166 hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
3167 hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3168 &(hba[i]->errinfo_pool_dhandle));
3169 if((hba[i]->cmd_pool_bits == NULL)
3170 || (hba[i]->cmd_pool == NULL)
3171 || (hba[i]->errinfo_pool == NULL)) {
3172 printk( KERN_ERR "cciss: out of memory");
3175 #ifdef CONFIG_CISS_SCSI_TAPE
3176 hba[i]->scsi_rejects.complete =
3177 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3178 (NR_CMDS + 5), GFP_KERNEL);
3179 if (hba[i]->scsi_rejects.complete == NULL) {
3180 printk( KERN_ERR "cciss: out of memory");
3184 spin_lock_init(&hba[i]->lock);
3186 /* Initialize the pdev driver private data.
3187 have it point to hba[i]. */
3188 pci_set_drvdata(pdev, hba[i]);
3189 /* command and error info recs zeroed out before
3191 memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
3194 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
3195 #endif /* CCISS_DEBUG */
3197 cciss_getgeometry(i);
3199 cciss_scsi_setup(i);
3201 /* Turn the interrupts on so we can service requests */
3202 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3205 hba[i]->busy_initializing = 0;
3207 for(j=0; j < NWD; j++) { /* mfm */
3208 drive_info_struct *drv = &(hba[i]->drv[j]);
3209 struct gendisk *disk = hba[i]->gendisk[j];
3211 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3214 "cciss: unable to allocate queue for disk %d\n",
3220 q->backing_dev_info.ra_pages = READ_AHEAD;
3221 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3223 /* This is a hardware imposed limit. */
3224 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3226 /* This is a limit in the driver and could be eliminated. */
3227 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3229 blk_queue_max_sectors(q, 512);
3231 blk_queue_softirq_done(q, cciss_softirq_done);
3233 q->queuedata = hba[i];
3234 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3235 sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
3236 disk->major = hba[i]->major;
3237 disk->first_minor = j << NWD_SHIFT;
3238 disk->fops = &cciss_fops;
3240 disk->private_data = drv;
3241 /* we must register the controller even if no disks exist */
3242 /* this is for the online array utilities */
3243 if(!drv->heads && j)
3245 blk_queue_hardsect_size(q, drv->block_size);
3246 set_capacity(disk, drv->nr_blocks);
3253 #ifdef CONFIG_CISS_SCSI_TAPE
3254 kfree(hba[i]->scsi_rejects.complete);
3256 kfree(hba[i]->cmd_pool_bits);
3257 if(hba[i]->cmd_pool)
3258 pci_free_consistent(hba[i]->pdev,
3259 NR_CMDS * sizeof(CommandList_struct),
3260 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3261 if(hba[i]->errinfo_pool)
3262 pci_free_consistent(hba[i]->pdev,
3263 NR_CMDS * sizeof( ErrorInfo_struct),
3264 hba[i]->errinfo_pool,
3265 hba[i]->errinfo_pool_dhandle);
3266 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3268 unregister_blkdev(hba[i]->major, hba[i]->devname);
3270 release_io_mem(hba[i]);
3271 hba[i]->busy_initializing = 0;
3276 static void __devexit cciss_remove_one (struct pci_dev *pdev)
3278 ctlr_info_t *tmp_ptr;
3283 if (pci_get_drvdata(pdev) == NULL)
3285 printk( KERN_ERR "cciss: Unable to remove device \n");
3288 tmp_ptr = pci_get_drvdata(pdev);
3292 printk(KERN_ERR "cciss: device appears to "
3293 "already be removed \n");
3296 /* Turn board interrupts off and send the flush cache command */
3297 /* sendcmd will turn off interrupt, and send the flush...
3298 * To write all data in the battery backed cache to disks */
3299 memset(flush_buf, 0, 4);
3300 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3302 if(return_code != IO_OK)
3304 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3307 free_irq(hba[i]->intr[2], hba[i]);
3309 #ifdef CONFIG_PCI_MSI
3310 if (hba[i]->msix_vector)
3311 pci_disable_msix(hba[i]->pdev);
3312 else if (hba[i]->msi_vector)
3313 pci_disable_msi(hba[i]->pdev);
3314 #endif /* CONFIG_PCI_MSI */
3316 pci_set_drvdata(pdev, NULL);
3317 iounmap(hba[i]->vaddr);
3318 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3319 unregister_blkdev(hba[i]->major, hba[i]->devname);
3320 remove_proc_entry(hba[i]->devname, proc_cciss);
3322 /* remove it from the disk list */
3323 for (j = 0; j < NWD; j++) {
3324 struct gendisk *disk = hba[i]->gendisk[j];
3326 request_queue_t *q = disk->queue;
3328 if (disk->flags & GENHD_FL_UP)
3331 blk_cleanup_queue(q);
3335 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3336 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3337 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3338 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3339 kfree(hba[i]->cmd_pool_bits);
3340 #ifdef CONFIG_CISS_SCSI_TAPE
3341 kfree(hba[i]->scsi_rejects.complete);
3343 release_io_mem(hba[i]);
3347 static struct pci_driver cciss_pci_driver = {
3349 .probe = cciss_init_one,
3350 .remove = __devexit_p(cciss_remove_one),
3351 .id_table = cciss_pci_device_id, /* id_table */
3355 * This is it. Register the PCI driver information for the cards we control
3356 * the OS will call our registered routines when it finds one of our cards.
3358 static int __init cciss_init(void)
3360 printk(KERN_INFO DRIVER_NAME "\n");
3362 /* Register for our PCI devices */
3363 return pci_register_driver(&cciss_pci_driver);
3366 static void __exit cciss_cleanup(void)
3370 pci_unregister_driver(&cciss_pci_driver);
3371 /* double check that all controller entrys have been removed */
3372 for (i=0; i< MAX_CTLR; i++)
3376 printk(KERN_WARNING "cciss: had to remove"
3377 " controller %d\n", i);
3378 cciss_remove_one(hba[i]->pdev);
3381 remove_proc_entry("cciss", proc_root_driver);
3384 static void fail_all_cmds(unsigned long ctlr)
3386 /* If we get here, the board is apparently dead. */
3387 ctlr_info_t *h = hba[ctlr];
3388 CommandList_struct *c;
3389 unsigned long flags;
3391 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3392 h->alive = 0; /* the controller apparently died... */
3394 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3396 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3398 /* move everything off the request queue onto the completed queue */
3399 while( (c = h->reqQ) != NULL ) {
3400 removeQ(&(h->reqQ), c);
3402 addQ (&(h->cmpQ), c);
3405 /* Now, fail everything on the completed queue with a HW error */
3406 while( (c = h->cmpQ) != NULL ) {
3407 removeQ(&h->cmpQ, c);
3408 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3409 if (c->cmd_type == CMD_RWREQ) {
3410 complete_command(h, c, 0);
3411 } else if (c->cmd_type == CMD_IOCTL_PEND)
3412 complete(c->waiting);
3413 #ifdef CONFIG_CISS_SCSI_TAPE
3414 else if (c->cmd_type == CMD_SCSI)
3415 complete_scsi_command(c, 0, 0);
3418 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3422 module_init(cciss_init);
3423 module_exit(cciss_cleanup);