2 * Disk Array driver for HP SA 5xxx and 6xxx Controllers
3 * Copyright 2000, 2006 Hewlett-Packard Development Company, L.P.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
13 * NON INFRINGEMENT. See the GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
23 #include <linux/config.h> /* CONFIG_PROC_FS */
24 #include <linux/module.h>
25 #include <linux/interrupt.h>
26 #include <linux/types.h>
27 #include <linux/pci.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/major.h>
33 #include <linux/bio.h>
34 #include <linux/blkpg.h>
35 #include <linux/timer.h>
36 #include <linux/proc_fs.h>
37 #include <linux/init.h>
38 #include <linux/hdreg.h>
39 #include <linux/spinlock.h>
40 #include <linux/compat.h>
41 #include <linux/blktrace_api.h>
42 #include <asm/uaccess.h>
45 #include <linux/dma-mapping.h>
46 #include <linux/blkdev.h>
47 #include <linux/genhd.h>
48 #include <linux/completion.h>
50 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
51 #define DRIVER_NAME "HP CISS Driver (v 2.6.10)"
52 #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,10)
54 /* Embedded module documentation macros - see modules.h */
55 MODULE_AUTHOR("Hewlett-Packard Company");
56 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.10");
57 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
58 " SA6i P600 P800 P400 P400i E200 E200i");
59 MODULE_LICENSE("GPL");
61 #include "cciss_cmd.h"
63 #include <linux/cciss_ioctl.h>
65 /* define the PCI info for the cards we can control */
66 static const struct pci_device_id cciss_pci_device_id[] = {
67 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
68 0x0E11, 0x4070, 0, 0, 0},
69 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
70 0x0E11, 0x4080, 0, 0, 0},
71 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
72 0x0E11, 0x4082, 0, 0, 0},
73 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
74 0x0E11, 0x4083, 0, 0, 0},
75 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
76 0x0E11, 0x409A, 0, 0, 0},
77 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
78 0x0E11, 0x409B, 0, 0, 0},
79 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
80 0x0E11, 0x409C, 0, 0, 0},
81 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
82 0x0E11, 0x409D, 0, 0, 0},
83 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
84 0x0E11, 0x4091, 0, 0, 0},
85 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
86 0x103C, 0x3225, 0, 0, 0},
87 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
88 0x103c, 0x3223, 0, 0, 0},
89 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
90 0x103c, 0x3234, 0, 0, 0},
91 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
92 0x103c, 0x3235, 0, 0, 0},
93 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
94 0x103c, 0x3211, 0, 0, 0},
95 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
96 0x103c, 0x3212, 0, 0, 0},
97 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
98 0x103c, 0x3213, 0, 0, 0},
99 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
100 0x103c, 0x3214, 0, 0, 0},
101 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
102 0x103c, 0x3215, 0, 0, 0},
105 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
107 #define NR_PRODUCTS ARRAY_SIZE(products)
109 /* board_id = Subsystem Device ID & Vendor ID
110 * product = Marketing Name for the board
111 * access = Address of the struct of function pointers
113 static struct board_type products[] = {
114 { 0x40700E11, "Smart Array 5300", &SA5_access },
115 { 0x40800E11, "Smart Array 5i", &SA5B_access},
116 { 0x40820E11, "Smart Array 532", &SA5B_access},
117 { 0x40830E11, "Smart Array 5312", &SA5B_access},
118 { 0x409A0E11, "Smart Array 641", &SA5_access},
119 { 0x409B0E11, "Smart Array 642", &SA5_access},
120 { 0x409C0E11, "Smart Array 6400", &SA5_access},
121 { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
122 { 0x40910E11, "Smart Array 6i", &SA5_access},
123 { 0x3225103C, "Smart Array P600", &SA5_access},
124 { 0x3223103C, "Smart Array P800", &SA5_access},
125 { 0x3234103C, "Smart Array P400", &SA5_access},
126 { 0x3235103C, "Smart Array P400i", &SA5_access},
127 { 0x3211103C, "Smart Array E200i", &SA5_access},
128 { 0x3212103C, "Smart Array E200", &SA5_access},
129 { 0x3213103C, "Smart Array E200i", &SA5_access},
130 { 0x3214103C, "Smart Array E200i", &SA5_access},
131 { 0x3215103C, "Smart Array E200i", &SA5_access},
134 /* How long to wait (in millesconds) for board to go into simple mode */
135 #define MAX_CONFIG_WAIT 30000
136 #define MAX_IOCTL_CONFIG_WAIT 1000
138 /*define how many times we will try a command because of bus resets */
139 #define MAX_CMD_RETRIES 3
141 #define READ_AHEAD 1024
142 #define NR_CMDS 384 /* #commands that can be outstanding */
145 /* Originally cciss driver only supports 8 major numbers */
146 #define MAX_CTLR_ORIG 8
149 static ctlr_info_t *hba[MAX_CTLR];
151 static void do_cciss_request(request_queue_t *q);
152 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
153 static int cciss_open(struct inode *inode, struct file *filep);
154 static int cciss_release(struct inode *inode, struct file *filep);
155 static int cciss_ioctl(struct inode *inode, struct file *filep,
156 unsigned int cmd, unsigned long arg);
157 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
159 static int revalidate_allvol(ctlr_info_t *host);
160 static int cciss_revalidate(struct gendisk *disk);
161 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
162 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
164 static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
165 int withirq, unsigned int *total_size, unsigned int *block_size);
166 static void cciss_geometry_inquiry(int ctlr, int logvol,
167 int withirq, unsigned int total_size,
168 unsigned int block_size, InquiryData_struct *inq_buff,
169 drive_info_struct *drv);
170 static void cciss_getgeometry(int cntl_num);
171 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, __u32);
172 static void start_io( ctlr_info_t *h);
173 static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
174 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
175 unsigned char *scsi3addr, int cmd_type);
176 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
177 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
180 static void fail_all_cmds(unsigned long ctlr);
182 #ifdef CONFIG_PROC_FS
183 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
184 int length, int *eof, void *data);
185 static void cciss_procinit(int i);
187 static void cciss_procinit(int i) {}
188 #endif /* CONFIG_PROC_FS */
191 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
194 static struct block_device_operations cciss_fops = {
195 .owner = THIS_MODULE,
197 .release = cciss_release,
198 .ioctl = cciss_ioctl,
199 .getgeo = cciss_getgeo,
201 .compat_ioctl = cciss_compat_ioctl,
203 .revalidate_disk= cciss_revalidate,
207 * Enqueuing and dequeuing functions for cmdlists.
209 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
213 c->next = c->prev = c;
215 c->prev = (*Qptr)->prev;
217 (*Qptr)->prev->next = c;
222 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
223 CommandList_struct *c)
225 if (c && c->next != c) {
226 if (*Qptr == c) *Qptr = c->next;
227 c->prev->next = c->next;
228 c->next->prev = c->prev;
235 #include "cciss_scsi.c" /* For SCSI tape support */
237 #ifdef CONFIG_PROC_FS
240 * Report information about this controller.
242 #define ENG_GIG 1000000000
243 #define ENG_GIG_FACTOR (ENG_GIG/512)
244 #define RAID_UNKNOWN 6
245 static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
248 static struct proc_dir_entry *proc_cciss;
250 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
251 int length, int *eof, void *data)
256 ctlr_info_t *h = (ctlr_info_t*)data;
257 drive_info_struct *drv;
259 sector_t vol_sz, vol_sz_frac;
263 /* prevent displaying bogus info during configuration
264 * or deconfiguration of a logical volume
266 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
267 if (h->busy_configuring) {
268 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
271 h->busy_configuring = 1;
272 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
274 size = sprintf(buffer, "%s: HP %s Controller\n"
275 "Board ID: 0x%08lx\n"
276 "Firmware Version: %c%c%c%c\n"
278 "Logical drives: %d\n"
279 "Current Q depth: %d\n"
280 "Current # commands on controller: %d\n"
281 "Max Q depth since init: %d\n"
282 "Max # commands on controller since init: %d\n"
283 "Max SG entries since init: %d\n\n",
286 (unsigned long)h->board_id,
287 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
288 (unsigned int)h->intr[SIMPLE_MODE_INT],
290 h->Qdepth, h->commands_outstanding,
291 h->maxQsinceinit, h->max_outstanding, h->maxSG);
293 pos += size; len += size;
294 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
295 for(i=0; i<=h->highest_lun; i++) {
301 vol_sz = drv->nr_blocks;
302 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
304 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
306 if (drv->raid_level > 5)
307 drv->raid_level = RAID_UNKNOWN;
308 size = sprintf(buffer+len, "cciss/c%dd%d:"
309 "\t%4u.%02uGB\tRAID %s\n",
310 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
311 raid_label[drv->raid_level]);
312 pos += size; len += size;
316 *start = buffer+offset;
320 h->busy_configuring = 0;
325 cciss_proc_write(struct file *file, const char __user *buffer,
326 unsigned long count, void *data)
328 unsigned char cmd[80];
330 #ifdef CONFIG_CISS_SCSI_TAPE
331 ctlr_info_t *h = (ctlr_info_t *) data;
335 if (count > sizeof(cmd)-1) return -EINVAL;
336 if (copy_from_user(cmd, buffer, count)) return -EFAULT;
338 len = strlen(cmd); // above 3 lines ensure safety
339 if (len && cmd[len-1] == '\n')
341 # ifdef CONFIG_CISS_SCSI_TAPE
342 if (strcmp("engage scsi", cmd)==0) {
343 rc = cciss_engage_scsi(h->ctlr);
344 if (rc != 0) return -rc;
347 /* might be nice to have "disengage" too, but it's not
348 safely possible. (only 1 module use count, lock issues.) */
354 * Get us a file in /proc/cciss that says something about each controller.
355 * Create /proc/cciss if it doesn't exist yet.
357 static void __devinit cciss_procinit(int i)
359 struct proc_dir_entry *pde;
361 if (proc_cciss == NULL) {
362 proc_cciss = proc_mkdir("cciss", proc_root_driver);
367 pde = create_proc_read_entry(hba[i]->devname,
368 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
369 proc_cciss, cciss_proc_get_info, hba[i]);
370 pde->write_proc = cciss_proc_write;
372 #endif /* CONFIG_PROC_FS */
375 * For operations that cannot sleep, a command block is allocated at init,
376 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
377 * which ones are free or in use. For operations that can wait for kmalloc
378 * to possible sleep, this routine can be called with get_from_pool set to 0.
379 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
381 static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
383 CommandList_struct *c;
386 dma_addr_t cmd_dma_handle, err_dma_handle;
390 c = (CommandList_struct *) pci_alloc_consistent(
391 h->pdev, sizeof(CommandList_struct), &cmd_dma_handle);
394 memset(c, 0, sizeof(CommandList_struct));
398 c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
399 h->pdev, sizeof(ErrorInfo_struct),
402 if (c->err_info == NULL)
404 pci_free_consistent(h->pdev,
405 sizeof(CommandList_struct), c, cmd_dma_handle);
408 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
409 } else /* get it out of the controllers pool */
412 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
415 } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
417 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
420 memset(c, 0, sizeof(CommandList_struct));
421 cmd_dma_handle = h->cmd_pool_dhandle
422 + i*sizeof(CommandList_struct);
423 c->err_info = h->errinfo_pool + i;
424 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
425 err_dma_handle = h->errinfo_pool_dhandle
426 + i*sizeof(ErrorInfo_struct);
432 c->busaddr = (__u32) cmd_dma_handle;
433 temp64.val = (__u64) err_dma_handle;
434 c->ErrDesc.Addr.lower = temp64.val32.lower;
435 c->ErrDesc.Addr.upper = temp64.val32.upper;
436 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
445 * Frees a command block that was previously allocated with cmd_alloc().
447 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
454 temp64.val32.lower = c->ErrDesc.Addr.lower;
455 temp64.val32.upper = c->ErrDesc.Addr.upper;
456 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
457 c->err_info, (dma_addr_t) temp64.val);
458 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
459 c, (dma_addr_t) c->busaddr);
463 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
468 static inline ctlr_info_t *get_host(struct gendisk *disk)
470 return disk->queue->queuedata;
473 static inline drive_info_struct *get_drv(struct gendisk *disk)
475 return disk->private_data;
479 * Open. Make sure the device is really there.
481 static int cciss_open(struct inode *inode, struct file *filep)
483 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
484 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
487 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
488 #endif /* CCISS_DEBUG */
490 if (host->busy_initializing || drv->busy_configuring)
493 * Root is allowed to open raw volume zero even if it's not configured
494 * so array config can still work. Root is also allowed to open any
495 * volume that has a LUN ID, so it can issue IOCTL to reread the
496 * disk information. I don't think I really like this
497 * but I'm already using way to many device nodes to claim another one
498 * for "raw controller".
500 if (drv->nr_blocks == 0) {
501 if (iminor(inode) != 0) { /* not node 0? */
502 /* if not node 0 make sure it is a partition = 0 */
503 if (iminor(inode) & 0x0f) {
505 /* if it is, make sure we have a LUN ID */
506 } else if (drv->LunID == 0) {
510 if (!capable(CAP_SYS_ADMIN))
520 static int cciss_release(struct inode *inode, struct file *filep)
522 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
523 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
526 printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
527 #endif /* CCISS_DEBUG */
536 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
540 ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
545 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
546 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
548 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
551 case CCISS_GETPCIINFO:
552 case CCISS_GETINTINFO:
553 case CCISS_SETINTINFO:
554 case CCISS_GETNODENAME:
555 case CCISS_SETNODENAME:
556 case CCISS_GETHEARTBEAT:
557 case CCISS_GETBUSTYPES:
558 case CCISS_GETFIRMVER:
559 case CCISS_GETDRIVVER:
560 case CCISS_REVALIDVOLS:
561 case CCISS_DEREGDISK:
562 case CCISS_REGNEWDISK:
564 case CCISS_RESCANDISK:
565 case CCISS_GETLUNINFO:
566 return do_ioctl(f, cmd, arg);
568 case CCISS_PASSTHRU32:
569 return cciss_ioctl32_passthru(f, cmd, arg);
570 case CCISS_BIG_PASSTHRU32:
571 return cciss_ioctl32_big_passthru(f, cmd, arg);
578 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
580 IOCTL32_Command_struct __user *arg32 =
581 (IOCTL32_Command_struct __user *) arg;
582 IOCTL_Command_struct arg64;
583 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
588 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
589 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
590 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
591 err |= get_user(arg64.buf_size, &arg32->buf_size);
592 err |= get_user(cp, &arg32->buf);
593 arg64.buf = compat_ptr(cp);
594 err |= copy_to_user(p, &arg64, sizeof(arg64));
599 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
602 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
608 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
610 BIG_IOCTL32_Command_struct __user *arg32 =
611 (BIG_IOCTL32_Command_struct __user *) arg;
612 BIG_IOCTL_Command_struct arg64;
613 BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
618 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
619 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
620 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
621 err |= get_user(arg64.buf_size, &arg32->buf_size);
622 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
623 err |= get_user(cp, &arg32->buf);
624 arg64.buf = compat_ptr(cp);
625 err |= copy_to_user(p, &arg64, sizeof(arg64));
630 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
633 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
640 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
642 drive_info_struct *drv = get_drv(bdev->bd_disk);
647 geo->heads = drv->heads;
648 geo->sectors = drv->sectors;
649 geo->cylinders = drv->cylinders;
656 static int cciss_ioctl(struct inode *inode, struct file *filep,
657 unsigned int cmd, unsigned long arg)
659 struct block_device *bdev = inode->i_bdev;
660 struct gendisk *disk = bdev->bd_disk;
661 ctlr_info_t *host = get_host(disk);
662 drive_info_struct *drv = get_drv(disk);
663 int ctlr = host->ctlr;
664 void __user *argp = (void __user *)arg;
667 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
668 #endif /* CCISS_DEBUG */
671 case CCISS_GETPCIINFO:
673 cciss_pci_info_struct pciinfo;
675 if (!arg) return -EINVAL;
676 pciinfo.domain = pci_domain_nr(host->pdev->bus);
677 pciinfo.bus = host->pdev->bus->number;
678 pciinfo.dev_fn = host->pdev->devfn;
679 pciinfo.board_id = host->board_id;
680 if (copy_to_user(argp, &pciinfo, sizeof( cciss_pci_info_struct )))
684 case CCISS_GETINTINFO:
686 cciss_coalint_struct intinfo;
687 if (!arg) return -EINVAL;
688 intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
689 intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
690 if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
694 case CCISS_SETINTINFO:
696 cciss_coalint_struct intinfo;
700 if (!arg) return -EINVAL;
701 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
702 if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
704 if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
707 // printk("cciss_ioctl: delay and count cannot be 0\n");
710 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
711 /* Update the field, and then ring the doorbell */
712 writel( intinfo.delay,
713 &(host->cfgtable->HostWrite.CoalIntDelay));
714 writel( intinfo.count,
715 &(host->cfgtable->HostWrite.CoalIntCount));
716 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
718 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
719 if (!(readl(host->vaddr + SA5_DOORBELL)
722 /* delay and try again */
725 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
726 if (i >= MAX_IOCTL_CONFIG_WAIT)
730 case CCISS_GETNODENAME:
732 NodeName_type NodeName;
735 if (!arg) return -EINVAL;
737 NodeName[i] = readb(&host->cfgtable->ServerName[i]);
738 if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
742 case CCISS_SETNODENAME:
744 NodeName_type NodeName;
748 if (!arg) return -EINVAL;
749 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
751 if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
754 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
756 /* Update the field, and then ring the doorbell */
758 writeb( NodeName[i], &host->cfgtable->ServerName[i]);
760 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
762 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
763 if (!(readl(host->vaddr + SA5_DOORBELL)
766 /* delay and try again */
769 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
770 if (i >= MAX_IOCTL_CONFIG_WAIT)
775 case CCISS_GETHEARTBEAT:
777 Heartbeat_type heartbeat;
779 if (!arg) return -EINVAL;
780 heartbeat = readl(&host->cfgtable->HeartBeat);
781 if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
785 case CCISS_GETBUSTYPES:
787 BusTypes_type BusTypes;
789 if (!arg) return -EINVAL;
790 BusTypes = readl(&host->cfgtable->BusTypes);
791 if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
795 case CCISS_GETFIRMVER:
797 FirmwareVer_type firmware;
799 if (!arg) return -EINVAL;
800 memcpy(firmware, host->firm_ver, 4);
802 if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
806 case CCISS_GETDRIVVER:
808 DriverVer_type DriverVer = DRIVER_VERSION;
810 if (!arg) return -EINVAL;
812 if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
817 case CCISS_REVALIDVOLS:
818 if (bdev != bdev->bd_contains || drv != host->drv)
820 return revalidate_allvol(host);
822 case CCISS_GETLUNINFO: {
823 LogvolInfo_struct luninfo;
825 luninfo.LunID = drv->LunID;
826 luninfo.num_opens = drv->usage_count;
827 luninfo.num_parts = 0;
828 if (copy_to_user(argp, &luninfo,
829 sizeof(LogvolInfo_struct)))
833 case CCISS_DEREGDISK:
834 return rebuild_lun_table(host, disk);
837 return rebuild_lun_table(host, NULL);
841 IOCTL_Command_struct iocommand;
842 CommandList_struct *c;
846 DECLARE_COMPLETION(wait);
848 if (!arg) return -EINVAL;
850 if (!capable(CAP_SYS_RAWIO)) return -EPERM;
852 if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
854 if((iocommand.buf_size < 1) &&
855 (iocommand.Request.Type.Direction != XFER_NONE))
859 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
860 /* Check kmalloc limits */
861 if(iocommand.buf_size > 128000)
864 if(iocommand.buf_size > 0)
866 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
870 if (iocommand.Request.Type.Direction == XFER_WRITE)
872 /* Copy the data into the buffer we created */
873 if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
879 memset(buff, 0, iocommand.buf_size);
881 if ((c = cmd_alloc(host , 0)) == NULL)
886 // Fill in the command type
887 c->cmd_type = CMD_IOCTL_PEND;
888 // Fill in Command Header
889 c->Header.ReplyQueue = 0; // unused in simple mode
890 if( iocommand.buf_size > 0) // buffer to fill
892 c->Header.SGList = 1;
893 c->Header.SGTotal= 1;
894 } else // no buffers to fill
896 c->Header.SGList = 0;
897 c->Header.SGTotal= 0;
899 c->Header.LUN = iocommand.LUN_info;
900 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
902 // Fill in Request block
903 c->Request = iocommand.Request;
905 // Fill in the scatter gather information
906 if (iocommand.buf_size > 0 )
908 temp64.val = pci_map_single( host->pdev, buff,
910 PCI_DMA_BIDIRECTIONAL);
911 c->SG[0].Addr.lower = temp64.val32.lower;
912 c->SG[0].Addr.upper = temp64.val32.upper;
913 c->SG[0].Len = iocommand.buf_size;
914 c->SG[0].Ext = 0; // we are not chaining
918 /* Put the request on the tail of the request queue */
919 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
920 addQ(&host->reqQ, c);
923 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
925 wait_for_completion(&wait);
927 /* unlock the buffers from DMA */
928 temp64.val32.lower = c->SG[0].Addr.lower;
929 temp64.val32.upper = c->SG[0].Addr.upper;
930 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
931 iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
933 /* Copy the error information out */
934 iocommand.error_info = *(c->err_info);
935 if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
938 cmd_free(host, c, 0);
942 if (iocommand.Request.Type.Direction == XFER_READ)
944 /* Copy the data out of the buffer we created */
945 if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
948 cmd_free(host, c, 0);
953 cmd_free(host, c, 0);
956 case CCISS_BIG_PASSTHRU: {
957 BIG_IOCTL_Command_struct *ioc;
958 CommandList_struct *c;
959 unsigned char **buff = NULL;
960 int *buff_size = NULL;
966 DECLARE_COMPLETION(wait);
969 BYTE __user *data_ptr;
973 if (!capable(CAP_SYS_RAWIO))
975 ioc = (BIG_IOCTL_Command_struct *)
976 kmalloc(sizeof(*ioc), GFP_KERNEL);
981 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
985 if ((ioc->buf_size < 1) &&
986 (ioc->Request.Type.Direction != XFER_NONE)) {
990 /* Check kmalloc limits using all SGs */
991 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
995 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
999 buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
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 if (copy_from_user(buff[sg_used], data_ptr, sz)) {
1026 memset(buff[sg_used], 0, sz);
1032 if ((c = cmd_alloc(host , 0)) == NULL) {
1036 c->cmd_type = CMD_IOCTL_PEND;
1037 c->Header.ReplyQueue = 0;
1039 if( ioc->buf_size > 0) {
1040 c->Header.SGList = sg_used;
1041 c->Header.SGTotal= sg_used;
1043 c->Header.SGList = 0;
1044 c->Header.SGTotal= 0;
1046 c->Header.LUN = ioc->LUN_info;
1047 c->Header.Tag.lower = c->busaddr;
1049 c->Request = ioc->Request;
1050 if (ioc->buf_size > 0 ) {
1052 for(i=0; i<sg_used; i++) {
1053 temp64.val = pci_map_single( host->pdev, buff[i],
1055 PCI_DMA_BIDIRECTIONAL);
1056 c->SG[i].Addr.lower = temp64.val32.lower;
1057 c->SG[i].Addr.upper = temp64.val32.upper;
1058 c->SG[i].Len = buff_size[i];
1059 c->SG[i].Ext = 0; /* we are not chaining */
1063 /* Put the request on the tail of the request queue */
1064 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1065 addQ(&host->reqQ, c);
1068 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1069 wait_for_completion(&wait);
1070 /* unlock the buffers from DMA */
1071 for(i=0; i<sg_used; i++) {
1072 temp64.val32.lower = c->SG[i].Addr.lower;
1073 temp64.val32.upper = c->SG[i].Addr.upper;
1074 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
1075 buff_size[i], PCI_DMA_BIDIRECTIONAL);
1077 /* Copy the error information out */
1078 ioc->error_info = *(c->err_info);
1079 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1080 cmd_free(host, c, 0);
1084 if (ioc->Request.Type.Direction == XFER_READ) {
1085 /* Copy the data out of the buffer we created */
1086 BYTE __user *ptr = ioc->buf;
1087 for(i=0; i< sg_used; i++) {
1088 if (copy_to_user(ptr, buff[i], buff_size[i])) {
1089 cmd_free(host, c, 0);
1093 ptr += buff_size[i];
1096 cmd_free(host, c, 0);
1100 for(i=0; i<sg_used; i++)
1115 * revalidate_allvol is for online array config utilities. After a
1116 * utility reconfigures the drives in the array, it can use this function
1117 * (through an ioctl) to make the driver zap any previous disk structs for
1118 * that controller and get new ones.
1120 * Right now I'm using the getgeometry() function to do this, but this
1121 * function should probably be finer grained and allow you to revalidate one
1122 * particualar logical volume (instead of all of them on a particular
1125 static int revalidate_allvol(ctlr_info_t *host)
1127 int ctlr = host->ctlr, i;
1128 unsigned long flags;
1130 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1131 if (host->usage_count > 1) {
1132 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1133 printk(KERN_WARNING "cciss: Device busy for volume"
1134 " revalidation (usage=%d)\n", host->usage_count);
1137 host->usage_count++;
1138 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1140 for(i=0; i< NWD; i++) {
1141 struct gendisk *disk = host->gendisk[i];
1143 request_queue_t *q = disk->queue;
1145 if (disk->flags & GENHD_FL_UP)
1148 blk_cleanup_queue(q);
1153 * Set the partition and block size structures for all volumes
1154 * on this controller to zero. We will reread all of this data
1156 memset(host->drv, 0, sizeof(drive_info_struct)
1159 * Tell the array controller not to give us any interrupts while
1160 * we check the new geometry. Then turn interrupts back on when
1163 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1164 cciss_getgeometry(ctlr);
1165 host->access.set_intr_mask(host, CCISS_INTR_ON);
1167 /* Loop through each real device */
1168 for (i = 0; i < NWD; i++) {
1169 struct gendisk *disk = host->gendisk[i];
1170 drive_info_struct *drv = &(host->drv[i]);
1171 /* we must register the controller even if no disks exist */
1172 /* this is for the online array utilities */
1173 if (!drv->heads && i)
1175 blk_queue_hardsect_size(drv->queue, drv->block_size);
1176 set_capacity(disk, drv->nr_blocks);
1179 host->usage_count--;
1183 static inline void complete_buffers(struct bio *bio, int status)
1186 struct bio *xbh = bio->bi_next;
1187 int nr_sectors = bio_sectors(bio);
1189 bio->bi_next = NULL;
1190 blk_finished_io(len);
1191 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
1197 static void cciss_softirq_done(struct request *rq)
1199 CommandList_struct *cmd = rq->completion_data;
1200 ctlr_info_t *h = hba[cmd->ctlr];
1201 unsigned long flags;
1205 if (cmd->Request.Type.Direction == XFER_READ)
1206 ddir = PCI_DMA_FROMDEVICE;
1208 ddir = PCI_DMA_TODEVICE;
1210 /* command did not need to be retried */
1211 /* unmap the DMA mapping for all the scatter gather elements */
1212 for(i=0; i<cmd->Header.SGList; i++) {
1213 temp64.val32.lower = cmd->SG[i].Addr.lower;
1214 temp64.val32.upper = cmd->SG[i].Addr.upper;
1215 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1218 complete_buffers(rq->bio, rq->errors);
1221 printk("Done with %p\n", rq);
1222 #endif /* CCISS_DEBUG */
1224 add_disk_randomness(rq->rq_disk);
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, hba[i]->devname, hba[i])) {
3157 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3158 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3161 hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
3162 hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
3163 hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3164 &(hba[i]->cmd_pool_dhandle));
3165 hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
3166 hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3167 &(hba[i]->errinfo_pool_dhandle));
3168 if((hba[i]->cmd_pool_bits == NULL)
3169 || (hba[i]->cmd_pool == NULL)
3170 || (hba[i]->errinfo_pool == NULL)) {
3171 printk( KERN_ERR "cciss: out of memory");
3174 #ifdef CONFIG_CISS_SCSI_TAPE
3175 hba[i]->scsi_rejects.complete =
3176 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3177 (NR_CMDS + 5), GFP_KERNEL);
3178 if (hba[i]->scsi_rejects.complete == NULL) {
3179 printk( KERN_ERR "cciss: out of memory");
3183 spin_lock_init(&hba[i]->lock);
3185 /* Initialize the pdev driver private data.
3186 have it point to hba[i]. */
3187 pci_set_drvdata(pdev, hba[i]);
3188 /* command and error info recs zeroed out before
3190 memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
3193 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
3194 #endif /* CCISS_DEBUG */
3196 cciss_getgeometry(i);
3198 cciss_scsi_setup(i);
3200 /* Turn the interrupts on so we can service requests */
3201 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3204 hba[i]->busy_initializing = 0;
3206 for(j=0; j < NWD; j++) { /* mfm */
3207 drive_info_struct *drv = &(hba[i]->drv[j]);
3208 struct gendisk *disk = hba[i]->gendisk[j];
3210 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3213 "cciss: unable to allocate queue for disk %d\n",
3219 q->backing_dev_info.ra_pages = READ_AHEAD;
3220 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3222 /* This is a hardware imposed limit. */
3223 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3225 /* This is a limit in the driver and could be eliminated. */
3226 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3228 blk_queue_max_sectors(q, 512);
3230 blk_queue_softirq_done(q, cciss_softirq_done);
3232 q->queuedata = hba[i];
3233 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3234 sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
3235 disk->major = hba[i]->major;
3236 disk->first_minor = j << NWD_SHIFT;
3237 disk->fops = &cciss_fops;
3239 disk->private_data = drv;
3240 disk->driverfs_dev = &pdev->dev;
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);