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/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/types.h>
26 #include <linux/pci.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/delay.h>
30 #include <linux/major.h>
32 #include <linux/bio.h>
33 #include <linux/blkpg.h>
34 #include <linux/timer.h>
35 #include <linux/proc_fs.h>
36 #include <linux/init.h>
37 #include <linux/hdreg.h>
38 #include <linux/spinlock.h>
39 #include <linux/compat.h>
40 #include <linux/blktrace_api.h>
41 #include <asm/uaccess.h>
44 #include <linux/dma-mapping.h>
45 #include <linux/blkdev.h>
46 #include <linux/genhd.h>
47 #include <linux/completion.h>
49 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
50 #define DRIVER_NAME "HP CISS Driver (v 3.6.10)"
51 #define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,10)
53 /* Embedded module documentation macros - see modules.h */
54 MODULE_AUTHOR("Hewlett-Packard Company");
55 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.10");
56 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
57 " SA6i P600 P800 P400 P400i E200 E200i E500");
58 MODULE_LICENSE("GPL");
60 #include "cciss_cmd.h"
62 #include <linux/cciss_ioctl.h>
64 /* define the PCI info for the cards we can control */
65 static const struct pci_device_id cciss_pci_device_id[] = {
66 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS, 0x0E11, 0x4070},
67 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
68 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
69 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
70 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
71 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
72 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
73 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
74 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
75 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA, 0x103C, 0x3225},
76 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3223},
77 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3234},
78 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3235},
79 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3211},
80 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3212},
81 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3213},
82 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3214},
83 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3215},
84 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3233},
88 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
90 /* board_id = Subsystem Device ID & Vendor ID
91 * product = Marketing Name for the board
92 * access = Address of the struct of function pointers
94 static struct board_type products[] = {
95 {0x40700E11, "Smart Array 5300", &SA5_access},
96 {0x40800E11, "Smart Array 5i", &SA5B_access},
97 {0x40820E11, "Smart Array 532", &SA5B_access},
98 {0x40830E11, "Smart Array 5312", &SA5B_access},
99 {0x409A0E11, "Smart Array 641", &SA5_access},
100 {0x409B0E11, "Smart Array 642", &SA5_access},
101 {0x409C0E11, "Smart Array 6400", &SA5_access},
102 {0x409D0E11, "Smart Array 6400 EM", &SA5_access},
103 {0x40910E11, "Smart Array 6i", &SA5_access},
104 {0x3225103C, "Smart Array P600", &SA5_access},
105 {0x3223103C, "Smart Array P800", &SA5_access},
106 {0x3234103C, "Smart Array P400", &SA5_access},
107 {0x3235103C, "Smart Array P400i", &SA5_access},
108 {0x3211103C, "Smart Array E200i", &SA5_access},
109 {0x3212103C, "Smart Array E200", &SA5_access},
110 {0x3213103C, "Smart Array E200i", &SA5_access},
111 {0x3214103C, "Smart Array E200i", &SA5_access},
112 {0x3215103C, "Smart Array E200i", &SA5_access},
113 {0x3233103C, "Smart Array E500", &SA5_access},
116 /* How long to wait (in milliseconds) for board to go into simple mode */
117 #define MAX_CONFIG_WAIT 30000
118 #define MAX_IOCTL_CONFIG_WAIT 1000
120 /*define how many times we will try a command because of bus resets */
121 #define MAX_CMD_RETRIES 3
123 #define READ_AHEAD 1024
124 #define NR_CMDS 384 /* #commands that can be outstanding */
127 /* Originally cciss driver only supports 8 major numbers */
128 #define MAX_CTLR_ORIG 8
130 static ctlr_info_t *hba[MAX_CTLR];
132 static void do_cciss_request(request_queue_t *q);
133 static irqreturn_t do_cciss_intr(int irq, void *dev_id);
134 static int cciss_open(struct inode *inode, struct file *filep);
135 static int cciss_release(struct inode *inode, struct file *filep);
136 static int cciss_ioctl(struct inode *inode, struct file *filep,
137 unsigned int cmd, unsigned long arg);
138 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
140 static int revalidate_allvol(ctlr_info_t *host);
141 static int cciss_revalidate(struct gendisk *disk);
142 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
143 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
146 static void cciss_read_capacity(int ctlr, int logvol, int withirq,
147 sector_t *total_size, unsigned int *block_size);
148 static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
149 sector_t *total_size, unsigned int *block_size);
150 static void cciss_geometry_inquiry(int ctlr, int logvol,
151 int withirq, sector_t total_size,
152 unsigned int block_size, InquiryData_struct *inq_buff,
153 drive_info_struct *drv);
154 static void cciss_getgeometry(int cntl_num);
155 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
157 static void start_io(ctlr_info_t *h);
158 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
159 unsigned int use_unit_num, unsigned int log_unit,
160 __u8 page_code, unsigned char *scsi3addr, int cmd_type);
161 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
162 unsigned int use_unit_num, unsigned int log_unit,
163 __u8 page_code, int cmd_type);
165 static void fail_all_cmds(unsigned long ctlr);
167 #ifdef CONFIG_PROC_FS
168 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
169 int length, int *eof, void *data);
170 static void cciss_procinit(int i);
172 static void cciss_procinit(int i)
175 #endif /* CONFIG_PROC_FS */
178 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
181 static struct block_device_operations cciss_fops = {
182 .owner = THIS_MODULE,
184 .release = cciss_release,
185 .ioctl = cciss_ioctl,
186 .getgeo = cciss_getgeo,
188 .compat_ioctl = cciss_compat_ioctl,
190 .revalidate_disk = cciss_revalidate,
194 * Enqueuing and dequeuing functions for cmdlists.
196 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
200 c->next = c->prev = c;
202 c->prev = (*Qptr)->prev;
204 (*Qptr)->prev->next = c;
209 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
210 CommandList_struct *c)
212 if (c && c->next != c) {
215 c->prev->next = c->next;
216 c->next->prev = c->prev;
223 #include "cciss_scsi.c" /* For SCSI tape support */
225 #ifdef CONFIG_PROC_FS
228 * Report information about this controller.
230 #define ENG_GIG 1000000000
231 #define ENG_GIG_FACTOR (ENG_GIG/512)
232 #define RAID_UNKNOWN 6
233 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
237 static struct proc_dir_entry *proc_cciss;
239 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
240 int length, int *eof, void *data)
245 ctlr_info_t *h = (ctlr_info_t *) data;
246 drive_info_struct *drv;
248 sector_t vol_sz, vol_sz_frac;
252 /* prevent displaying bogus info during configuration
253 * or deconfiguration of a logical volume
255 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
256 if (h->busy_configuring) {
257 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
260 h->busy_configuring = 1;
261 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
263 size = sprintf(buffer, "%s: HP %s Controller\n"
264 "Board ID: 0x%08lx\n"
265 "Firmware Version: %c%c%c%c\n"
267 "Logical drives: %d\n"
268 "Current Q depth: %d\n"
269 "Current # commands on controller: %d\n"
270 "Max Q depth since init: %d\n"
271 "Max # commands on controller since init: %d\n"
272 "Max SG entries since init: %d\n\n",
275 (unsigned long)h->board_id,
276 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
277 h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
278 h->num_luns, h->Qdepth, h->commands_outstanding,
279 h->maxQsinceinit, h->max_outstanding, h->maxSG);
283 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
284 for (i = 0; i <= h->highest_lun; i++) {
290 vol_sz = drv->nr_blocks;
291 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
293 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
295 if (drv->raid_level > 5)
296 drv->raid_level = RAID_UNKNOWN;
297 size = sprintf(buffer + len, "cciss/c%dd%d:"
298 "\t%4u.%02uGB\tRAID %s\n",
299 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
300 raid_label[drv->raid_level]);
306 *start = buffer + offset;
310 h->busy_configuring = 0;
315 cciss_proc_write(struct file *file, const char __user *buffer,
316 unsigned long count, void *data)
318 unsigned char cmd[80];
320 #ifdef CONFIG_CISS_SCSI_TAPE
321 ctlr_info_t *h = (ctlr_info_t *) data;
325 if (count > sizeof(cmd) - 1)
327 if (copy_from_user(cmd, buffer, count))
330 len = strlen(cmd); // above 3 lines ensure safety
331 if (len && cmd[len - 1] == '\n')
333 # ifdef CONFIG_CISS_SCSI_TAPE
334 if (strcmp("engage scsi", cmd) == 0) {
335 rc = cciss_engage_scsi(h->ctlr);
340 /* might be nice to have "disengage" too, but it's not
341 safely possible. (only 1 module use count, lock issues.) */
347 * Get us a file in /proc/cciss that says something about each controller.
348 * Create /proc/cciss if it doesn't exist yet.
350 static void __devinit cciss_procinit(int i)
352 struct proc_dir_entry *pde;
354 if (proc_cciss == NULL) {
355 proc_cciss = proc_mkdir("cciss", proc_root_driver);
360 pde = create_proc_read_entry(hba[i]->devname,
361 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
362 proc_cciss, cciss_proc_get_info, hba[i]);
363 pde->write_proc = cciss_proc_write;
365 #endif /* CONFIG_PROC_FS */
368 * For operations that cannot sleep, a command block is allocated at init,
369 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
370 * which ones are free or in use. For operations that can wait for kmalloc
371 * to possible sleep, this routine can be called with get_from_pool set to 0.
372 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
374 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
376 CommandList_struct *c;
379 dma_addr_t cmd_dma_handle, err_dma_handle;
381 if (!get_from_pool) {
382 c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
383 sizeof(CommandList_struct), &cmd_dma_handle);
386 memset(c, 0, sizeof(CommandList_struct));
390 c->err_info = (ErrorInfo_struct *)
391 pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
394 if (c->err_info == NULL) {
395 pci_free_consistent(h->pdev,
396 sizeof(CommandList_struct), c, cmd_dma_handle);
399 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
400 } else { /* get it out of the controllers pool */
403 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
406 } while (test_and_set_bit
407 (i & (BITS_PER_LONG - 1),
408 h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
410 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
413 memset(c, 0, sizeof(CommandList_struct));
414 cmd_dma_handle = h->cmd_pool_dhandle
415 + i * sizeof(CommandList_struct);
416 c->err_info = h->errinfo_pool + i;
417 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
418 err_dma_handle = h->errinfo_pool_dhandle
419 + i * sizeof(ErrorInfo_struct);
425 c->busaddr = (__u32) cmd_dma_handle;
426 temp64.val = (__u64) err_dma_handle;
427 c->ErrDesc.Addr.lower = temp64.val32.lower;
428 c->ErrDesc.Addr.upper = temp64.val32.upper;
429 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
436 * Frees a command block that was previously allocated with cmd_alloc().
438 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
443 if (!got_from_pool) {
444 temp64.val32.lower = c->ErrDesc.Addr.lower;
445 temp64.val32.upper = c->ErrDesc.Addr.upper;
446 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
447 c->err_info, (dma_addr_t) temp64.val);
448 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
449 c, (dma_addr_t) c->busaddr);
452 clear_bit(i & (BITS_PER_LONG - 1),
453 h->cmd_pool_bits + (i / BITS_PER_LONG));
458 static inline ctlr_info_t *get_host(struct gendisk *disk)
460 return disk->queue->queuedata;
463 static inline drive_info_struct *get_drv(struct gendisk *disk)
465 return disk->private_data;
469 * Open. Make sure the device is really there.
471 static int cciss_open(struct inode *inode, struct file *filep)
473 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
474 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
477 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
478 #endif /* CCISS_DEBUG */
480 if (host->busy_initializing || drv->busy_configuring)
483 * Root is allowed to open raw volume zero even if it's not configured
484 * so array config can still work. Root is also allowed to open any
485 * volume that has a LUN ID, so it can issue IOCTL to reread the
486 * disk information. I don't think I really like this
487 * but I'm already using way to many device nodes to claim another one
488 * for "raw controller".
490 if (drv->nr_blocks == 0) {
491 if (iminor(inode) != 0) { /* not node 0? */
492 /* if not node 0 make sure it is a partition = 0 */
493 if (iminor(inode) & 0x0f) {
495 /* if it is, make sure we have a LUN ID */
496 } else if (drv->LunID == 0) {
500 if (!capable(CAP_SYS_ADMIN))
511 static int cciss_release(struct inode *inode, struct file *filep)
513 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
514 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
517 printk(KERN_DEBUG "cciss_release %s\n",
518 inode->i_bdev->bd_disk->disk_name);
519 #endif /* CCISS_DEBUG */
528 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
532 ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
537 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
539 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
542 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
545 case CCISS_GETPCIINFO:
546 case CCISS_GETINTINFO:
547 case CCISS_SETINTINFO:
548 case CCISS_GETNODENAME:
549 case CCISS_SETNODENAME:
550 case CCISS_GETHEARTBEAT:
551 case CCISS_GETBUSTYPES:
552 case CCISS_GETFIRMVER:
553 case CCISS_GETDRIVVER:
554 case CCISS_REVALIDVOLS:
555 case CCISS_DEREGDISK:
556 case CCISS_REGNEWDISK:
558 case CCISS_RESCANDISK:
559 case CCISS_GETLUNINFO:
560 return do_ioctl(f, cmd, arg);
562 case CCISS_PASSTHRU32:
563 return cciss_ioctl32_passthru(f, cmd, arg);
564 case CCISS_BIG_PASSTHRU32:
565 return cciss_ioctl32_big_passthru(f, cmd, arg);
572 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
575 IOCTL32_Command_struct __user *arg32 =
576 (IOCTL32_Command_struct __user *) arg;
577 IOCTL_Command_struct arg64;
578 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
584 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
585 sizeof(arg64.LUN_info));
587 copy_from_user(&arg64.Request, &arg32->Request,
588 sizeof(arg64.Request));
590 copy_from_user(&arg64.error_info, &arg32->error_info,
591 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);
604 copy_in_user(&arg32->error_info, &p->error_info,
605 sizeof(arg32->error_info));
611 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
614 BIG_IOCTL32_Command_struct __user *arg32 =
615 (BIG_IOCTL32_Command_struct __user *) arg;
616 BIG_IOCTL_Command_struct arg64;
617 BIG_IOCTL_Command_struct __user *p =
618 compat_alloc_user_space(sizeof(arg64));
624 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
625 sizeof(arg64.LUN_info));
627 copy_from_user(&arg64.Request, &arg32->Request,
628 sizeof(arg64.Request));
630 copy_from_user(&arg64.error_info, &arg32->error_info,
631 sizeof(arg64.error_info));
632 err |= get_user(arg64.buf_size, &arg32->buf_size);
633 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
634 err |= get_user(cp, &arg32->buf);
635 arg64.buf = compat_ptr(cp);
636 err |= copy_to_user(p, &arg64, sizeof(arg64));
641 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
645 copy_in_user(&arg32->error_info, &p->error_info,
646 sizeof(arg32->error_info));
653 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
655 drive_info_struct *drv = get_drv(bdev->bd_disk);
660 geo->heads = drv->heads;
661 geo->sectors = drv->sectors;
662 geo->cylinders = drv->cylinders;
669 static int cciss_ioctl(struct inode *inode, struct file *filep,
670 unsigned int cmd, unsigned long arg)
672 struct block_device *bdev = inode->i_bdev;
673 struct gendisk *disk = bdev->bd_disk;
674 ctlr_info_t *host = get_host(disk);
675 drive_info_struct *drv = get_drv(disk);
676 int ctlr = host->ctlr;
677 void __user *argp = (void __user *)arg;
680 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
681 #endif /* CCISS_DEBUG */
684 case CCISS_GETPCIINFO:
686 cciss_pci_info_struct pciinfo;
690 pciinfo.domain = pci_domain_nr(host->pdev->bus);
691 pciinfo.bus = host->pdev->bus->number;
692 pciinfo.dev_fn = host->pdev->devfn;
693 pciinfo.board_id = host->board_id;
695 (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
699 case CCISS_GETINTINFO:
701 cciss_coalint_struct intinfo;
705 readl(&host->cfgtable->HostWrite.CoalIntDelay);
707 readl(&host->cfgtable->HostWrite.CoalIntCount);
709 (argp, &intinfo, sizeof(cciss_coalint_struct)))
713 case CCISS_SETINTINFO:
715 cciss_coalint_struct intinfo;
721 if (!capable(CAP_SYS_ADMIN))
724 (&intinfo, argp, sizeof(cciss_coalint_struct)))
726 if ((intinfo.delay == 0) && (intinfo.count == 0))
728 // printk("cciss_ioctl: delay and count cannot be 0\n");
731 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
732 /* Update the field, and then ring the doorbell */
733 writel(intinfo.delay,
734 &(host->cfgtable->HostWrite.CoalIntDelay));
735 writel(intinfo.count,
736 &(host->cfgtable->HostWrite.CoalIntCount));
737 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
739 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
740 if (!(readl(host->vaddr + SA5_DOORBELL)
743 /* delay and try again */
746 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
747 if (i >= MAX_IOCTL_CONFIG_WAIT)
751 case CCISS_GETNODENAME:
753 NodeName_type NodeName;
758 for (i = 0; i < 16; i++)
760 readb(&host->cfgtable->ServerName[i]);
761 if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
765 case CCISS_SETNODENAME:
767 NodeName_type NodeName;
773 if (!capable(CAP_SYS_ADMIN))
777 (NodeName, argp, sizeof(NodeName_type)))
780 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
782 /* Update the field, and then ring the doorbell */
783 for (i = 0; i < 16; i++)
785 &host->cfgtable->ServerName[i]);
787 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
789 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
790 if (!(readl(host->vaddr + SA5_DOORBELL)
793 /* delay and try again */
796 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
797 if (i >= MAX_IOCTL_CONFIG_WAIT)
802 case CCISS_GETHEARTBEAT:
804 Heartbeat_type heartbeat;
808 heartbeat = readl(&host->cfgtable->HeartBeat);
810 (argp, &heartbeat, sizeof(Heartbeat_type)))
814 case CCISS_GETBUSTYPES:
816 BusTypes_type BusTypes;
820 BusTypes = readl(&host->cfgtable->BusTypes);
822 (argp, &BusTypes, sizeof(BusTypes_type)))
826 case CCISS_GETFIRMVER:
828 FirmwareVer_type firmware;
832 memcpy(firmware, host->firm_ver, 4);
835 (argp, firmware, sizeof(FirmwareVer_type)))
839 case CCISS_GETDRIVVER:
841 DriverVer_type DriverVer = DRIVER_VERSION;
847 (argp, &DriverVer, sizeof(DriverVer_type)))
852 case CCISS_REVALIDVOLS:
853 if (bdev != bdev->bd_contains || drv != host->drv)
855 return revalidate_allvol(host);
857 case CCISS_GETLUNINFO:{
858 LogvolInfo_struct luninfo;
860 luninfo.LunID = drv->LunID;
861 luninfo.num_opens = drv->usage_count;
862 luninfo.num_parts = 0;
863 if (copy_to_user(argp, &luninfo,
864 sizeof(LogvolInfo_struct)))
868 case CCISS_DEREGDISK:
869 return rebuild_lun_table(host, disk);
872 return rebuild_lun_table(host, NULL);
876 IOCTL_Command_struct iocommand;
877 CommandList_struct *c;
881 DECLARE_COMPLETION_ONSTACK(wait);
886 if (!capable(CAP_SYS_RAWIO))
890 (&iocommand, argp, sizeof(IOCTL_Command_struct)))
892 if ((iocommand.buf_size < 1) &&
893 (iocommand.Request.Type.Direction != XFER_NONE)) {
896 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
897 /* Check kmalloc limits */
898 if (iocommand.buf_size > 128000)
901 if (iocommand.buf_size > 0) {
902 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
906 if (iocommand.Request.Type.Direction == XFER_WRITE) {
907 /* Copy the data into the buffer we created */
909 (buff, iocommand.buf, iocommand.buf_size)) {
914 memset(buff, 0, iocommand.buf_size);
916 if ((c = cmd_alloc(host, 0)) == NULL) {
920 // Fill in the command type
921 c->cmd_type = CMD_IOCTL_PEND;
922 // Fill in Command Header
923 c->Header.ReplyQueue = 0; // unused in simple mode
924 if (iocommand.buf_size > 0) // buffer to fill
926 c->Header.SGList = 1;
927 c->Header.SGTotal = 1;
928 } else // no buffers to fill
930 c->Header.SGList = 0;
931 c->Header.SGTotal = 0;
933 c->Header.LUN = iocommand.LUN_info;
934 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
936 // Fill in Request block
937 c->Request = iocommand.Request;
939 // Fill in the scatter gather information
940 if (iocommand.buf_size > 0) {
941 temp64.val = pci_map_single(host->pdev, buff,
943 PCI_DMA_BIDIRECTIONAL);
944 c->SG[0].Addr.lower = temp64.val32.lower;
945 c->SG[0].Addr.upper = temp64.val32.upper;
946 c->SG[0].Len = iocommand.buf_size;
947 c->SG[0].Ext = 0; // we are not chaining
951 /* Put the request on the tail of the request queue */
952 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
953 addQ(&host->reqQ, c);
956 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
958 wait_for_completion(&wait);
960 /* unlock the buffers from DMA */
961 temp64.val32.lower = c->SG[0].Addr.lower;
962 temp64.val32.upper = c->SG[0].Addr.upper;
963 pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
965 PCI_DMA_BIDIRECTIONAL);
967 /* Copy the error information out */
968 iocommand.error_info = *(c->err_info);
970 (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
972 cmd_free(host, c, 0);
976 if (iocommand.Request.Type.Direction == XFER_READ) {
977 /* Copy the data out of the buffer we created */
979 (iocommand.buf, buff, iocommand.buf_size)) {
981 cmd_free(host, c, 0);
986 cmd_free(host, c, 0);
989 case CCISS_BIG_PASSTHRU:{
990 BIG_IOCTL_Command_struct *ioc;
991 CommandList_struct *c;
992 unsigned char **buff = NULL;
993 int *buff_size = NULL;
999 DECLARE_COMPLETION_ONSTACK(wait);
1002 BYTE __user *data_ptr;
1006 if (!capable(CAP_SYS_RAWIO))
1008 ioc = (BIG_IOCTL_Command_struct *)
1009 kmalloc(sizeof(*ioc), GFP_KERNEL);
1014 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
1018 if ((ioc->buf_size < 1) &&
1019 (ioc->Request.Type.Direction != XFER_NONE)) {
1023 /* Check kmalloc limits using all SGs */
1024 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
1028 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1033 kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1038 buff_size = (int *)kmalloc(MAXSGENTRIES * sizeof(int),
1044 left = ioc->buf_size;
1045 data_ptr = ioc->buf;
1048 ioc->malloc_size) ? ioc->
1050 buff_size[sg_used] = sz;
1051 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1052 if (buff[sg_used] == NULL) {
1056 if (ioc->Request.Type.Direction == XFER_WRITE) {
1058 (buff[sg_used], data_ptr, sz)) {
1063 memset(buff[sg_used], 0, sz);
1069 if ((c = cmd_alloc(host, 0)) == NULL) {
1073 c->cmd_type = CMD_IOCTL_PEND;
1074 c->Header.ReplyQueue = 0;
1076 if (ioc->buf_size > 0) {
1077 c->Header.SGList = sg_used;
1078 c->Header.SGTotal = sg_used;
1080 c->Header.SGList = 0;
1081 c->Header.SGTotal = 0;
1083 c->Header.LUN = ioc->LUN_info;
1084 c->Header.Tag.lower = c->busaddr;
1086 c->Request = ioc->Request;
1087 if (ioc->buf_size > 0) {
1089 for (i = 0; i < sg_used; i++) {
1091 pci_map_single(host->pdev, buff[i],
1093 PCI_DMA_BIDIRECTIONAL);
1094 c->SG[i].Addr.lower =
1096 c->SG[i].Addr.upper =
1098 c->SG[i].Len = buff_size[i];
1099 c->SG[i].Ext = 0; /* we are not chaining */
1103 /* Put the request on the tail of the request queue */
1104 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1105 addQ(&host->reqQ, c);
1108 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1109 wait_for_completion(&wait);
1110 /* unlock the buffers from DMA */
1111 for (i = 0; i < sg_used; i++) {
1112 temp64.val32.lower = c->SG[i].Addr.lower;
1113 temp64.val32.upper = c->SG[i].Addr.upper;
1114 pci_unmap_single(host->pdev,
1115 (dma_addr_t) temp64.val, buff_size[i],
1116 PCI_DMA_BIDIRECTIONAL);
1118 /* Copy the error information out */
1119 ioc->error_info = *(c->err_info);
1120 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1121 cmd_free(host, c, 0);
1125 if (ioc->Request.Type.Direction == XFER_READ) {
1126 /* Copy the data out of the buffer we created */
1127 BYTE __user *ptr = ioc->buf;
1128 for (i = 0; i < sg_used; i++) {
1130 (ptr, buff[i], buff_size[i])) {
1131 cmd_free(host, c, 0);
1135 ptr += buff_size[i];
1138 cmd_free(host, c, 0);
1142 for (i = 0; i < sg_used; i++)
1156 * revalidate_allvol is for online array config utilities. After a
1157 * utility reconfigures the drives in the array, it can use this function
1158 * (through an ioctl) to make the driver zap any previous disk structs for
1159 * that controller and get new ones.
1161 * Right now I'm using the getgeometry() function to do this, but this
1162 * function should probably be finer grained and allow you to revalidate one
1163 * particular logical volume (instead of all of them on a particular
1166 static int revalidate_allvol(ctlr_info_t *host)
1168 int ctlr = host->ctlr, i;
1169 unsigned long flags;
1171 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1172 if (host->usage_count > 1) {
1173 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1174 printk(KERN_WARNING "cciss: Device busy for volume"
1175 " revalidation (usage=%d)\n", host->usage_count);
1178 host->usage_count++;
1179 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1181 for (i = 0; i < NWD; i++) {
1182 struct gendisk *disk = host->gendisk[i];
1184 request_queue_t *q = disk->queue;
1186 if (disk->flags & GENHD_FL_UP)
1189 blk_cleanup_queue(q);
1194 * Set the partition and block size structures for all volumes
1195 * on this controller to zero. We will reread all of this data
1197 memset(host->drv, 0, sizeof(drive_info_struct)
1200 * Tell the array controller not to give us any interrupts while
1201 * we check the new geometry. Then turn interrupts back on when
1204 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1205 cciss_getgeometry(ctlr);
1206 host->access.set_intr_mask(host, CCISS_INTR_ON);
1208 /* Loop through each real device */
1209 for (i = 0; i < NWD; i++) {
1210 struct gendisk *disk = host->gendisk[i];
1211 drive_info_struct *drv = &(host->drv[i]);
1212 /* we must register the controller even if no disks exist */
1213 /* this is for the online array utilities */
1214 if (!drv->heads && i)
1216 blk_queue_hardsect_size(drv->queue, drv->block_size);
1217 set_capacity(disk, drv->nr_blocks);
1220 host->usage_count--;
1224 static inline void complete_buffers(struct bio *bio, int status)
1227 struct bio *xbh = bio->bi_next;
1228 int nr_sectors = bio_sectors(bio);
1230 bio->bi_next = NULL;
1231 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
1236 static void cciss_check_queues(ctlr_info_t *h)
1238 int start_queue = h->next_to_run;
1241 /* check to see if we have maxed out the number of commands that can
1242 * be placed on the queue. If so then exit. We do this check here
1243 * in case the interrupt we serviced was from an ioctl and did not
1244 * free any new commands.
1246 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
1249 /* We have room on the queue for more commands. Now we need to queue
1250 * them up. We will also keep track of the next queue to run so
1251 * that every queue gets a chance to be started first.
1253 for (i = 0; i < h->highest_lun + 1; i++) {
1254 int curr_queue = (start_queue + i) % (h->highest_lun + 1);
1255 /* make sure the disk has been added and the drive is real
1256 * because this can be called from the middle of init_one.
1258 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
1260 blk_start_queue(h->gendisk[curr_queue]->queue);
1262 /* check to see if we have maxed out the number of commands
1263 * that can be placed on the queue.
1265 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS) {
1266 if (curr_queue == start_queue) {
1268 (start_queue + 1) % (h->highest_lun + 1);
1271 h->next_to_run = curr_queue;
1275 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
1280 static void cciss_softirq_done(struct request *rq)
1282 CommandList_struct *cmd = rq->completion_data;
1283 ctlr_info_t *h = hba[cmd->ctlr];
1284 unsigned long flags;
1288 if (cmd->Request.Type.Direction == XFER_READ)
1289 ddir = PCI_DMA_FROMDEVICE;
1291 ddir = PCI_DMA_TODEVICE;
1293 /* command did not need to be retried */
1294 /* unmap the DMA mapping for all the scatter gather elements */
1295 for (i = 0; i < cmd->Header.SGList; i++) {
1296 temp64.val32.lower = cmd->SG[i].Addr.lower;
1297 temp64.val32.upper = cmd->SG[i].Addr.upper;
1298 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1301 complete_buffers(rq->bio, rq->errors);
1303 if (blk_fs_request(rq)) {
1304 const int rw = rq_data_dir(rq);
1306 disk_stat_add(rq->rq_disk, sectors[rw], rq->nr_sectors);
1310 printk("Done with %p\n", rq);
1311 #endif /* CCISS_DEBUG */
1313 add_disk_randomness(rq->rq_disk);
1314 spin_lock_irqsave(&h->lock, flags);
1315 end_that_request_last(rq, rq->errors);
1316 cmd_free(h, cmd, 1);
1317 cciss_check_queues(h);
1318 spin_unlock_irqrestore(&h->lock, flags);
1321 /* This function will check the usage_count of the drive to be updated/added.
1322 * If the usage_count is zero then the drive information will be updated and
1323 * the disk will be re-registered with the kernel. If not then it will be
1324 * left alone for the next reboot. The exception to this is disk 0 which
1325 * will always be left registered with the kernel since it is also the
1326 * controller node. Any changes to disk 0 will show up on the next
1329 static void cciss_update_drive_info(int ctlr, int drv_index)
1331 ctlr_info_t *h = hba[ctlr];
1332 struct gendisk *disk;
1333 InquiryData_struct *inq_buff = NULL;
1334 unsigned int block_size;
1335 sector_t total_size;
1336 unsigned long flags = 0;
1339 /* if the disk already exists then deregister it before proceeding */
1340 if (h->drv[drv_index].raid_level != -1) {
1341 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1342 h->drv[drv_index].busy_configuring = 1;
1343 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1344 ret = deregister_disk(h->gendisk[drv_index],
1345 &h->drv[drv_index], 0);
1346 h->drv[drv_index].busy_configuring = 0;
1349 /* If the disk is in use return */
1353 /* Get information about the disk and modify the driver structure */
1354 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1355 if (inq_buff == NULL)
1358 cciss_read_capacity(ctlr, drv_index, 1,
1359 &total_size, &block_size);
1361 /* total size = last LBA + 1 */
1362 /* FFFFFFFF + 1 = 0, cannot have a logical volume of size 0 */
1363 /* so we assume this volume this must be >2TB in size */
1364 if (total_size == (__u32) 0) {
1365 cciss_read_capacity_16(ctlr, drv_index, 1,
1366 &total_size, &block_size);
1367 h->cciss_read = CCISS_READ_16;
1368 h->cciss_write = CCISS_WRITE_16;
1370 h->cciss_read = CCISS_READ_10;
1371 h->cciss_write = CCISS_WRITE_10;
1373 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1374 inq_buff, &h->drv[drv_index]);
1377 disk = h->gendisk[drv_index];
1378 set_capacity(disk, h->drv[drv_index].nr_blocks);
1380 /* if it's the controller it's already added */
1382 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1384 /* Set up queue information */
1385 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1386 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1388 /* This is a hardware imposed limit. */
1389 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1391 /* This is a limit in the driver and could be eliminated. */
1392 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1394 blk_queue_max_sectors(disk->queue, 512);
1396 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1398 disk->queue->queuedata = hba[ctlr];
1400 blk_queue_hardsect_size(disk->queue,
1401 hba[ctlr]->drv[drv_index].block_size);
1403 h->drv[drv_index].queue = disk->queue;
1411 printk(KERN_ERR "cciss: out of memory\n");
1415 /* This function will find the first index of the controllers drive array
1416 * that has a -1 for the raid_level and will return that index. This is
1417 * where new drives will be added. If the index to be returned is greater
1418 * than the highest_lun index for the controller then highest_lun is set
1419 * to this new index. If there are no available indexes then -1 is returned.
1421 static int cciss_find_free_drive_index(int ctlr)
1425 for (i = 0; i < CISS_MAX_LUN; i++) {
1426 if (hba[ctlr]->drv[i].raid_level == -1) {
1427 if (i > hba[ctlr]->highest_lun)
1428 hba[ctlr]->highest_lun = i;
1435 /* This function will add and remove logical drives from the Logical
1436 * drive array of the controller and maintain persistency of ordering
1437 * so that mount points are preserved until the next reboot. This allows
1438 * for the removal of logical drives in the middle of the drive array
1439 * without a re-ordering of those drives.
1441 * h = The controller to perform the operations on
1442 * del_disk = The disk to remove if specified. If the value given
1443 * is NULL then no disk is removed.
1445 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1449 ReportLunData_struct *ld_buff = NULL;
1450 drive_info_struct *drv = NULL;
1457 unsigned long flags;
1459 /* Set busy_configuring flag for this operation */
1460 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1461 if (h->num_luns >= CISS_MAX_LUN) {
1462 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1466 if (h->busy_configuring) {
1467 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1470 h->busy_configuring = 1;
1472 /* if del_disk is NULL then we are being called to add a new disk
1473 * and update the logical drive table. If it is not NULL then
1474 * we will check if the disk is in use or not.
1476 if (del_disk != NULL) {
1477 drv = get_drv(del_disk);
1478 drv->busy_configuring = 1;
1479 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1480 return_code = deregister_disk(del_disk, drv, 1);
1481 drv->busy_configuring = 0;
1482 h->busy_configuring = 0;
1485 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1486 if (!capable(CAP_SYS_RAWIO))
1489 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1490 if (ld_buff == NULL)
1493 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1494 sizeof(ReportLunData_struct), 0,
1497 if (return_code == IO_OK) {
1499 (0xff & (unsigned int)(ld_buff->LUNListLength[0]))
1502 (0xff & (unsigned int)(ld_buff->LUNListLength[1]))
1505 (0xff & (unsigned int)(ld_buff->LUNListLength[2]))
1508 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1509 } else { /* reading number of logical volumes failed */
1510 printk(KERN_WARNING "cciss: report logical volume"
1511 " command failed\n");
1516 num_luns = listlength / 8; /* 8 bytes per entry */
1517 if (num_luns > CISS_MAX_LUN) {
1518 num_luns = CISS_MAX_LUN;
1519 printk(KERN_WARNING "cciss: more luns configured"
1520 " on controller than can be handled by"
1524 /* Compare controller drive array to drivers drive array.
1525 * Check for updates in the drive information and any new drives
1526 * on the controller.
1528 for (i = 0; i < num_luns; i++) {
1534 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1536 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1538 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1539 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
1541 /* Find if the LUN is already in the drive array
1542 * of the controller. If so then update its info
1543 * if not is use. If it does not exist then find
1544 * the first free index and add it.
1546 for (j = 0; j <= h->highest_lun; j++) {
1547 if (h->drv[j].LunID == lunid) {
1553 /* check if the drive was found already in the array */
1555 drv_index = cciss_find_free_drive_index(ctlr);
1556 if (drv_index == -1)
1560 h->drv[drv_index].LunID = lunid;
1561 cciss_update_drive_info(ctlr, drv_index);
1567 h->busy_configuring = 0;
1568 /* We return -1 here to tell the ACU that we have registered/updated
1569 * all of the drives that we can and to keep it from calling us
1574 printk(KERN_ERR "cciss: out of memory\n");
1578 /* This function will deregister the disk and it's queue from the
1579 * kernel. It must be called with the controller lock held and the
1580 * drv structures busy_configuring flag set. It's parameters are:
1582 * disk = This is the disk to be deregistered
1583 * drv = This is the drive_info_struct associated with the disk to be
1584 * deregistered. It contains information about the disk used
1586 * clear_all = This flag determines whether or not the disk information
1587 * is going to be completely cleared out and the highest_lun
1588 * reset. Sometimes we want to clear out information about
1589 * the disk in preparation for re-adding it. In this case
1590 * the highest_lun should be left unchanged and the LunID
1591 * should not be cleared.
1593 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1596 ctlr_info_t *h = get_host(disk);
1598 if (!capable(CAP_SYS_RAWIO))
1601 /* make sure logical volume is NOT is use */
1602 if (clear_all || (h->gendisk[0] == disk)) {
1603 if (drv->usage_count > 1)
1605 } else if (drv->usage_count > 0)
1608 /* invalidate the devices and deregister the disk. If it is disk
1609 * zero do not deregister it but just zero out it's values. This
1610 * allows us to delete disk zero but keep the controller registered.
1612 if (h->gendisk[0] != disk) {
1614 request_queue_t *q = disk->queue;
1615 if (disk->flags & GENHD_FL_UP)
1618 blk_cleanup_queue(q);
1625 /* zero out the disk size info */
1627 drv->block_size = 0;
1631 drv->raid_level = -1; /* This can be used as a flag variable to
1632 * indicate that this element of the drive
1637 /* check to see if it was the last disk */
1638 if (drv == h->drv + h->highest_lun) {
1639 /* if so, find the new hightest lun */
1640 int i, newhighest = -1;
1641 for (i = 0; i < h->highest_lun; i++) {
1642 /* if the disk has size > 0, it is available */
1643 if (h->drv[i].heads)
1646 h->highest_lun = newhighest;
1654 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
1655 1: address logical volume log_unit,
1656 2: periph device address is scsi3addr */
1657 unsigned int log_unit, __u8 page_code,
1658 unsigned char *scsi3addr, int cmd_type)
1660 ctlr_info_t *h = hba[ctlr];
1661 u64bit buff_dma_handle;
1664 c->cmd_type = CMD_IOCTL_PEND;
1665 c->Header.ReplyQueue = 0;
1667 c->Header.SGList = 1;
1668 c->Header.SGTotal = 1;
1670 c->Header.SGList = 0;
1671 c->Header.SGTotal = 0;
1673 c->Header.Tag.lower = c->busaddr;
1675 c->Request.Type.Type = cmd_type;
1676 if (cmd_type == TYPE_CMD) {
1679 /* If the logical unit number is 0 then, this is going
1680 to controller so It's a physical command
1681 mode = 0 target = 0. So we have nothing to write.
1682 otherwise, if use_unit_num == 1,
1683 mode = 1(volume set addressing) target = LUNID
1684 otherwise, if use_unit_num == 2,
1685 mode = 0(periph dev addr) target = scsi3addr */
1686 if (use_unit_num == 1) {
1687 c->Header.LUN.LogDev.VolId =
1688 h->drv[log_unit].LunID;
1689 c->Header.LUN.LogDev.Mode = 1;
1690 } else if (use_unit_num == 2) {
1691 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1693 c->Header.LUN.LogDev.Mode = 0;
1695 /* are we trying to read a vital product page */
1696 if (page_code != 0) {
1697 c->Request.CDB[1] = 0x01;
1698 c->Request.CDB[2] = page_code;
1700 c->Request.CDBLen = 6;
1701 c->Request.Type.Attribute = ATTR_SIMPLE;
1702 c->Request.Type.Direction = XFER_READ;
1703 c->Request.Timeout = 0;
1704 c->Request.CDB[0] = CISS_INQUIRY;
1705 c->Request.CDB[4] = size & 0xFF;
1707 case CISS_REPORT_LOG:
1708 case CISS_REPORT_PHYS:
1709 /* Talking to controller so It's a physical command
1710 mode = 00 target = 0. Nothing to write.
1712 c->Request.CDBLen = 12;
1713 c->Request.Type.Attribute = ATTR_SIMPLE;
1714 c->Request.Type.Direction = XFER_READ;
1715 c->Request.Timeout = 0;
1716 c->Request.CDB[0] = cmd;
1717 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1718 c->Request.CDB[7] = (size >> 16) & 0xFF;
1719 c->Request.CDB[8] = (size >> 8) & 0xFF;
1720 c->Request.CDB[9] = size & 0xFF;
1723 case CCISS_READ_CAPACITY:
1724 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1725 c->Header.LUN.LogDev.Mode = 1;
1726 c->Request.CDBLen = 10;
1727 c->Request.Type.Attribute = ATTR_SIMPLE;
1728 c->Request.Type.Direction = XFER_READ;
1729 c->Request.Timeout = 0;
1730 c->Request.CDB[0] = cmd;
1732 case CCISS_READ_CAPACITY_16:
1733 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1734 c->Header.LUN.LogDev.Mode = 1;
1735 c->Request.CDBLen = 16;
1736 c->Request.Type.Attribute = ATTR_SIMPLE;
1737 c->Request.Type.Direction = XFER_READ;
1738 c->Request.Timeout = 0;
1739 c->Request.CDB[0] = cmd;
1740 c->Request.CDB[1] = 0x10;
1741 c->Request.CDB[10] = (size >> 24) & 0xFF;
1742 c->Request.CDB[11] = (size >> 16) & 0xFF;
1743 c->Request.CDB[12] = (size >> 8) & 0xFF;
1744 c->Request.CDB[13] = size & 0xFF;
1745 c->Request.Timeout = 0;
1746 c->Request.CDB[0] = cmd;
1748 case CCISS_CACHE_FLUSH:
1749 c->Request.CDBLen = 12;
1750 c->Request.Type.Attribute = ATTR_SIMPLE;
1751 c->Request.Type.Direction = XFER_WRITE;
1752 c->Request.Timeout = 0;
1753 c->Request.CDB[0] = BMIC_WRITE;
1754 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1758 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1761 } else if (cmd_type == TYPE_MSG) {
1763 case 0: /* ABORT message */
1764 c->Request.CDBLen = 12;
1765 c->Request.Type.Attribute = ATTR_SIMPLE;
1766 c->Request.Type.Direction = XFER_WRITE;
1767 c->Request.Timeout = 0;
1768 c->Request.CDB[0] = cmd; /* abort */
1769 c->Request.CDB[1] = 0; /* abort a command */
1770 /* buff contains the tag of the command to abort */
1771 memcpy(&c->Request.CDB[4], buff, 8);
1773 case 1: /* RESET message */
1774 c->Request.CDBLen = 12;
1775 c->Request.Type.Attribute = ATTR_SIMPLE;
1776 c->Request.Type.Direction = XFER_WRITE;
1777 c->Request.Timeout = 0;
1778 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1779 c->Request.CDB[0] = cmd; /* reset */
1780 c->Request.CDB[1] = 0x04; /* reset a LUN */
1782 case 3: /* No-Op message */
1783 c->Request.CDBLen = 1;
1784 c->Request.Type.Attribute = ATTR_SIMPLE;
1785 c->Request.Type.Direction = XFER_WRITE;
1786 c->Request.Timeout = 0;
1787 c->Request.CDB[0] = cmd;
1791 "cciss%d: unknown message type %d\n", ctlr, cmd);
1796 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1799 /* Fill in the scatter gather information */
1801 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1803 PCI_DMA_BIDIRECTIONAL);
1804 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1805 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1806 c->SG[0].Len = size;
1807 c->SG[0].Ext = 0; /* we are not chaining */
1812 static int sendcmd_withirq(__u8 cmd,
1816 unsigned int use_unit_num,
1817 unsigned int log_unit, __u8 page_code, int cmd_type)
1819 ctlr_info_t *h = hba[ctlr];
1820 CommandList_struct *c;
1821 u64bit buff_dma_handle;
1822 unsigned long flags;
1824 DECLARE_COMPLETION_ONSTACK(wait);
1826 if ((c = cmd_alloc(h, 0)) == NULL)
1828 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1829 log_unit, page_code, NULL, cmd_type);
1830 if (return_status != IO_OK) {
1832 return return_status;
1837 /* Put the request on the tail of the queue and send it */
1838 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1842 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1844 wait_for_completion(&wait);
1846 if (c->err_info->CommandStatus != 0) { /* an error has occurred */
1847 switch (c->err_info->CommandStatus) {
1848 case CMD_TARGET_STATUS:
1849 printk(KERN_WARNING "cciss: cmd %p has "
1850 " completed with errors\n", c);
1851 if (c->err_info->ScsiStatus) {
1852 printk(KERN_WARNING "cciss: cmd %p "
1853 "has SCSI Status = %x\n",
1854 c, c->err_info->ScsiStatus);
1858 case CMD_DATA_UNDERRUN:
1859 case CMD_DATA_OVERRUN:
1860 /* expected for inquire and report lun commands */
1863 printk(KERN_WARNING "cciss: Cmd %p is "
1864 "reported invalid\n", c);
1865 return_status = IO_ERROR;
1867 case CMD_PROTOCOL_ERR:
1868 printk(KERN_WARNING "cciss: cmd %p has "
1869 "protocol error \n", c);
1870 return_status = IO_ERROR;
1872 case CMD_HARDWARE_ERR:
1873 printk(KERN_WARNING "cciss: cmd %p had "
1874 " hardware error\n", c);
1875 return_status = IO_ERROR;
1877 case CMD_CONNECTION_LOST:
1878 printk(KERN_WARNING "cciss: cmd %p had "
1879 "connection lost\n", c);
1880 return_status = IO_ERROR;
1883 printk(KERN_WARNING "cciss: cmd %p was "
1885 return_status = IO_ERROR;
1887 case CMD_ABORT_FAILED:
1888 printk(KERN_WARNING "cciss: cmd %p reports "
1889 "abort failed\n", c);
1890 return_status = IO_ERROR;
1892 case CMD_UNSOLICITED_ABORT:
1894 "cciss%d: unsolicited abort %p\n", ctlr, c);
1895 if (c->retry_count < MAX_CMD_RETRIES) {
1897 "cciss%d: retrying %p\n", ctlr, c);
1899 /* erase the old error information */
1900 memset(c->err_info, 0,
1901 sizeof(ErrorInfo_struct));
1902 return_status = IO_OK;
1903 INIT_COMPLETION(wait);
1906 return_status = IO_ERROR;
1909 printk(KERN_WARNING "cciss: cmd %p returned "
1910 "unknown status %x\n", c,
1911 c->err_info->CommandStatus);
1912 return_status = IO_ERROR;
1915 /* unlock the buffers from DMA */
1916 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1917 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1918 pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
1919 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1921 return return_status;
1924 static void cciss_geometry_inquiry(int ctlr, int logvol,
1925 int withirq, sector_t total_size,
1926 unsigned int block_size,
1927 InquiryData_struct *inq_buff,
1928 drive_info_struct *drv)
1933 memset(inq_buff, 0, sizeof(InquiryData_struct));
1935 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1936 inq_buff, sizeof(*inq_buff), 1,
1937 logvol, 0xC1, TYPE_CMD);
1939 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1940 sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
1942 if (return_code == IO_OK) {
1943 if (inq_buff->data_byte[8] == 0xFF) {
1945 "cciss: reading geometry failed, volume "
1946 "does not support reading geometry\n");
1948 drv->sectors = 32; // Sectors per track
1950 drv->heads = inq_buff->data_byte[6];
1951 drv->sectors = inq_buff->data_byte[7];
1952 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1953 drv->cylinders += inq_buff->data_byte[5];
1954 drv->raid_level = inq_buff->data_byte[8];
1956 drv->block_size = block_size;
1957 drv->nr_blocks = total_size;
1958 t = drv->heads * drv->sectors;
1960 unsigned rem = sector_div(total_size, t);
1963 drv->cylinders = total_size;
1965 } else { /* Get geometry failed */
1966 printk(KERN_WARNING "cciss: reading geometry failed\n");
1968 printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n",
1969 drv->heads, drv->sectors, drv->cylinders);
1973 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
1974 unsigned int *block_size)
1976 ReadCapdata_struct *buf;
1978 buf = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
1980 printk(KERN_WARNING "cciss: out of memory\n");
1983 memset(buf, 0, sizeof(ReadCapdata_struct));
1985 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1986 ctlr, buf, sizeof(ReadCapdata_struct),
1987 1, logvol, 0, TYPE_CMD);
1989 return_code = sendcmd(CCISS_READ_CAPACITY,
1990 ctlr, buf, sizeof(ReadCapdata_struct),
1991 1, logvol, 0, NULL, TYPE_CMD);
1992 if (return_code == IO_OK) {
1993 *total_size = be32_to_cpu(*(__u32 *) buf->total_size)+1;
1994 *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
1995 } else { /* read capacity command failed */
1996 printk(KERN_WARNING "cciss: read capacity failed\n");
1998 *block_size = BLOCK_SIZE;
2000 if (*total_size != (__u32) 0)
2001 printk(KERN_INFO " blocks= %llu block_size= %d\n",
2002 (unsigned long long)*total_size, *block_size);
2008 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, unsigned int *block_size)
2010 ReadCapdata_struct_16 *buf;
2012 buf = kmalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
2014 printk(KERN_WARNING "cciss: out of memory\n");
2017 memset(buf, 0, sizeof(ReadCapdata_struct_16));
2019 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2020 ctlr, buf, sizeof(ReadCapdata_struct_16),
2021 1, logvol, 0, TYPE_CMD);
2024 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2025 ctlr, buf, sizeof(ReadCapdata_struct_16),
2026 1, logvol, 0, NULL, TYPE_CMD);
2028 if (return_code == IO_OK) {
2029 *total_size = be64_to_cpu(*(__u64 *) buf->total_size)+1;
2030 *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
2031 } else { /* read capacity command failed */
2032 printk(KERN_WARNING "cciss: read capacity failed\n");
2034 *block_size = BLOCK_SIZE;
2036 printk(KERN_INFO " blocks= %llu block_size= %d\n",
2037 (unsigned long long)*total_size, *block_size);
2042 static int cciss_revalidate(struct gendisk *disk)
2044 ctlr_info_t *h = get_host(disk);
2045 drive_info_struct *drv = get_drv(disk);
2048 unsigned int block_size;
2049 sector_t total_size;
2050 InquiryData_struct *inq_buff = NULL;
2052 for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2053 if (h->drv[logvol].LunID == drv->LunID) {
2062 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2063 if (inq_buff == NULL) {
2064 printk(KERN_WARNING "cciss: out of memory\n");
2067 if (h->cciss_read == CCISS_READ_10) {
2068 cciss_read_capacity(h->ctlr, logvol, 1,
2069 &total_size, &block_size);
2071 cciss_read_capacity_16(h->ctlr, logvol, 1,
2072 &total_size, &block_size);
2074 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2077 blk_queue_hardsect_size(drv->queue, drv->block_size);
2078 set_capacity(disk, drv->nr_blocks);
2085 * Wait polling for a command to complete.
2086 * The memory mapped FIFO is polled for the completion.
2087 * Used only at init time, interrupts from the HBA are disabled.
2089 static unsigned long pollcomplete(int ctlr)
2094 /* Wait (up to 20 seconds) for a command to complete */
2096 for (i = 20 * HZ; i > 0; i--) {
2097 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2098 if (done == FIFO_EMPTY)
2099 schedule_timeout_uninterruptible(1);
2103 /* Invalid address to tell caller we ran out of time */
2107 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2109 /* We get in here if sendcmd() is polling for completions
2110 and gets some command back that it wasn't expecting --
2111 something other than that which it just sent down.
2112 Ordinarily, that shouldn't happen, but it can happen when
2113 the scsi tape stuff gets into error handling mode, and
2114 starts using sendcmd() to try to abort commands and
2115 reset tape drives. In that case, sendcmd may pick up
2116 completions of commands that were sent to logical drives
2117 through the block i/o system, or cciss ioctls completing, etc.
2118 In that case, we need to save those completions for later
2119 processing by the interrupt handler.
2122 #ifdef CONFIG_CISS_SCSI_TAPE
2123 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2125 /* If it's not the scsi tape stuff doing error handling, (abort */
2126 /* or reset) then we don't expect anything weird. */
2127 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2129 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2130 "Invalid command list address returned! (%lx)\n",
2132 /* not much we can do. */
2133 #ifdef CONFIG_CISS_SCSI_TAPE
2137 /* We've sent down an abort or reset, but something else
2139 if (srl->ncompletions >= (NR_CMDS + 2)) {
2140 /* Uh oh. No room to save it for later... */
2141 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2142 "reject list overflow, command lost!\n", ctlr);
2145 /* Save it for later */
2146 srl->complete[srl->ncompletions] = complete;
2147 srl->ncompletions++;
2153 * Send a command to the controller, and wait for it to complete.
2154 * Only used at init time.
2156 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
2157 1: address logical volume log_unit,
2158 2: periph device address is scsi3addr */
2159 unsigned int log_unit,
2160 __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2162 CommandList_struct *c;
2164 unsigned long complete;
2165 ctlr_info_t *info_p = hba[ctlr];
2166 u64bit buff_dma_handle;
2167 int status, done = 0;
2169 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2170 printk(KERN_WARNING "cciss: unable to get memory");
2173 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2174 log_unit, page_code, scsi3addr, cmd_type);
2175 if (status != IO_OK) {
2176 cmd_free(info_p, c, 1);
2184 printk(KERN_DEBUG "cciss: turning intr off\n");
2185 #endif /* CCISS_DEBUG */
2186 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2188 /* Make sure there is room in the command FIFO */
2189 /* Actually it should be completely empty at this time */
2190 /* unless we are in here doing error handling for the scsi */
2191 /* tape side of the driver. */
2192 for (i = 200000; i > 0; i--) {
2193 /* if fifo isn't full go */
2194 if (!(info_p->access.fifo_full(info_p))) {
2199 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2200 " waiting!\n", ctlr);
2205 info_p->access.submit_command(info_p, c);
2208 complete = pollcomplete(ctlr);
2211 printk(KERN_DEBUG "cciss: command completed\n");
2212 #endif /* CCISS_DEBUG */
2214 if (complete == 1) {
2216 "cciss cciss%d: SendCmd Timeout out, "
2217 "No command list address returned!\n", ctlr);
2223 /* This will need to change for direct lookup completions */
2224 if ((complete & CISS_ERROR_BIT)
2225 && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2226 /* if data overrun or underun on Report command
2229 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2230 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2231 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2232 ((c->err_info->CommandStatus ==
2233 CMD_DATA_OVERRUN) ||
2234 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2236 complete = c->busaddr;
2238 if (c->err_info->CommandStatus ==
2239 CMD_UNSOLICITED_ABORT) {
2240 printk(KERN_WARNING "cciss%d: "
2241 "unsolicited abort %p\n",
2243 if (c->retry_count < MAX_CMD_RETRIES) {
2245 "cciss%d: retrying %p\n",
2248 /* erase the old error */
2250 memset(c->err_info, 0,
2252 (ErrorInfo_struct));
2256 "cciss%d: retried %p too "
2257 "many times\n", ctlr, c);
2261 } else if (c->err_info->CommandStatus ==
2264 "cciss%d: command could not be aborted.\n",
2269 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2270 " Error %x \n", ctlr,
2271 c->err_info->CommandStatus);
2272 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2274 " size %x\n num %x value %x\n",
2276 c->err_info->MoreErrInfo.Invalid_Cmd.
2278 c->err_info->MoreErrInfo.Invalid_Cmd.
2280 c->err_info->MoreErrInfo.Invalid_Cmd.
2286 /* This will need changing for direct lookup completions */
2287 if (complete != c->busaddr) {
2288 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2289 BUG(); /* we are pretty much hosed if we get here. */
2297 /* unlock the data buffer from DMA */
2298 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2299 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2300 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2301 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2302 #ifdef CONFIG_CISS_SCSI_TAPE
2303 /* if we saved some commands for later, process them now. */
2304 if (info_p->scsi_rejects.ncompletions > 0)
2305 do_cciss_intr(0, info_p);
2307 cmd_free(info_p, c, 1);
2312 * Map (physical) PCI mem into (virtual) kernel space
2314 static void __iomem *remap_pci_mem(ulong base, ulong size)
2316 ulong page_base = ((ulong) base) & PAGE_MASK;
2317 ulong page_offs = ((ulong) base) - page_base;
2318 void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2320 return page_remapped ? (page_remapped + page_offs) : NULL;
2324 * Takes jobs of the Q and sends them to the hardware, then puts it on
2325 * the Q to wait for completion.
2327 static void start_io(ctlr_info_t *h)
2329 CommandList_struct *c;
2331 while ((c = h->reqQ) != NULL) {
2332 /* can't do anything if fifo is full */
2333 if ((h->access.fifo_full(h))) {
2334 printk(KERN_WARNING "cciss: fifo full\n");
2338 /* Get the first entry from the Request Q */
2339 removeQ(&(h->reqQ), c);
2342 /* Tell the controller execute command */
2343 h->access.submit_command(h, c);
2345 /* Put job onto the completed Q */
2346 addQ(&(h->cmpQ), c);
2350 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2351 /* Zeros out the error record and then resends the command back */
2352 /* to the controller */
2353 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2355 /* erase the old error information */
2356 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2358 /* add it to software queue and then send it to the controller */
2359 addQ(&(h->reqQ), c);
2361 if (h->Qdepth > h->maxQsinceinit)
2362 h->maxQsinceinit = h->Qdepth;
2367 /* checks the status of the job and calls complete buffers to mark all
2368 * buffers for the completed job. Note that this function does not need
2369 * to hold the hba/queue lock.
2371 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2380 if (cmd->err_info->CommandStatus != 0) { /* an error has occurred */
2381 switch (cmd->err_info->CommandStatus) {
2382 unsigned char sense_key;
2383 case CMD_TARGET_STATUS:
2386 if (cmd->err_info->ScsiStatus == 0x02) {
2387 printk(KERN_WARNING "cciss: cmd %p "
2388 "has CHECK CONDITION "
2389 " byte 2 = 0x%x\n", cmd,
2390 cmd->err_info->SenseInfo[2]
2392 /* check the sense key */
2393 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2394 /* no status or recovered error */
2395 if ((sense_key == 0x0) || (sense_key == 0x1)) {
2399 printk(KERN_WARNING "cciss: cmd %p "
2400 "has SCSI Status 0x%x\n",
2401 cmd, cmd->err_info->ScsiStatus);
2404 case CMD_DATA_UNDERRUN:
2405 printk(KERN_WARNING "cciss: cmd %p has"
2406 " completed with data underrun "
2409 case CMD_DATA_OVERRUN:
2410 printk(KERN_WARNING "cciss: cmd %p has"
2411 " completed with data overrun "
2415 printk(KERN_WARNING "cciss: cmd %p is "
2416 "reported invalid\n", cmd);
2419 case CMD_PROTOCOL_ERR:
2420 printk(KERN_WARNING "cciss: cmd %p has "
2421 "protocol error \n", cmd);
2424 case CMD_HARDWARE_ERR:
2425 printk(KERN_WARNING "cciss: cmd %p had "
2426 " hardware error\n", cmd);
2429 case CMD_CONNECTION_LOST:
2430 printk(KERN_WARNING "cciss: cmd %p had "
2431 "connection lost\n", cmd);
2435 printk(KERN_WARNING "cciss: cmd %p was "
2439 case CMD_ABORT_FAILED:
2440 printk(KERN_WARNING "cciss: cmd %p reports "
2441 "abort failed\n", cmd);
2444 case CMD_UNSOLICITED_ABORT:
2445 printk(KERN_WARNING "cciss%d: unsolicited "
2446 "abort %p\n", h->ctlr, cmd);
2447 if (cmd->retry_count < MAX_CMD_RETRIES) {
2450 "cciss%d: retrying %p\n", h->ctlr, cmd);
2454 "cciss%d: %p retried too "
2455 "many times\n", h->ctlr, cmd);
2459 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2463 printk(KERN_WARNING "cciss: cmd %p returned "
2464 "unknown status %x\n", cmd,
2465 cmd->err_info->CommandStatus);
2469 /* We need to return this command */
2471 resend_cciss_cmd(h, cmd);
2475 cmd->rq->completion_data = cmd;
2476 cmd->rq->errors = status;
2477 blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
2478 blk_complete_request(cmd->rq);
2482 * Get a request and submit it to the controller.
2484 static void do_cciss_request(request_queue_t *q)
2486 ctlr_info_t *h = q->queuedata;
2487 CommandList_struct *c;
2490 struct request *creq;
2492 struct scatterlist tmp_sg[MAXSGENTRIES];
2493 drive_info_struct *drv;
2496 /* We call start_io here in case there is a command waiting on the
2497 * queue that has not been sent.
2499 if (blk_queue_plugged(q))
2503 creq = elv_next_request(q);
2507 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2509 if ((c = cmd_alloc(h, 1)) == NULL)
2512 blkdev_dequeue_request(creq);
2514 spin_unlock_irq(q->queue_lock);
2516 c->cmd_type = CMD_RWREQ;
2519 /* fill in the request */
2520 drv = creq->rq_disk->private_data;
2521 c->Header.ReplyQueue = 0; // unused in simple mode
2522 /* got command from pool, so use the command block index instead */
2523 /* for direct lookups. */
2524 /* The first 2 bits are reserved for controller error reporting. */
2525 c->Header.Tag.lower = (c->cmdindex << 3);
2526 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2527 c->Header.LUN.LogDev.VolId = drv->LunID;
2528 c->Header.LUN.LogDev.Mode = 1;
2529 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2530 c->Request.Type.Type = TYPE_CMD; // It is a command.
2531 c->Request.Type.Attribute = ATTR_SIMPLE;
2532 c->Request.Type.Direction =
2533 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2534 c->Request.Timeout = 0; // Don't time out
2536 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2537 start_blk = creq->sector;
2539 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2540 (int)creq->nr_sectors);
2541 #endif /* CCISS_DEBUG */
2543 seg = blk_rq_map_sg(q, creq, tmp_sg);
2545 /* get the DMA records for the setup */
2546 if (c->Request.Type.Direction == XFER_READ)
2547 dir = PCI_DMA_FROMDEVICE;
2549 dir = PCI_DMA_TODEVICE;
2551 for (i = 0; i < seg; i++) {
2552 c->SG[i].Len = tmp_sg[i].length;
2553 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2555 tmp_sg[i].length, dir);
2556 c->SG[i].Addr.lower = temp64.val32.lower;
2557 c->SG[i].Addr.upper = temp64.val32.upper;
2558 c->SG[i].Ext = 0; // we are not chaining
2560 /* track how many SG entries we are using */
2565 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2566 creq->nr_sectors, seg);
2567 #endif /* CCISS_DEBUG */
2569 c->Header.SGList = c->Header.SGTotal = seg;
2570 if(h->cciss_read == CCISS_READ_10) {
2571 c->Request.CDB[1] = 0;
2572 c->Request.CDB[2] = (start_blk >> 24) & 0xff; //MSB
2573 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2574 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2575 c->Request.CDB[5] = start_blk & 0xff;
2576 c->Request.CDB[6] = 0; // (sect >> 24) & 0xff; MSB
2577 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2578 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2579 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2581 c->Request.CDBLen = 16;
2582 c->Request.CDB[1]= 0;
2583 c->Request.CDB[2]= (start_blk >> 56) & 0xff; //MSB
2584 c->Request.CDB[3]= (start_blk >> 48) & 0xff;
2585 c->Request.CDB[4]= (start_blk >> 40) & 0xff;
2586 c->Request.CDB[5]= (start_blk >> 32) & 0xff;
2587 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2588 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2589 c->Request.CDB[8]= (start_blk >> 8) & 0xff;
2590 c->Request.CDB[9]= start_blk & 0xff;
2591 c->Request.CDB[10]= (creq->nr_sectors >> 24) & 0xff;
2592 c->Request.CDB[11]= (creq->nr_sectors >> 16) & 0xff;
2593 c->Request.CDB[12]= (creq->nr_sectors >> 8) & 0xff;
2594 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2595 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2598 spin_lock_irq(q->queue_lock);
2600 addQ(&(h->reqQ), c);
2602 if (h->Qdepth > h->maxQsinceinit)
2603 h->maxQsinceinit = h->Qdepth;
2609 /* We will already have the driver lock here so not need
2615 static inline unsigned long get_next_completion(ctlr_info_t *h)
2617 #ifdef CONFIG_CISS_SCSI_TAPE
2618 /* Any rejects from sendcmd() lying around? Process them first */
2619 if (h->scsi_rejects.ncompletions == 0)
2620 return h->access.command_completed(h);
2622 struct sendcmd_reject_list *srl;
2624 srl = &h->scsi_rejects;
2625 n = --srl->ncompletions;
2626 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2628 return srl->complete[n];
2631 return h->access.command_completed(h);
2635 static inline int interrupt_pending(ctlr_info_t *h)
2637 #ifdef CONFIG_CISS_SCSI_TAPE
2638 return (h->access.intr_pending(h)
2639 || (h->scsi_rejects.ncompletions > 0));
2641 return h->access.intr_pending(h);
2645 static inline long interrupt_not_for_us(ctlr_info_t *h)
2647 #ifdef CONFIG_CISS_SCSI_TAPE
2648 return (((h->access.intr_pending(h) == 0) ||
2649 (h->interrupts_enabled == 0))
2650 && (h->scsi_rejects.ncompletions == 0));
2652 return (((h->access.intr_pending(h) == 0) ||
2653 (h->interrupts_enabled == 0)));
2657 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2659 ctlr_info_t *h = dev_id;
2660 CommandList_struct *c;
2661 unsigned long flags;
2664 if (interrupt_not_for_us(h))
2667 * If there are completed commands in the completion queue,
2668 * we had better do something about it.
2670 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2671 while (interrupt_pending(h)) {
2672 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2676 if (a2 >= NR_CMDS) {
2678 "cciss: controller cciss%d failed, stopping.\n",
2680 fail_all_cmds(h->ctlr);
2684 c = h->cmd_pool + a2;
2689 if ((c = h->cmpQ) == NULL) {
2691 "cciss: Completion of %08x ignored\n",
2695 while (c->busaddr != a) {
2702 * If we've found the command, take it off the
2703 * completion Q and free it
2705 if (c->busaddr == a) {
2706 removeQ(&h->cmpQ, c);
2707 if (c->cmd_type == CMD_RWREQ) {
2708 complete_command(h, c, 0);
2709 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2710 complete(c->waiting);
2712 # ifdef CONFIG_CISS_SCSI_TAPE
2713 else if (c->cmd_type == CMD_SCSI)
2714 complete_scsi_command(c, 0, a1);
2721 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2726 * We cannot read the structure directly, for portability we must use
2728 * This is for debug only.
2731 static void print_cfg_table(CfgTable_struct *tb)
2736 printk("Controller Configuration information\n");
2737 printk("------------------------------------\n");
2738 for (i = 0; i < 4; i++)
2739 temp_name[i] = readb(&(tb->Signature[i]));
2740 temp_name[4] = '\0';
2741 printk(" Signature = %s\n", temp_name);
2742 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2743 printk(" Transport methods supported = 0x%x\n",
2744 readl(&(tb->TransportSupport)));
2745 printk(" Transport methods active = 0x%x\n",
2746 readl(&(tb->TransportActive)));
2747 printk(" Requested transport Method = 0x%x\n",
2748 readl(&(tb->HostWrite.TransportRequest)));
2749 printk(" Coalesce Interrupt Delay = 0x%x\n",
2750 readl(&(tb->HostWrite.CoalIntDelay)));
2751 printk(" Coalesce Interrupt Count = 0x%x\n",
2752 readl(&(tb->HostWrite.CoalIntCount)));
2753 printk(" Max outstanding commands = 0x%d\n",
2754 readl(&(tb->CmdsOutMax)));
2755 printk(" Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2756 for (i = 0; i < 16; i++)
2757 temp_name[i] = readb(&(tb->ServerName[i]));
2758 temp_name[16] = '\0';
2759 printk(" Server Name = %s\n", temp_name);
2760 printk(" Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
2762 #endif /* CCISS_DEBUG */
2764 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
2766 int i, offset, mem_type, bar_type;
2767 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2770 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2771 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
2772 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2775 mem_type = pci_resource_flags(pdev, i) &
2776 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2778 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2779 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2780 offset += 4; /* 32 bit */
2782 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2785 default: /* reserved in PCI 2.2 */
2787 "Base address is invalid\n");
2792 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2798 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
2799 * controllers that are capable. If not, we use IO-APIC mode.
2802 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
2803 struct pci_dev *pdev, __u32 board_id)
2805 #ifdef CONFIG_PCI_MSI
2807 struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
2811 /* Some boards advertise MSI but don't really support it */
2812 if ((board_id == 0x40700E11) ||
2813 (board_id == 0x40800E11) ||
2814 (board_id == 0x40820E11) || (board_id == 0x40830E11))
2815 goto default_int_mode;
2817 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2818 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2820 c->intr[0] = cciss_msix_entries[0].vector;
2821 c->intr[1] = cciss_msix_entries[1].vector;
2822 c->intr[2] = cciss_msix_entries[2].vector;
2823 c->intr[3] = cciss_msix_entries[3].vector;
2828 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2829 "available\n", err);
2831 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2835 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2836 if (!pci_enable_msi(pdev)) {
2837 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2841 printk(KERN_WARNING "cciss: MSI init failed\n");
2842 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2847 #endif /* CONFIG_PCI_MSI */
2848 /* if we get here we're going to use the default interrupt mode */
2849 c->intr[SIMPLE_MODE_INT] = pdev->irq;
2853 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2855 ushort subsystem_vendor_id, subsystem_device_id, command;
2856 __u32 board_id, scratchpad = 0;
2858 __u32 cfg_base_addr;
2859 __u64 cfg_base_addr_index;
2862 /* check to see if controller has been disabled */
2863 /* BEFORE trying to enable it */
2864 (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
2865 if (!(command & 0x02)) {
2867 "cciss: controller appears to be disabled\n");
2871 err = pci_enable_device(pdev);
2873 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2877 err = pci_request_regions(pdev, "cciss");
2879 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
2881 goto err_out_disable_pdev;
2884 subsystem_vendor_id = pdev->subsystem_vendor;
2885 subsystem_device_id = pdev->subsystem_device;
2886 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2887 subsystem_vendor_id);
2890 printk("command = %x\n", command);
2891 printk("irq = %x\n", pdev->irq);
2892 printk("board_id = %x\n", board_id);
2893 #endif /* CCISS_DEBUG */
2895 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2896 * else we use the IO-APIC interrupt assigned to us by system ROM.
2898 cciss_interrupt_mode(c, pdev, board_id);
2901 * Memory base addr is first addr , the second points to the config
2905 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2907 printk("address 0 = %x\n", c->paddr);
2908 #endif /* CCISS_DEBUG */
2909 c->vaddr = remap_pci_mem(c->paddr, 200);
2911 /* Wait for the board to become ready. (PCI hotplug needs this.)
2912 * We poll for up to 120 secs, once per 100ms. */
2913 for (i = 0; i < 1200; i++) {
2914 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2915 if (scratchpad == CCISS_FIRMWARE_READY)
2917 set_current_state(TASK_INTERRUPTIBLE);
2918 schedule_timeout(HZ / 10); /* wait 100ms */
2920 if (scratchpad != CCISS_FIRMWARE_READY) {
2921 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
2923 goto err_out_free_res;
2926 /* get the address index number */
2927 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2928 cfg_base_addr &= (__u32) 0x0000ffff;
2930 printk("cfg base address = %x\n", cfg_base_addr);
2931 #endif /* CCISS_DEBUG */
2932 cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
2934 printk("cfg base address index = %x\n", cfg_base_addr_index);
2935 #endif /* CCISS_DEBUG */
2936 if (cfg_base_addr_index == -1) {
2937 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2939 goto err_out_free_res;
2942 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2944 printk("cfg offset = %x\n", cfg_offset);
2945 #endif /* CCISS_DEBUG */
2946 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2947 cfg_base_addr_index) +
2948 cfg_offset, sizeof(CfgTable_struct));
2949 c->board_id = board_id;
2952 print_cfg_table(c->cfgtable);
2953 #endif /* CCISS_DEBUG */
2955 for (i = 0; i < ARRAY_SIZE(products); i++) {
2956 if (board_id == products[i].board_id) {
2957 c->product_name = products[i].product_name;
2958 c->access = *(products[i].access);
2962 if (i == ARRAY_SIZE(products)) {
2963 printk(KERN_WARNING "cciss: Sorry, I don't know how"
2964 " to access the Smart Array controller %08lx\n",
2965 (unsigned long)board_id);
2967 goto err_out_free_res;
2969 if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
2970 (readb(&c->cfgtable->Signature[1]) != 'I') ||
2971 (readb(&c->cfgtable->Signature[2]) != 'S') ||
2972 (readb(&c->cfgtable->Signature[3]) != 'S')) {
2973 printk("Does not appear to be a valid CISS config table\n");
2975 goto err_out_free_res;
2979 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2981 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2983 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2988 printk("Trying to put board into Simple mode\n");
2989 #endif /* CCISS_DEBUG */
2990 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2991 /* Update the field, and then ring the doorbell */
2992 writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
2993 writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2995 /* under certain very rare conditions, this can take awhile.
2996 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2997 * as we enter this code.) */
2998 for (i = 0; i < MAX_CONFIG_WAIT; i++) {
2999 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3001 /* delay and try again */
3002 set_current_state(TASK_INTERRUPTIBLE);
3003 schedule_timeout(10);
3007 printk(KERN_DEBUG "I counter got to %d %x\n", i,
3008 readl(c->vaddr + SA5_DOORBELL));
3009 #endif /* CCISS_DEBUG */
3011 print_cfg_table(c->cfgtable);
3012 #endif /* CCISS_DEBUG */
3014 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
3015 printk(KERN_WARNING "cciss: unable to get board into"
3018 goto err_out_free_res;
3023 pci_release_regions(pdev);
3025 err_out_disable_pdev:
3026 pci_disable_device(pdev);
3031 * Gets information about the local volumes attached to the controller.
3033 static void cciss_getgeometry(int cntl_num)
3035 ReportLunData_struct *ld_buff;
3036 InquiryData_struct *inq_buff;
3042 sector_t total_size;
3044 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3045 if (ld_buff == NULL) {
3046 printk(KERN_ERR "cciss: out of memory\n");
3049 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3050 if (inq_buff == NULL) {
3051 printk(KERN_ERR "cciss: out of memory\n");
3055 /* Get the firmware version */
3056 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3057 sizeof(InquiryData_struct), 0, 0, 0, NULL,
3059 if (return_code == IO_OK) {
3060 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3061 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3062 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3063 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3064 } else { /* send command failed */
3066 printk(KERN_WARNING "cciss: unable to determine firmware"
3067 " version of controller\n");
3069 /* Get the number of logical volumes */
3070 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3071 sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3074 if (return_code == IO_OK) {
3076 printk("LUN Data\n--------------------------\n");
3077 #endif /* CCISS_DEBUG */
3080 (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3082 (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3084 (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
3085 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3086 } else { /* reading number of logical volumes failed */
3088 printk(KERN_WARNING "cciss: report logical volume"
3089 " command failed\n");
3092 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
3093 if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3095 "ciss: only %d number of logical volumes supported\n",
3097 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3100 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3101 ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3102 ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3103 hba[cntl_num]->num_luns);
3104 #endif /* CCISS_DEBUG */
3106 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
3107 for (i = 0; i < CISS_MAX_LUN; i++) {
3108 if (i < hba[cntl_num]->num_luns) {
3109 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3111 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3113 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3115 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3117 hba[cntl_num]->drv[i].LunID = lunid;
3120 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
3121 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3122 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3123 hba[cntl_num]->drv[i].LunID);
3124 #endif /* CCISS_DEBUG */
3126 /* testing to see if 16-byte CDBs are already being used */
3127 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3128 cciss_read_capacity_16(cntl_num, i, 0,
3129 &total_size, &block_size);
3132 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3134 /* total_size = last LBA + 1 */
3135 if(total_size == (__u32) 0) {
3136 cciss_read_capacity_16(cntl_num, i, 0,
3137 &total_size, &block_size);
3138 hba[cntl_num]->cciss_read = CCISS_READ_16;
3139 hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3141 hba[cntl_num]->cciss_read = CCISS_READ_10;
3142 hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3145 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3146 block_size, inq_buff,
3147 &hba[cntl_num]->drv[i]);
3149 /* initialize raid_level to indicate a free space */
3150 hba[cntl_num]->drv[i].raid_level = -1;
3157 /* Function to find the first free pointer into our hba[] array */
3158 /* Returns -1 if no free entries are left. */
3159 static int alloc_cciss_hba(void)
3161 struct gendisk *disk[NWD];
3163 for (n = 0; n < NWD; n++) {
3164 disk[n] = alloc_disk(1 << NWD_SHIFT);
3169 for (i = 0; i < MAX_CTLR; i++) {
3172 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3175 for (n = 0; n < NWD; n++)
3176 p->gendisk[n] = disk[n];
3181 printk(KERN_WARNING "cciss: This driver supports a maximum"
3182 " of %d controllers.\n", MAX_CTLR);
3185 printk(KERN_ERR "cciss: out of memory.\n");
3192 static void free_hba(int i)
3194 ctlr_info_t *p = hba[i];
3198 for (n = 0; n < NWD; n++)
3199 put_disk(p->gendisk[n]);
3204 * This is it. Find all the controllers and register them. I really hate
3205 * stealing all these major device numbers.
3206 * returns the number of block devices registered.
3208 static int __devinit cciss_init_one(struct pci_dev *pdev,
3209 const struct pci_device_id *ent)
3217 i = alloc_cciss_hba();
3221 hba[i]->busy_initializing = 1;
3223 if (cciss_pci_init(hba[i], pdev) != 0)
3226 sprintf(hba[i]->devname, "cciss%d", i);
3228 hba[i]->pdev = pdev;
3230 /* configure PCI DMA stuff */
3231 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3233 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3236 printk(KERN_ERR "cciss: no suitable DMA available\n");
3241 * register with the major number, or get a dynamic major number
3242 * by passing 0 as argument. This is done for greater than
3243 * 8 controller support.
3245 if (i < MAX_CTLR_ORIG)
3246 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3247 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3248 if (rc == -EBUSY || rc == -EINVAL) {
3250 "cciss: Unable to get major number %d for %s "
3251 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3254 if (i >= MAX_CTLR_ORIG)
3258 /* make sure the board interrupts are off */
3259 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3260 if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3261 IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3262 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3263 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3267 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3268 hba[i]->devname, pdev->device, pci_name(pdev),
3269 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3271 hba[i]->cmd_pool_bits =
3272 kmalloc(((NR_CMDS + BITS_PER_LONG -
3273 1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3274 hba[i]->cmd_pool = (CommandList_struct *)
3275 pci_alloc_consistent(hba[i]->pdev,
3276 NR_CMDS * sizeof(CommandList_struct),
3277 &(hba[i]->cmd_pool_dhandle));
3278 hba[i]->errinfo_pool = (ErrorInfo_struct *)
3279 pci_alloc_consistent(hba[i]->pdev,
3280 NR_CMDS * sizeof(ErrorInfo_struct),
3281 &(hba[i]->errinfo_pool_dhandle));
3282 if ((hba[i]->cmd_pool_bits == NULL)
3283 || (hba[i]->cmd_pool == NULL)
3284 || (hba[i]->errinfo_pool == NULL)) {
3285 printk(KERN_ERR "cciss: out of memory");
3288 #ifdef CONFIG_CISS_SCSI_TAPE
3289 hba[i]->scsi_rejects.complete =
3290 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3291 (NR_CMDS + 5), GFP_KERNEL);
3292 if (hba[i]->scsi_rejects.complete == NULL) {
3293 printk(KERN_ERR "cciss: out of memory");
3297 spin_lock_init(&hba[i]->lock);
3299 /* Initialize the pdev driver private data.
3300 have it point to hba[i]. */
3301 pci_set_drvdata(pdev, hba[i]);
3302 /* command and error info recs zeroed out before
3304 memset(hba[i]->cmd_pool_bits, 0,
3305 ((NR_CMDS + BITS_PER_LONG -
3306 1) / BITS_PER_LONG) * sizeof(unsigned long));
3309 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3310 #endif /* CCISS_DEBUG */
3312 cciss_getgeometry(i);
3314 cciss_scsi_setup(i);
3316 /* Turn the interrupts on so we can service requests */
3317 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3320 hba[i]->busy_initializing = 0;
3322 for (j = 0; j < NWD; j++) { /* mfm */
3323 drive_info_struct *drv = &(hba[i]->drv[j]);
3324 struct gendisk *disk = hba[i]->gendisk[j];
3326 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3329 "cciss: unable to allocate queue for disk %d\n",
3335 q->backing_dev_info.ra_pages = READ_AHEAD;
3336 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3338 /* This is a hardware imposed limit. */
3339 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3341 /* This is a limit in the driver and could be eliminated. */
3342 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3344 blk_queue_max_sectors(q, 512);
3346 blk_queue_softirq_done(q, cciss_softirq_done);
3348 q->queuedata = hba[i];
3349 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3350 disk->major = hba[i]->major;
3351 disk->first_minor = j << NWD_SHIFT;
3352 disk->fops = &cciss_fops;
3354 disk->private_data = drv;
3355 disk->driverfs_dev = &pdev->dev;
3356 /* we must register the controller even if no disks exist */
3357 /* this is for the online array utilities */
3358 if (!drv->heads && j)
3360 blk_queue_hardsect_size(q, drv->block_size);
3361 set_capacity(disk, drv->nr_blocks);
3368 #ifdef CONFIG_CISS_SCSI_TAPE
3369 kfree(hba[i]->scsi_rejects.complete);
3371 kfree(hba[i]->cmd_pool_bits);
3372 if (hba[i]->cmd_pool)
3373 pci_free_consistent(hba[i]->pdev,
3374 NR_CMDS * sizeof(CommandList_struct),
3375 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3376 if (hba[i]->errinfo_pool)
3377 pci_free_consistent(hba[i]->pdev,
3378 NR_CMDS * sizeof(ErrorInfo_struct),
3379 hba[i]->errinfo_pool,
3380 hba[i]->errinfo_pool_dhandle);
3381 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3383 unregister_blkdev(hba[i]->major, hba[i]->devname);
3385 hba[i]->busy_initializing = 0;
3390 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3392 ctlr_info_t *tmp_ptr;
3397 if (pci_get_drvdata(pdev) == NULL) {
3398 printk(KERN_ERR "cciss: Unable to remove device \n");
3401 tmp_ptr = pci_get_drvdata(pdev);
3403 if (hba[i] == NULL) {
3404 printk(KERN_ERR "cciss: device appears to "
3405 "already be removed \n");
3408 /* Turn board interrupts off and send the flush cache command */
3409 /* sendcmd will turn off interrupt, and send the flush...
3410 * To write all data in the battery backed cache to disks */
3411 memset(flush_buf, 0, 4);
3412 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3414 if (return_code != IO_OK) {
3415 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3418 free_irq(hba[i]->intr[2], hba[i]);
3420 #ifdef CONFIG_PCI_MSI
3421 if (hba[i]->msix_vector)
3422 pci_disable_msix(hba[i]->pdev);
3423 else if (hba[i]->msi_vector)
3424 pci_disable_msi(hba[i]->pdev);
3425 #endif /* CONFIG_PCI_MSI */
3427 iounmap(hba[i]->vaddr);
3428 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3429 unregister_blkdev(hba[i]->major, hba[i]->devname);
3430 remove_proc_entry(hba[i]->devname, proc_cciss);
3432 /* remove it from the disk list */
3433 for (j = 0; j < NWD; j++) {
3434 struct gendisk *disk = hba[i]->gendisk[j];
3436 request_queue_t *q = disk->queue;
3438 if (disk->flags & GENHD_FL_UP)
3441 blk_cleanup_queue(q);
3445 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3446 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3447 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(ErrorInfo_struct),
3448 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3449 kfree(hba[i]->cmd_pool_bits);
3450 #ifdef CONFIG_CISS_SCSI_TAPE
3451 kfree(hba[i]->scsi_rejects.complete);
3453 pci_release_regions(pdev);
3454 pci_disable_device(pdev);
3455 pci_set_drvdata(pdev, NULL);
3459 static struct pci_driver cciss_pci_driver = {
3461 .probe = cciss_init_one,
3462 .remove = __devexit_p(cciss_remove_one),
3463 .id_table = cciss_pci_device_id, /* id_table */
3467 * This is it. Register the PCI driver information for the cards we control
3468 * the OS will call our registered routines when it finds one of our cards.
3470 static int __init cciss_init(void)
3472 printk(KERN_INFO DRIVER_NAME "\n");
3474 /* Register for our PCI devices */
3475 return pci_register_driver(&cciss_pci_driver);
3478 static void __exit cciss_cleanup(void)
3482 pci_unregister_driver(&cciss_pci_driver);
3483 /* double check that all controller entrys have been removed */
3484 for (i = 0; i < MAX_CTLR; i++) {
3485 if (hba[i] != NULL) {
3486 printk(KERN_WARNING "cciss: had to remove"
3487 " controller %d\n", i);
3488 cciss_remove_one(hba[i]->pdev);
3491 remove_proc_entry("cciss", proc_root_driver);
3494 static void fail_all_cmds(unsigned long ctlr)
3496 /* If we get here, the board is apparently dead. */
3497 ctlr_info_t *h = hba[ctlr];
3498 CommandList_struct *c;
3499 unsigned long flags;
3501 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3502 h->alive = 0; /* the controller apparently died... */
3504 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3506 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3508 /* move everything off the request queue onto the completed queue */
3509 while ((c = h->reqQ) != NULL) {
3510 removeQ(&(h->reqQ), c);
3512 addQ(&(h->cmpQ), c);
3515 /* Now, fail everything on the completed queue with a HW error */
3516 while ((c = h->cmpQ) != NULL) {
3517 removeQ(&h->cmpQ, c);
3518 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3519 if (c->cmd_type == CMD_RWREQ) {
3520 complete_command(h, c, 0);
3521 } else if (c->cmd_type == CMD_IOCTL_PEND)
3522 complete(c->waiting);
3523 #ifdef CONFIG_CISS_SCSI_TAPE
3524 else if (c->cmd_type == CMD_SCSI)
3525 complete_scsi_command(c, 0, 0);
3528 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3532 module_init(cciss_init);
3533 module_exit(cciss_cleanup);