cciss.c revision 7d1fd970e4b2e84a624b3274669fa642fcd19c98
1/* 2 * Disk Array driver for HP Smart Array controllers. 3 * (C) Copyright 2000, 2007 Hewlett-Packard Development Company, L.P. 4 * 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; version 2 of the License. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 17 * 02111-1307, USA. 18 * 19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com 20 * 21 */ 22 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> 31#include <linux/fs.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> 42#include <asm/io.h> 43 44#include <linux/dma-mapping.h> 45#include <linux/blkdev.h> 46#include <linux/genhd.h> 47#include <linux/completion.h> 48#include <scsi/scsi.h> 49#include <scsi/sg.h> 50#include <scsi/scsi_ioctl.h> 51#include <linux/cdrom.h> 52 53#define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin)) 54#define DRIVER_NAME "HP CISS Driver (v 3.6.14)" 55#define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,14) 56 57/* Embedded module documentation macros - see modules.h */ 58MODULE_AUTHOR("Hewlett-Packard Company"); 59MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.14"); 60MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400" 61 " SA6i P600 P800 P400 P400i E200 E200i E500"); 62MODULE_VERSION("3.6.14"); 63MODULE_LICENSE("GPL"); 64 65#include "cciss_cmd.h" 66#include "cciss.h" 67#include <linux/cciss_ioctl.h> 68 69/* define the PCI info for the cards we can control */ 70static const struct pci_device_id cciss_pci_device_id[] = { 71 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS, 0x0E11, 0x4070}, 72 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080}, 73 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082}, 74 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083}, 75 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091}, 76 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A}, 77 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B}, 78 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C}, 79 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D}, 80 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA, 0x103C, 0x3225}, 81 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3223}, 82 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3234}, 83 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3235}, 84 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3211}, 85 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3212}, 86 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3213}, 87 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3214}, 88 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3215}, 89 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3237}, 90 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x323D}, 91 {PCI_VENDOR_ID_HP, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 92 PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0}, 93 {0,} 94}; 95 96MODULE_DEVICE_TABLE(pci, cciss_pci_device_id); 97 98/* board_id = Subsystem Device ID & Vendor ID 99 * product = Marketing Name for the board 100 * access = Address of the struct of function pointers 101 * nr_cmds = Number of commands supported by controller 102 */ 103static struct board_type products[] = { 104 {0x40700E11, "Smart Array 5300", &SA5_access, 512}, 105 {0x40800E11, "Smart Array 5i", &SA5B_access, 512}, 106 {0x40820E11, "Smart Array 532", &SA5B_access, 512}, 107 {0x40830E11, "Smart Array 5312", &SA5B_access, 512}, 108 {0x409A0E11, "Smart Array 641", &SA5_access, 512}, 109 {0x409B0E11, "Smart Array 642", &SA5_access, 512}, 110 {0x409C0E11, "Smart Array 6400", &SA5_access, 512}, 111 {0x409D0E11, "Smart Array 6400 EM", &SA5_access, 512}, 112 {0x40910E11, "Smart Array 6i", &SA5_access, 512}, 113 {0x3225103C, "Smart Array P600", &SA5_access, 512}, 114 {0x3223103C, "Smart Array P800", &SA5_access, 512}, 115 {0x3234103C, "Smart Array P400", &SA5_access, 512}, 116 {0x3235103C, "Smart Array P400i", &SA5_access, 512}, 117 {0x3211103C, "Smart Array E200i", &SA5_access, 120}, 118 {0x3212103C, "Smart Array E200", &SA5_access, 120}, 119 {0x3213103C, "Smart Array E200i", &SA5_access, 120}, 120 {0x3214103C, "Smart Array E200i", &SA5_access, 120}, 121 {0x3215103C, "Smart Array E200i", &SA5_access, 120}, 122 {0x3237103C, "Smart Array E500", &SA5_access, 512}, 123 {0x323D103C, "Smart Array P700m", &SA5_access, 512}, 124 {0xFFFF103C, "Unknown Smart Array", &SA5_access, 120}, 125}; 126 127/* How long to wait (in milliseconds) for board to go into simple mode */ 128#define MAX_CONFIG_WAIT 30000 129#define MAX_IOCTL_CONFIG_WAIT 1000 130 131/*define how many times we will try a command because of bus resets */ 132#define MAX_CMD_RETRIES 3 133 134#define READ_AHEAD 1024 135#define MAX_CTLR 32 136 137/* Originally cciss driver only supports 8 major numbers */ 138#define MAX_CTLR_ORIG 8 139 140static ctlr_info_t *hba[MAX_CTLR]; 141 142static void do_cciss_request(struct request_queue *q); 143static irqreturn_t do_cciss_intr(int irq, void *dev_id); 144static int cciss_open(struct inode *inode, struct file *filep); 145static int cciss_release(struct inode *inode, struct file *filep); 146static int cciss_ioctl(struct inode *inode, struct file *filep, 147 unsigned int cmd, unsigned long arg); 148static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo); 149 150static int cciss_revalidate(struct gendisk *disk); 151static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk); 152static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, 153 int clear_all); 154 155static void cciss_read_capacity(int ctlr, int logvol, int withirq, 156 sector_t *total_size, unsigned int *block_size); 157static void cciss_read_capacity_16(int ctlr, int logvol, int withirq, 158 sector_t *total_size, unsigned int *block_size); 159static void cciss_geometry_inquiry(int ctlr, int logvol, 160 int withirq, sector_t total_size, 161 unsigned int block_size, InquiryData_struct *inq_buff, 162 drive_info_struct *drv); 163static void cciss_getgeometry(int cntl_num); 164static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, 165 __u32); 166static void start_io(ctlr_info_t *h); 167static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, 168 unsigned int use_unit_num, unsigned int log_unit, 169 __u8 page_code, unsigned char *scsi3addr, int cmd_type); 170static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size, 171 unsigned int use_unit_num, unsigned int log_unit, 172 __u8 page_code, int cmd_type); 173 174static void fail_all_cmds(unsigned long ctlr); 175 176#ifdef CONFIG_PROC_FS 177static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 178 int length, int *eof, void *data); 179static void cciss_procinit(int i); 180#else 181static void cciss_procinit(int i) 182{ 183} 184#endif /* CONFIG_PROC_FS */ 185 186#ifdef CONFIG_COMPAT 187static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg); 188#endif 189 190static struct block_device_operations cciss_fops = { 191 .owner = THIS_MODULE, 192 .open = cciss_open, 193 .release = cciss_release, 194 .ioctl = cciss_ioctl, 195 .getgeo = cciss_getgeo, 196#ifdef CONFIG_COMPAT 197 .compat_ioctl = cciss_compat_ioctl, 198#endif 199 .revalidate_disk = cciss_revalidate, 200}; 201 202/* 203 * Enqueuing and dequeuing functions for cmdlists. 204 */ 205static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c) 206{ 207 if (*Qptr == NULL) { 208 *Qptr = c; 209 c->next = c->prev = c; 210 } else { 211 c->prev = (*Qptr)->prev; 212 c->next = (*Qptr); 213 (*Qptr)->prev->next = c; 214 (*Qptr)->prev = c; 215 } 216} 217 218static inline CommandList_struct *removeQ(CommandList_struct **Qptr, 219 CommandList_struct *c) 220{ 221 if (c && c->next != c) { 222 if (*Qptr == c) 223 *Qptr = c->next; 224 c->prev->next = c->next; 225 c->next->prev = c->prev; 226 } else { 227 *Qptr = NULL; 228 } 229 return c; 230} 231 232#include "cciss_scsi.c" /* For SCSI tape support */ 233 234#define RAID_UNKNOWN 6 235 236#ifdef CONFIG_PROC_FS 237 238/* 239 * Report information about this controller. 240 */ 241#define ENG_GIG 1000000000 242#define ENG_GIG_FACTOR (ENG_GIG/512) 243static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG", 244 "UNKNOWN" 245}; 246 247static struct proc_dir_entry *proc_cciss; 248 249static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 250 int length, int *eof, void *data) 251{ 252 off_t pos = 0; 253 off_t len = 0; 254 int size, i, ctlr; 255 ctlr_info_t *h = (ctlr_info_t *) data; 256 drive_info_struct *drv; 257 unsigned long flags; 258 sector_t vol_sz, vol_sz_frac; 259 260 ctlr = h->ctlr; 261 262 /* prevent displaying bogus info during configuration 263 * or deconfiguration of a logical volume 264 */ 265 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 266 if (h->busy_configuring) { 267 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 268 return -EBUSY; 269 } 270 h->busy_configuring = 1; 271 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 272 273 size = sprintf(buffer, "%s: HP %s Controller\n" 274 "Board ID: 0x%08lx\n" 275 "Firmware Version: %c%c%c%c\n" 276 "IRQ: %d\n" 277 "Logical drives: %d\n" 278 "Max sectors: %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", 284 h->devname, 285 h->product_name, 286 (unsigned long)h->board_id, 287 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], 288 h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT], 289 h->num_luns, 290 h->cciss_max_sectors, 291 h->Qdepth, h->commands_outstanding, 292 h->maxQsinceinit, h->max_outstanding, h->maxSG); 293 294 pos += size; 295 len += size; 296 cciss_proc_tape_report(ctlr, buffer, &pos, &len); 297 for (i = 0; i <= h->highest_lun; i++) { 298 299 drv = &h->drv[i]; 300 if (drv->heads == 0) 301 continue; 302 303 vol_sz = drv->nr_blocks; 304 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR); 305 vol_sz_frac *= 100; 306 sector_div(vol_sz_frac, ENG_GIG_FACTOR); 307 308 if (drv->raid_level > 5) 309 drv->raid_level = RAID_UNKNOWN; 310 size = sprintf(buffer + len, "cciss/c%dd%d:" 311 "\t%4u.%02uGB\tRAID %s\n", 312 ctlr, i, (int)vol_sz, (int)vol_sz_frac, 313 raid_label[drv->raid_level]); 314 pos += size; 315 len += size; 316 } 317 318 *eof = 1; 319 *start = buffer + offset; 320 len -= offset; 321 if (len > length) 322 len = length; 323 h->busy_configuring = 0; 324 return len; 325} 326 327static int 328cciss_proc_write(struct file *file, const char __user *buffer, 329 unsigned long count, void *data) 330{ 331 unsigned char cmd[80]; 332 int len; 333#ifdef CONFIG_CISS_SCSI_TAPE 334 ctlr_info_t *h = (ctlr_info_t *) data; 335 int rc; 336#endif 337 338 if (count > sizeof(cmd) - 1) 339 return -EINVAL; 340 if (copy_from_user(cmd, buffer, count)) 341 return -EFAULT; 342 cmd[count] = '\0'; 343 len = strlen(cmd); // above 3 lines ensure safety 344 if (len && cmd[len - 1] == '\n') 345 cmd[--len] = '\0'; 346# ifdef CONFIG_CISS_SCSI_TAPE 347 if (strcmp("engage scsi", cmd) == 0) { 348 rc = cciss_engage_scsi(h->ctlr); 349 if (rc != 0) 350 return -rc; 351 return count; 352 } 353 /* might be nice to have "disengage" too, but it's not 354 safely possible. (only 1 module use count, lock issues.) */ 355# endif 356 return -EINVAL; 357} 358 359/* 360 * Get us a file in /proc/cciss that says something about each controller. 361 * Create /proc/cciss if it doesn't exist yet. 362 */ 363static void __devinit cciss_procinit(int i) 364{ 365 struct proc_dir_entry *pde; 366 367 if (proc_cciss == NULL) { 368 proc_cciss = proc_mkdir("cciss", proc_root_driver); 369 if (!proc_cciss) 370 return; 371 } 372 373 pde = create_proc_read_entry(hba[i]->devname, 374 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH, 375 proc_cciss, cciss_proc_get_info, hba[i]); 376 pde->write_proc = cciss_proc_write; 377} 378#endif /* CONFIG_PROC_FS */ 379 380/* 381 * For operations that cannot sleep, a command block is allocated at init, 382 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track 383 * which ones are free or in use. For operations that can wait for kmalloc 384 * to possible sleep, this routine can be called with get_from_pool set to 0. 385 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was. 386 */ 387static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool) 388{ 389 CommandList_struct *c; 390 int i; 391 u64bit temp64; 392 dma_addr_t cmd_dma_handle, err_dma_handle; 393 394 if (!get_from_pool) { 395 c = (CommandList_struct *) pci_alloc_consistent(h->pdev, 396 sizeof(CommandList_struct), &cmd_dma_handle); 397 if (c == NULL) 398 return NULL; 399 memset(c, 0, sizeof(CommandList_struct)); 400 401 c->cmdindex = -1; 402 403 c->err_info = (ErrorInfo_struct *) 404 pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct), 405 &err_dma_handle); 406 407 if (c->err_info == NULL) { 408 pci_free_consistent(h->pdev, 409 sizeof(CommandList_struct), c, cmd_dma_handle); 410 return NULL; 411 } 412 memset(c->err_info, 0, sizeof(ErrorInfo_struct)); 413 } else { /* get it out of the controllers pool */ 414 415 do { 416 i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds); 417 if (i == h->nr_cmds) 418 return NULL; 419 } while (test_and_set_bit 420 (i & (BITS_PER_LONG - 1), 421 h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0); 422#ifdef CCISS_DEBUG 423 printk(KERN_DEBUG "cciss: using command buffer %d\n", i); 424#endif 425 c = h->cmd_pool + i; 426 memset(c, 0, sizeof(CommandList_struct)); 427 cmd_dma_handle = h->cmd_pool_dhandle 428 + i * sizeof(CommandList_struct); 429 c->err_info = h->errinfo_pool + i; 430 memset(c->err_info, 0, sizeof(ErrorInfo_struct)); 431 err_dma_handle = h->errinfo_pool_dhandle 432 + i * sizeof(ErrorInfo_struct); 433 h->nr_allocs++; 434 435 c->cmdindex = i; 436 } 437 438 c->busaddr = (__u32) cmd_dma_handle; 439 temp64.val = (__u64) err_dma_handle; 440 c->ErrDesc.Addr.lower = temp64.val32.lower; 441 c->ErrDesc.Addr.upper = temp64.val32.upper; 442 c->ErrDesc.Len = sizeof(ErrorInfo_struct); 443 444 c->ctlr = h->ctlr; 445 return c; 446} 447 448/* 449 * Frees a command block that was previously allocated with cmd_alloc(). 450 */ 451static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool) 452{ 453 int i; 454 u64bit temp64; 455 456 if (!got_from_pool) { 457 temp64.val32.lower = c->ErrDesc.Addr.lower; 458 temp64.val32.upper = c->ErrDesc.Addr.upper; 459 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct), 460 c->err_info, (dma_addr_t) temp64.val); 461 pci_free_consistent(h->pdev, sizeof(CommandList_struct), 462 c, (dma_addr_t) c->busaddr); 463 } else { 464 i = c - h->cmd_pool; 465 clear_bit(i & (BITS_PER_LONG - 1), 466 h->cmd_pool_bits + (i / BITS_PER_LONG)); 467 h->nr_frees++; 468 } 469} 470 471static inline ctlr_info_t *get_host(struct gendisk *disk) 472{ 473 return disk->queue->queuedata; 474} 475 476static inline drive_info_struct *get_drv(struct gendisk *disk) 477{ 478 return disk->private_data; 479} 480 481/* 482 * Open. Make sure the device is really there. 483 */ 484static int cciss_open(struct inode *inode, struct file *filep) 485{ 486 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk); 487 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk); 488 489#ifdef CCISS_DEBUG 490 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name); 491#endif /* CCISS_DEBUG */ 492 493 if (host->busy_initializing || drv->busy_configuring) 494 return -EBUSY; 495 /* 496 * Root is allowed to open raw volume zero even if it's not configured 497 * so array config can still work. Root is also allowed to open any 498 * volume that has a LUN ID, so it can issue IOCTL to reread the 499 * disk information. I don't think I really like this 500 * but I'm already using way to many device nodes to claim another one 501 * for "raw controller". 502 */ 503 if (drv->heads == 0) { 504 if (iminor(inode) != 0) { /* not node 0? */ 505 /* if not node 0 make sure it is a partition = 0 */ 506 if (iminor(inode) & 0x0f) { 507 return -ENXIO; 508 /* if it is, make sure we have a LUN ID */ 509 } else if (drv->LunID == 0) { 510 return -ENXIO; 511 } 512 } 513 if (!capable(CAP_SYS_ADMIN)) 514 return -EPERM; 515 } 516 drv->usage_count++; 517 host->usage_count++; 518 return 0; 519} 520 521/* 522 * Close. Sync first. 523 */ 524static int cciss_release(struct inode *inode, struct file *filep) 525{ 526 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk); 527 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk); 528 529#ifdef CCISS_DEBUG 530 printk(KERN_DEBUG "cciss_release %s\n", 531 inode->i_bdev->bd_disk->disk_name); 532#endif /* CCISS_DEBUG */ 533 534 drv->usage_count--; 535 host->usage_count--; 536 return 0; 537} 538 539#ifdef CONFIG_COMPAT 540 541static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg) 542{ 543 int ret; 544 lock_kernel(); 545 ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg); 546 unlock_kernel(); 547 return ret; 548} 549 550static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, 551 unsigned long arg); 552static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, 553 unsigned long arg); 554 555static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg) 556{ 557 switch (cmd) { 558 case CCISS_GETPCIINFO: 559 case CCISS_GETINTINFO: 560 case CCISS_SETINTINFO: 561 case CCISS_GETNODENAME: 562 case CCISS_SETNODENAME: 563 case CCISS_GETHEARTBEAT: 564 case CCISS_GETBUSTYPES: 565 case CCISS_GETFIRMVER: 566 case CCISS_GETDRIVVER: 567 case CCISS_REVALIDVOLS: 568 case CCISS_DEREGDISK: 569 case CCISS_REGNEWDISK: 570 case CCISS_REGNEWD: 571 case CCISS_RESCANDISK: 572 case CCISS_GETLUNINFO: 573 return do_ioctl(f, cmd, arg); 574 575 case CCISS_PASSTHRU32: 576 return cciss_ioctl32_passthru(f, cmd, arg); 577 case CCISS_BIG_PASSTHRU32: 578 return cciss_ioctl32_big_passthru(f, cmd, arg); 579 580 default: 581 return -ENOIOCTLCMD; 582 } 583} 584 585static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, 586 unsigned long arg) 587{ 588 IOCTL32_Command_struct __user *arg32 = 589 (IOCTL32_Command_struct __user *) arg; 590 IOCTL_Command_struct arg64; 591 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64)); 592 int err; 593 u32 cp; 594 595 err = 0; 596 err |= 597 copy_from_user(&arg64.LUN_info, &arg32->LUN_info, 598 sizeof(arg64.LUN_info)); 599 err |= 600 copy_from_user(&arg64.Request, &arg32->Request, 601 sizeof(arg64.Request)); 602 err |= 603 copy_from_user(&arg64.error_info, &arg32->error_info, 604 sizeof(arg64.error_info)); 605 err |= get_user(arg64.buf_size, &arg32->buf_size); 606 err |= get_user(cp, &arg32->buf); 607 arg64.buf = compat_ptr(cp); 608 err |= copy_to_user(p, &arg64, sizeof(arg64)); 609 610 if (err) 611 return -EFAULT; 612 613 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p); 614 if (err) 615 return err; 616 err |= 617 copy_in_user(&arg32->error_info, &p->error_info, 618 sizeof(arg32->error_info)); 619 if (err) 620 return -EFAULT; 621 return err; 622} 623 624static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, 625 unsigned long arg) 626{ 627 BIG_IOCTL32_Command_struct __user *arg32 = 628 (BIG_IOCTL32_Command_struct __user *) arg; 629 BIG_IOCTL_Command_struct arg64; 630 BIG_IOCTL_Command_struct __user *p = 631 compat_alloc_user_space(sizeof(arg64)); 632 int err; 633 u32 cp; 634 635 err = 0; 636 err |= 637 copy_from_user(&arg64.LUN_info, &arg32->LUN_info, 638 sizeof(arg64.LUN_info)); 639 err |= 640 copy_from_user(&arg64.Request, &arg32->Request, 641 sizeof(arg64.Request)); 642 err |= 643 copy_from_user(&arg64.error_info, &arg32->error_info, 644 sizeof(arg64.error_info)); 645 err |= get_user(arg64.buf_size, &arg32->buf_size); 646 err |= get_user(arg64.malloc_size, &arg32->malloc_size); 647 err |= get_user(cp, &arg32->buf); 648 arg64.buf = compat_ptr(cp); 649 err |= copy_to_user(p, &arg64, sizeof(arg64)); 650 651 if (err) 652 return -EFAULT; 653 654 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p); 655 if (err) 656 return err; 657 err |= 658 copy_in_user(&arg32->error_info, &p->error_info, 659 sizeof(arg32->error_info)); 660 if (err) 661 return -EFAULT; 662 return err; 663} 664#endif 665 666static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo) 667{ 668 drive_info_struct *drv = get_drv(bdev->bd_disk); 669 670 if (!drv->cylinders) 671 return -ENXIO; 672 673 geo->heads = drv->heads; 674 geo->sectors = drv->sectors; 675 geo->cylinders = drv->cylinders; 676 return 0; 677} 678 679/* 680 * ioctl 681 */ 682static int cciss_ioctl(struct inode *inode, struct file *filep, 683 unsigned int cmd, unsigned long arg) 684{ 685 struct block_device *bdev = inode->i_bdev; 686 struct gendisk *disk = bdev->bd_disk; 687 ctlr_info_t *host = get_host(disk); 688 drive_info_struct *drv = get_drv(disk); 689 int ctlr = host->ctlr; 690 void __user *argp = (void __user *)arg; 691 692#ifdef CCISS_DEBUG 693 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg); 694#endif /* CCISS_DEBUG */ 695 696 switch (cmd) { 697 case CCISS_GETPCIINFO: 698 { 699 cciss_pci_info_struct pciinfo; 700 701 if (!arg) 702 return -EINVAL; 703 pciinfo.domain = pci_domain_nr(host->pdev->bus); 704 pciinfo.bus = host->pdev->bus->number; 705 pciinfo.dev_fn = host->pdev->devfn; 706 pciinfo.board_id = host->board_id; 707 if (copy_to_user 708 (argp, &pciinfo, sizeof(cciss_pci_info_struct))) 709 return -EFAULT; 710 return 0; 711 } 712 case CCISS_GETINTINFO: 713 { 714 cciss_coalint_struct intinfo; 715 if (!arg) 716 return -EINVAL; 717 intinfo.delay = 718 readl(&host->cfgtable->HostWrite.CoalIntDelay); 719 intinfo.count = 720 readl(&host->cfgtable->HostWrite.CoalIntCount); 721 if (copy_to_user 722 (argp, &intinfo, sizeof(cciss_coalint_struct))) 723 return -EFAULT; 724 return 0; 725 } 726 case CCISS_SETINTINFO: 727 { 728 cciss_coalint_struct intinfo; 729 unsigned long flags; 730 int i; 731 732 if (!arg) 733 return -EINVAL; 734 if (!capable(CAP_SYS_ADMIN)) 735 return -EPERM; 736 if (copy_from_user 737 (&intinfo, argp, sizeof(cciss_coalint_struct))) 738 return -EFAULT; 739 if ((intinfo.delay == 0) && (intinfo.count == 0)) 740 { 741// printk("cciss_ioctl: delay and count cannot be 0\n"); 742 return -EINVAL; 743 } 744 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 745 /* Update the field, and then ring the doorbell */ 746 writel(intinfo.delay, 747 &(host->cfgtable->HostWrite.CoalIntDelay)); 748 writel(intinfo.count, 749 &(host->cfgtable->HostWrite.CoalIntCount)); 750 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL); 751 752 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) { 753 if (!(readl(host->vaddr + SA5_DOORBELL) 754 & CFGTBL_ChangeReq)) 755 break; 756 /* delay and try again */ 757 udelay(1000); 758 } 759 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 760 if (i >= MAX_IOCTL_CONFIG_WAIT) 761 return -EAGAIN; 762 return 0; 763 } 764 case CCISS_GETNODENAME: 765 { 766 NodeName_type NodeName; 767 int i; 768 769 if (!arg) 770 return -EINVAL; 771 for (i = 0; i < 16; i++) 772 NodeName[i] = 773 readb(&host->cfgtable->ServerName[i]); 774 if (copy_to_user(argp, NodeName, sizeof(NodeName_type))) 775 return -EFAULT; 776 return 0; 777 } 778 case CCISS_SETNODENAME: 779 { 780 NodeName_type NodeName; 781 unsigned long flags; 782 int i; 783 784 if (!arg) 785 return -EINVAL; 786 if (!capable(CAP_SYS_ADMIN)) 787 return -EPERM; 788 789 if (copy_from_user 790 (NodeName, argp, sizeof(NodeName_type))) 791 return -EFAULT; 792 793 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 794 795 /* Update the field, and then ring the doorbell */ 796 for (i = 0; i < 16; i++) 797 writeb(NodeName[i], 798 &host->cfgtable->ServerName[i]); 799 800 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL); 801 802 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) { 803 if (!(readl(host->vaddr + SA5_DOORBELL) 804 & CFGTBL_ChangeReq)) 805 break; 806 /* delay and try again */ 807 udelay(1000); 808 } 809 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 810 if (i >= MAX_IOCTL_CONFIG_WAIT) 811 return -EAGAIN; 812 return 0; 813 } 814 815 case CCISS_GETHEARTBEAT: 816 { 817 Heartbeat_type heartbeat; 818 819 if (!arg) 820 return -EINVAL; 821 heartbeat = readl(&host->cfgtable->HeartBeat); 822 if (copy_to_user 823 (argp, &heartbeat, sizeof(Heartbeat_type))) 824 return -EFAULT; 825 return 0; 826 } 827 case CCISS_GETBUSTYPES: 828 { 829 BusTypes_type BusTypes; 830 831 if (!arg) 832 return -EINVAL; 833 BusTypes = readl(&host->cfgtable->BusTypes); 834 if (copy_to_user 835 (argp, &BusTypes, sizeof(BusTypes_type))) 836 return -EFAULT; 837 return 0; 838 } 839 case CCISS_GETFIRMVER: 840 { 841 FirmwareVer_type firmware; 842 843 if (!arg) 844 return -EINVAL; 845 memcpy(firmware, host->firm_ver, 4); 846 847 if (copy_to_user 848 (argp, firmware, sizeof(FirmwareVer_type))) 849 return -EFAULT; 850 return 0; 851 } 852 case CCISS_GETDRIVVER: 853 { 854 DriverVer_type DriverVer = DRIVER_VERSION; 855 856 if (!arg) 857 return -EINVAL; 858 859 if (copy_to_user 860 (argp, &DriverVer, sizeof(DriverVer_type))) 861 return -EFAULT; 862 return 0; 863 } 864 865 case CCISS_REVALIDVOLS: 866 return rebuild_lun_table(host, NULL); 867 868 case CCISS_GETLUNINFO:{ 869 LogvolInfo_struct luninfo; 870 871 luninfo.LunID = drv->LunID; 872 luninfo.num_opens = drv->usage_count; 873 luninfo.num_parts = 0; 874 if (copy_to_user(argp, &luninfo, 875 sizeof(LogvolInfo_struct))) 876 return -EFAULT; 877 return 0; 878 } 879 case CCISS_DEREGDISK: 880 return rebuild_lun_table(host, disk); 881 882 case CCISS_REGNEWD: 883 return rebuild_lun_table(host, NULL); 884 885 case CCISS_PASSTHRU: 886 { 887 IOCTL_Command_struct iocommand; 888 CommandList_struct *c; 889 char *buff = NULL; 890 u64bit temp64; 891 unsigned long flags; 892 DECLARE_COMPLETION_ONSTACK(wait); 893 894 if (!arg) 895 return -EINVAL; 896 897 if (!capable(CAP_SYS_RAWIO)) 898 return -EPERM; 899 900 if (copy_from_user 901 (&iocommand, argp, sizeof(IOCTL_Command_struct))) 902 return -EFAULT; 903 if ((iocommand.buf_size < 1) && 904 (iocommand.Request.Type.Direction != XFER_NONE)) { 905 return -EINVAL; 906 } 907#if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */ 908 /* Check kmalloc limits */ 909 if (iocommand.buf_size > 128000) 910 return -EINVAL; 911#endif 912 if (iocommand.buf_size > 0) { 913 buff = kmalloc(iocommand.buf_size, GFP_KERNEL); 914 if (buff == NULL) 915 return -EFAULT; 916 } 917 if (iocommand.Request.Type.Direction == XFER_WRITE) { 918 /* Copy the data into the buffer we created */ 919 if (copy_from_user 920 (buff, iocommand.buf, iocommand.buf_size)) { 921 kfree(buff); 922 return -EFAULT; 923 } 924 } else { 925 memset(buff, 0, iocommand.buf_size); 926 } 927 if ((c = cmd_alloc(host, 0)) == NULL) { 928 kfree(buff); 929 return -ENOMEM; 930 } 931 // Fill in the command type 932 c->cmd_type = CMD_IOCTL_PEND; 933 // Fill in Command Header 934 c->Header.ReplyQueue = 0; // unused in simple mode 935 if (iocommand.buf_size > 0) // buffer to fill 936 { 937 c->Header.SGList = 1; 938 c->Header.SGTotal = 1; 939 } else // no buffers to fill 940 { 941 c->Header.SGList = 0; 942 c->Header.SGTotal = 0; 943 } 944 c->Header.LUN = iocommand.LUN_info; 945 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag 946 947 // Fill in Request block 948 c->Request = iocommand.Request; 949 950 // Fill in the scatter gather information 951 if (iocommand.buf_size > 0) { 952 temp64.val = pci_map_single(host->pdev, buff, 953 iocommand.buf_size, 954 PCI_DMA_BIDIRECTIONAL); 955 c->SG[0].Addr.lower = temp64.val32.lower; 956 c->SG[0].Addr.upper = temp64.val32.upper; 957 c->SG[0].Len = iocommand.buf_size; 958 c->SG[0].Ext = 0; // we are not chaining 959 } 960 c->waiting = &wait; 961 962 /* Put the request on the tail of the request queue */ 963 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 964 addQ(&host->reqQ, c); 965 host->Qdepth++; 966 start_io(host); 967 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 968 969 wait_for_completion(&wait); 970 971 /* unlock the buffers from DMA */ 972 temp64.val32.lower = c->SG[0].Addr.lower; 973 temp64.val32.upper = c->SG[0].Addr.upper; 974 pci_unmap_single(host->pdev, (dma_addr_t) temp64.val, 975 iocommand.buf_size, 976 PCI_DMA_BIDIRECTIONAL); 977 978 /* Copy the error information out */ 979 iocommand.error_info = *(c->err_info); 980 if (copy_to_user 981 (argp, &iocommand, sizeof(IOCTL_Command_struct))) { 982 kfree(buff); 983 cmd_free(host, c, 0); 984 return -EFAULT; 985 } 986 987 if (iocommand.Request.Type.Direction == XFER_READ) { 988 /* Copy the data out of the buffer we created */ 989 if (copy_to_user 990 (iocommand.buf, buff, iocommand.buf_size)) { 991 kfree(buff); 992 cmd_free(host, c, 0); 993 return -EFAULT; 994 } 995 } 996 kfree(buff); 997 cmd_free(host, c, 0); 998 return 0; 999 } 1000 case CCISS_BIG_PASSTHRU:{ 1001 BIG_IOCTL_Command_struct *ioc; 1002 CommandList_struct *c; 1003 unsigned char **buff = NULL; 1004 int *buff_size = NULL; 1005 u64bit temp64; 1006 unsigned long flags; 1007 BYTE sg_used = 0; 1008 int status = 0; 1009 int i; 1010 DECLARE_COMPLETION_ONSTACK(wait); 1011 __u32 left; 1012 __u32 sz; 1013 BYTE __user *data_ptr; 1014 1015 if (!arg) 1016 return -EINVAL; 1017 if (!capable(CAP_SYS_RAWIO)) 1018 return -EPERM; 1019 ioc = (BIG_IOCTL_Command_struct *) 1020 kmalloc(sizeof(*ioc), GFP_KERNEL); 1021 if (!ioc) { 1022 status = -ENOMEM; 1023 goto cleanup1; 1024 } 1025 if (copy_from_user(ioc, argp, sizeof(*ioc))) { 1026 status = -EFAULT; 1027 goto cleanup1; 1028 } 1029 if ((ioc->buf_size < 1) && 1030 (ioc->Request.Type.Direction != XFER_NONE)) { 1031 status = -EINVAL; 1032 goto cleanup1; 1033 } 1034 /* Check kmalloc limits using all SGs */ 1035 if (ioc->malloc_size > MAX_KMALLOC_SIZE) { 1036 status = -EINVAL; 1037 goto cleanup1; 1038 } 1039 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) { 1040 status = -EINVAL; 1041 goto cleanup1; 1042 } 1043 buff = 1044 kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL); 1045 if (!buff) { 1046 status = -ENOMEM; 1047 goto cleanup1; 1048 } 1049 buff_size = kmalloc(MAXSGENTRIES * sizeof(int), 1050 GFP_KERNEL); 1051 if (!buff_size) { 1052 status = -ENOMEM; 1053 goto cleanup1; 1054 } 1055 left = ioc->buf_size; 1056 data_ptr = ioc->buf; 1057 while (left) { 1058 sz = (left > 1059 ioc->malloc_size) ? ioc-> 1060 malloc_size : left; 1061 buff_size[sg_used] = sz; 1062 buff[sg_used] = kmalloc(sz, GFP_KERNEL); 1063 if (buff[sg_used] == NULL) { 1064 status = -ENOMEM; 1065 goto cleanup1; 1066 } 1067 if (ioc->Request.Type.Direction == XFER_WRITE) { 1068 if (copy_from_user 1069 (buff[sg_used], data_ptr, sz)) { 1070 status = -ENOMEM; 1071 goto cleanup1; 1072 } 1073 } else { 1074 memset(buff[sg_used], 0, sz); 1075 } 1076 left -= sz; 1077 data_ptr += sz; 1078 sg_used++; 1079 } 1080 if ((c = cmd_alloc(host, 0)) == NULL) { 1081 status = -ENOMEM; 1082 goto cleanup1; 1083 } 1084 c->cmd_type = CMD_IOCTL_PEND; 1085 c->Header.ReplyQueue = 0; 1086 1087 if (ioc->buf_size > 0) { 1088 c->Header.SGList = sg_used; 1089 c->Header.SGTotal = sg_used; 1090 } else { 1091 c->Header.SGList = 0; 1092 c->Header.SGTotal = 0; 1093 } 1094 c->Header.LUN = ioc->LUN_info; 1095 c->Header.Tag.lower = c->busaddr; 1096 1097 c->Request = ioc->Request; 1098 if (ioc->buf_size > 0) { 1099 int i; 1100 for (i = 0; i < sg_used; i++) { 1101 temp64.val = 1102 pci_map_single(host->pdev, buff[i], 1103 buff_size[i], 1104 PCI_DMA_BIDIRECTIONAL); 1105 c->SG[i].Addr.lower = 1106 temp64.val32.lower; 1107 c->SG[i].Addr.upper = 1108 temp64.val32.upper; 1109 c->SG[i].Len = buff_size[i]; 1110 c->SG[i].Ext = 0; /* we are not chaining */ 1111 } 1112 } 1113 c->waiting = &wait; 1114 /* Put the request on the tail of the request queue */ 1115 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1116 addQ(&host->reqQ, c); 1117 host->Qdepth++; 1118 start_io(host); 1119 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1120 wait_for_completion(&wait); 1121 /* unlock the buffers from DMA */ 1122 for (i = 0; i < sg_used; i++) { 1123 temp64.val32.lower = c->SG[i].Addr.lower; 1124 temp64.val32.upper = c->SG[i].Addr.upper; 1125 pci_unmap_single(host->pdev, 1126 (dma_addr_t) temp64.val, buff_size[i], 1127 PCI_DMA_BIDIRECTIONAL); 1128 } 1129 /* Copy the error information out */ 1130 ioc->error_info = *(c->err_info); 1131 if (copy_to_user(argp, ioc, sizeof(*ioc))) { 1132 cmd_free(host, c, 0); 1133 status = -EFAULT; 1134 goto cleanup1; 1135 } 1136 if (ioc->Request.Type.Direction == XFER_READ) { 1137 /* Copy the data out of the buffer we created */ 1138 BYTE __user *ptr = ioc->buf; 1139 for (i = 0; i < sg_used; i++) { 1140 if (copy_to_user 1141 (ptr, buff[i], buff_size[i])) { 1142 cmd_free(host, c, 0); 1143 status = -EFAULT; 1144 goto cleanup1; 1145 } 1146 ptr += buff_size[i]; 1147 } 1148 } 1149 cmd_free(host, c, 0); 1150 status = 0; 1151 cleanup1: 1152 if (buff) { 1153 for (i = 0; i < sg_used; i++) 1154 kfree(buff[i]); 1155 kfree(buff); 1156 } 1157 kfree(buff_size); 1158 kfree(ioc); 1159 return status; 1160 } 1161 1162 /* scsi_cmd_ioctl handles these, below, though some are not */ 1163 /* very meaningful for cciss. SG_IO is the main one people want. */ 1164 1165 case SG_GET_VERSION_NUM: 1166 case SG_SET_TIMEOUT: 1167 case SG_GET_TIMEOUT: 1168 case SG_GET_RESERVED_SIZE: 1169 case SG_SET_RESERVED_SIZE: 1170 case SG_EMULATED_HOST: 1171 case SG_IO: 1172 case SCSI_IOCTL_SEND_COMMAND: 1173 return scsi_cmd_ioctl(filep, disk->queue, disk, cmd, argp); 1174 1175 /* scsi_cmd_ioctl would normally handle these, below, but */ 1176 /* they aren't a good fit for cciss, as CD-ROMs are */ 1177 /* not supported, and we don't have any bus/target/lun */ 1178 /* which we present to the kernel. */ 1179 1180 case CDROM_SEND_PACKET: 1181 case CDROMCLOSETRAY: 1182 case CDROMEJECT: 1183 case SCSI_IOCTL_GET_IDLUN: 1184 case SCSI_IOCTL_GET_BUS_NUMBER: 1185 default: 1186 return -ENOTTY; 1187 } 1188} 1189 1190static inline void complete_buffers(struct bio *bio, int status) 1191{ 1192 while (bio) { 1193 struct bio *xbh = bio->bi_next; 1194 1195 bio->bi_next = NULL; 1196 bio_endio(bio, status ? 0 : -EIO); 1197 bio = xbh; 1198 } 1199} 1200 1201static void cciss_check_queues(ctlr_info_t *h) 1202{ 1203 int start_queue = h->next_to_run; 1204 int i; 1205 1206 /* check to see if we have maxed out the number of commands that can 1207 * be placed on the queue. If so then exit. We do this check here 1208 * in case the interrupt we serviced was from an ioctl and did not 1209 * free any new commands. 1210 */ 1211 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) 1212 return; 1213 1214 /* We have room on the queue for more commands. Now we need to queue 1215 * them up. We will also keep track of the next queue to run so 1216 * that every queue gets a chance to be started first. 1217 */ 1218 for (i = 0; i < h->highest_lun + 1; i++) { 1219 int curr_queue = (start_queue + i) % (h->highest_lun + 1); 1220 /* make sure the disk has been added and the drive is real 1221 * because this can be called from the middle of init_one. 1222 */ 1223 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads)) 1224 continue; 1225 blk_start_queue(h->gendisk[curr_queue]->queue); 1226 1227 /* check to see if we have maxed out the number of commands 1228 * that can be placed on the queue. 1229 */ 1230 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) { 1231 if (curr_queue == start_queue) { 1232 h->next_to_run = 1233 (start_queue + 1) % (h->highest_lun + 1); 1234 break; 1235 } else { 1236 h->next_to_run = curr_queue; 1237 break; 1238 } 1239 } else { 1240 curr_queue = (curr_queue + 1) % (h->highest_lun + 1); 1241 } 1242 } 1243} 1244 1245static void cciss_softirq_done(struct request *rq) 1246{ 1247 CommandList_struct *cmd = rq->completion_data; 1248 ctlr_info_t *h = hba[cmd->ctlr]; 1249 unsigned long flags; 1250 u64bit temp64; 1251 int i, ddir; 1252 1253 if (cmd->Request.Type.Direction == XFER_READ) 1254 ddir = PCI_DMA_FROMDEVICE; 1255 else 1256 ddir = PCI_DMA_TODEVICE; 1257 1258 /* command did not need to be retried */ 1259 /* unmap the DMA mapping for all the scatter gather elements */ 1260 for (i = 0; i < cmd->Header.SGList; i++) { 1261 temp64.val32.lower = cmd->SG[i].Addr.lower; 1262 temp64.val32.upper = cmd->SG[i].Addr.upper; 1263 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir); 1264 } 1265 1266 complete_buffers(rq->bio, (rq->errors == 0)); 1267 1268 if (blk_fs_request(rq)) { 1269 const int rw = rq_data_dir(rq); 1270 1271 disk_stat_add(rq->rq_disk, sectors[rw], rq->nr_sectors); 1272 } 1273 1274#ifdef CCISS_DEBUG 1275 printk("Done with %p\n", rq); 1276#endif /* CCISS_DEBUG */ 1277 1278 add_disk_randomness(rq->rq_disk); 1279 spin_lock_irqsave(&h->lock, flags); 1280 end_that_request_last(rq, (rq->errors == 0)); 1281 cmd_free(h, cmd, 1); 1282 cciss_check_queues(h); 1283 spin_unlock_irqrestore(&h->lock, flags); 1284} 1285 1286/* This function will check the usage_count of the drive to be updated/added. 1287 * If the usage_count is zero then the drive information will be updated and 1288 * the disk will be re-registered with the kernel. If not then it will be 1289 * left alone for the next reboot. The exception to this is disk 0 which 1290 * will always be left registered with the kernel since it is also the 1291 * controller node. Any changes to disk 0 will show up on the next 1292 * reboot. 1293 */ 1294static void cciss_update_drive_info(int ctlr, int drv_index) 1295{ 1296 ctlr_info_t *h = hba[ctlr]; 1297 struct gendisk *disk; 1298 InquiryData_struct *inq_buff = NULL; 1299 unsigned int block_size; 1300 sector_t total_size; 1301 unsigned long flags = 0; 1302 int ret = 0; 1303 1304 /* if the disk already exists then deregister it before proceeding */ 1305 if (h->drv[drv_index].raid_level != -1) { 1306 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 1307 h->drv[drv_index].busy_configuring = 1; 1308 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 1309 ret = deregister_disk(h->gendisk[drv_index], 1310 &h->drv[drv_index], 0); 1311 h->drv[drv_index].busy_configuring = 0; 1312 } 1313 1314 /* If the disk is in use return */ 1315 if (ret) 1316 return; 1317 1318 /* Get information about the disk and modify the driver structure */ 1319 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); 1320 if (inq_buff == NULL) 1321 goto mem_msg; 1322 1323 /* testing to see if 16-byte CDBs are already being used */ 1324 if (h->cciss_read == CCISS_READ_16) { 1325 cciss_read_capacity_16(h->ctlr, drv_index, 1, 1326 &total_size, &block_size); 1327 goto geo_inq; 1328 } 1329 1330 cciss_read_capacity(ctlr, drv_index, 1, 1331 &total_size, &block_size); 1332 1333 /* if read_capacity returns all F's this volume is >2TB in size */ 1334 /* so we switch to 16-byte CDB's for all read/write ops */ 1335 if (total_size == 0xFFFFFFFFULL) { 1336 cciss_read_capacity_16(ctlr, drv_index, 1, 1337 &total_size, &block_size); 1338 h->cciss_read = CCISS_READ_16; 1339 h->cciss_write = CCISS_WRITE_16; 1340 } else { 1341 h->cciss_read = CCISS_READ_10; 1342 h->cciss_write = CCISS_WRITE_10; 1343 } 1344geo_inq: 1345 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size, 1346 inq_buff, &h->drv[drv_index]); 1347 1348 ++h->num_luns; 1349 disk = h->gendisk[drv_index]; 1350 set_capacity(disk, h->drv[drv_index].nr_blocks); 1351 1352 /* if it's the controller it's already added */ 1353 if (drv_index) { 1354 disk->queue = blk_init_queue(do_cciss_request, &h->lock); 1355 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index); 1356 disk->major = h->major; 1357 disk->first_minor = drv_index << NWD_SHIFT; 1358 disk->fops = &cciss_fops; 1359 disk->private_data = &h->drv[drv_index]; 1360 1361 /* Set up queue information */ 1362 disk->queue->backing_dev_info.ra_pages = READ_AHEAD; 1363 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask); 1364 1365 /* This is a hardware imposed limit. */ 1366 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES); 1367 1368 /* This is a limit in the driver and could be eliminated. */ 1369 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES); 1370 1371 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors); 1372 1373 blk_queue_softirq_done(disk->queue, cciss_softirq_done); 1374 1375 disk->queue->queuedata = hba[ctlr]; 1376 1377 blk_queue_hardsect_size(disk->queue, 1378 hba[ctlr]->drv[drv_index].block_size); 1379 1380 h->drv[drv_index].queue = disk->queue; 1381 add_disk(disk); 1382 } 1383 1384 freeret: 1385 kfree(inq_buff); 1386 return; 1387 mem_msg: 1388 printk(KERN_ERR "cciss: out of memory\n"); 1389 goto freeret; 1390} 1391 1392/* This function will find the first index of the controllers drive array 1393 * that has a -1 for the raid_level and will return that index. This is 1394 * where new drives will be added. If the index to be returned is greater 1395 * than the highest_lun index for the controller then highest_lun is set 1396 * to this new index. If there are no available indexes then -1 is returned. 1397 */ 1398static int cciss_find_free_drive_index(int ctlr) 1399{ 1400 int i; 1401 1402 for (i = 0; i < CISS_MAX_LUN; i++) { 1403 if (hba[ctlr]->drv[i].raid_level == -1) { 1404 if (i > hba[ctlr]->highest_lun) 1405 hba[ctlr]->highest_lun = i; 1406 return i; 1407 } 1408 } 1409 return -1; 1410} 1411 1412/* This function will add and remove logical drives from the Logical 1413 * drive array of the controller and maintain persistency of ordering 1414 * so that mount points are preserved until the next reboot. This allows 1415 * for the removal of logical drives in the middle of the drive array 1416 * without a re-ordering of those drives. 1417 * INPUT 1418 * h = The controller to perform the operations on 1419 * del_disk = The disk to remove if specified. If the value given 1420 * is NULL then no disk is removed. 1421 */ 1422static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk) 1423{ 1424 int ctlr = h->ctlr; 1425 int num_luns; 1426 ReportLunData_struct *ld_buff = NULL; 1427 drive_info_struct *drv = NULL; 1428 int return_code; 1429 int listlength = 0; 1430 int i; 1431 int drv_found; 1432 int drv_index = 0; 1433 __u32 lunid = 0; 1434 unsigned long flags; 1435 1436 /* Set busy_configuring flag for this operation */ 1437 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 1438 if (h->busy_configuring) { 1439 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 1440 return -EBUSY; 1441 } 1442 h->busy_configuring = 1; 1443 1444 /* if del_disk is NULL then we are being called to add a new disk 1445 * and update the logical drive table. If it is not NULL then 1446 * we will check if the disk is in use or not. 1447 */ 1448 if (del_disk != NULL) { 1449 drv = get_drv(del_disk); 1450 drv->busy_configuring = 1; 1451 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 1452 return_code = deregister_disk(del_disk, drv, 1); 1453 drv->busy_configuring = 0; 1454 h->busy_configuring = 0; 1455 return return_code; 1456 } else { 1457 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 1458 if (!capable(CAP_SYS_RAWIO)) 1459 return -EPERM; 1460 1461 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL); 1462 if (ld_buff == NULL) 1463 goto mem_msg; 1464 1465 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff, 1466 sizeof(ReportLunData_struct), 0, 1467 0, 0, TYPE_CMD); 1468 1469 if (return_code == IO_OK) { 1470 listlength = 1471 be32_to_cpu(*(__be32 *) ld_buff->LUNListLength); 1472 } else { /* reading number of logical volumes failed */ 1473 printk(KERN_WARNING "cciss: report logical volume" 1474 " command failed\n"); 1475 listlength = 0; 1476 goto freeret; 1477 } 1478 1479 num_luns = listlength / 8; /* 8 bytes per entry */ 1480 if (num_luns > CISS_MAX_LUN) { 1481 num_luns = CISS_MAX_LUN; 1482 printk(KERN_WARNING "cciss: more luns configured" 1483 " on controller than can be handled by" 1484 " this driver.\n"); 1485 } 1486 1487 /* Compare controller drive array to drivers drive array. 1488 * Check for updates in the drive information and any new drives 1489 * on the controller. 1490 */ 1491 for (i = 0; i < num_luns; i++) { 1492 int j; 1493 1494 drv_found = 0; 1495 1496 lunid = (0xff & 1497 (unsigned int)(ld_buff->LUN[i][3])) << 24; 1498 lunid |= (0xff & 1499 (unsigned int)(ld_buff->LUN[i][2])) << 16; 1500 lunid |= (0xff & 1501 (unsigned int)(ld_buff->LUN[i][1])) << 8; 1502 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]); 1503 1504 /* Find if the LUN is already in the drive array 1505 * of the controller. If so then update its info 1506 * if not is use. If it does not exist then find 1507 * the first free index and add it. 1508 */ 1509 for (j = 0; j <= h->highest_lun; j++) { 1510 if (h->drv[j].LunID == lunid) { 1511 drv_index = j; 1512 drv_found = 1; 1513 } 1514 } 1515 1516 /* check if the drive was found already in the array */ 1517 if (!drv_found) { 1518 drv_index = cciss_find_free_drive_index(ctlr); 1519 if (drv_index == -1) 1520 goto freeret; 1521 1522 /*Check if the gendisk needs to be allocated */ 1523 if (!h->gendisk[drv_index]){ 1524 h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT); 1525 if (!h->gendisk[drv_index]){ 1526 printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index); 1527 goto mem_msg; 1528 } 1529 } 1530 } 1531 h->drv[drv_index].LunID = lunid; 1532 cciss_update_drive_info(ctlr, drv_index); 1533 } /* end for */ 1534 } /* end else */ 1535 1536 freeret: 1537 kfree(ld_buff); 1538 h->busy_configuring = 0; 1539 /* We return -1 here to tell the ACU that we have registered/updated 1540 * all of the drives that we can and to keep it from calling us 1541 * additional times. 1542 */ 1543 return -1; 1544 mem_msg: 1545 printk(KERN_ERR "cciss: out of memory\n"); 1546 goto freeret; 1547} 1548 1549/* This function will deregister the disk and it's queue from the 1550 * kernel. It must be called with the controller lock held and the 1551 * drv structures busy_configuring flag set. It's parameters are: 1552 * 1553 * disk = This is the disk to be deregistered 1554 * drv = This is the drive_info_struct associated with the disk to be 1555 * deregistered. It contains information about the disk used 1556 * by the driver. 1557 * clear_all = This flag determines whether or not the disk information 1558 * is going to be completely cleared out and the highest_lun 1559 * reset. Sometimes we want to clear out information about 1560 * the disk in preparation for re-adding it. In this case 1561 * the highest_lun should be left unchanged and the LunID 1562 * should not be cleared. 1563*/ 1564static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, 1565 int clear_all) 1566{ 1567 int i; 1568 ctlr_info_t *h = get_host(disk); 1569 1570 if (!capable(CAP_SYS_RAWIO)) 1571 return -EPERM; 1572 1573 /* make sure logical volume is NOT is use */ 1574 if (clear_all || (h->gendisk[0] == disk)) { 1575 if (drv->usage_count > 1) 1576 return -EBUSY; 1577 } else if (drv->usage_count > 0) 1578 return -EBUSY; 1579 1580 /* invalidate the devices and deregister the disk. If it is disk 1581 * zero do not deregister it but just zero out it's values. This 1582 * allows us to delete disk zero but keep the controller registered. 1583 */ 1584 if (h->gendisk[0] != disk) { 1585 struct request_queue *q = disk->queue; 1586 if (disk->flags & GENHD_FL_UP) 1587 del_gendisk(disk); 1588 if (q) { 1589 blk_cleanup_queue(q); 1590 /* Set drv->queue to NULL so that we do not try 1591 * to call blk_start_queue on this queue in the 1592 * interrupt handler 1593 */ 1594 drv->queue = NULL; 1595 } 1596 /* If clear_all is set then we are deleting the logical 1597 * drive, not just refreshing its info. For drives 1598 * other than disk 0 we will call put_disk. We do not 1599 * do this for disk 0 as we need it to be able to 1600 * configure the controller. 1601 */ 1602 if (clear_all){ 1603 /* This isn't pretty, but we need to find the 1604 * disk in our array and NULL our the pointer. 1605 * This is so that we will call alloc_disk if 1606 * this index is used again later. 1607 */ 1608 for (i=0; i < CISS_MAX_LUN; i++){ 1609 if(h->gendisk[i] == disk){ 1610 h->gendisk[i] = NULL; 1611 break; 1612 } 1613 } 1614 put_disk(disk); 1615 } 1616 } else { 1617 set_capacity(disk, 0); 1618 } 1619 1620 --h->num_luns; 1621 /* zero out the disk size info */ 1622 drv->nr_blocks = 0; 1623 drv->block_size = 0; 1624 drv->heads = 0; 1625 drv->sectors = 0; 1626 drv->cylinders = 0; 1627 drv->raid_level = -1; /* This can be used as a flag variable to 1628 * indicate that this element of the drive 1629 * array is free. 1630 */ 1631 1632 if (clear_all) { 1633 /* check to see if it was the last disk */ 1634 if (drv == h->drv + h->highest_lun) { 1635 /* if so, find the new hightest lun */ 1636 int i, newhighest = -1; 1637 for (i = 0; i < h->highest_lun; i++) { 1638 /* if the disk has size > 0, it is available */ 1639 if (h->drv[i].heads) 1640 newhighest = i; 1641 } 1642 h->highest_lun = newhighest; 1643 } 1644 1645 drv->LunID = 0; 1646 } 1647 return 0; 1648} 1649 1650static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller, 1651 1: address logical volume log_unit, 1652 2: periph device address is scsi3addr */ 1653 unsigned int log_unit, __u8 page_code, 1654 unsigned char *scsi3addr, int cmd_type) 1655{ 1656 ctlr_info_t *h = hba[ctlr]; 1657 u64bit buff_dma_handle; 1658 int status = IO_OK; 1659 1660 c->cmd_type = CMD_IOCTL_PEND; 1661 c->Header.ReplyQueue = 0; 1662 if (buff != NULL) { 1663 c->Header.SGList = 1; 1664 c->Header.SGTotal = 1; 1665 } else { 1666 c->Header.SGList = 0; 1667 c->Header.SGTotal = 0; 1668 } 1669 c->Header.Tag.lower = c->busaddr; 1670 1671 c->Request.Type.Type = cmd_type; 1672 if (cmd_type == TYPE_CMD) { 1673 switch (cmd) { 1674 case CISS_INQUIRY: 1675 /* If the logical unit number is 0 then, this is going 1676 to controller so It's a physical command 1677 mode = 0 target = 0. So we have nothing to write. 1678 otherwise, if use_unit_num == 1, 1679 mode = 1(volume set addressing) target = LUNID 1680 otherwise, if use_unit_num == 2, 1681 mode = 0(periph dev addr) target = scsi3addr */ 1682 if (use_unit_num == 1) { 1683 c->Header.LUN.LogDev.VolId = 1684 h->drv[log_unit].LunID; 1685 c->Header.LUN.LogDev.Mode = 1; 1686 } else if (use_unit_num == 2) { 1687 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 1688 8); 1689 c->Header.LUN.LogDev.Mode = 0; 1690 } 1691 /* are we trying to read a vital product page */ 1692 if (page_code != 0) { 1693 c->Request.CDB[1] = 0x01; 1694 c->Request.CDB[2] = page_code; 1695 } 1696 c->Request.CDBLen = 6; 1697 c->Request.Type.Attribute = ATTR_SIMPLE; 1698 c->Request.Type.Direction = XFER_READ; 1699 c->Request.Timeout = 0; 1700 c->Request.CDB[0] = CISS_INQUIRY; 1701 c->Request.CDB[4] = size & 0xFF; 1702 break; 1703 case CISS_REPORT_LOG: 1704 case CISS_REPORT_PHYS: 1705 /* Talking to controller so It's a physical command 1706 mode = 00 target = 0. Nothing to write. 1707 */ 1708 c->Request.CDBLen = 12; 1709 c->Request.Type.Attribute = ATTR_SIMPLE; 1710 c->Request.Type.Direction = XFER_READ; 1711 c->Request.Timeout = 0; 1712 c->Request.CDB[0] = cmd; 1713 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB 1714 c->Request.CDB[7] = (size >> 16) & 0xFF; 1715 c->Request.CDB[8] = (size >> 8) & 0xFF; 1716 c->Request.CDB[9] = size & 0xFF; 1717 break; 1718 1719 case CCISS_READ_CAPACITY: 1720 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID; 1721 c->Header.LUN.LogDev.Mode = 1; 1722 c->Request.CDBLen = 10; 1723 c->Request.Type.Attribute = ATTR_SIMPLE; 1724 c->Request.Type.Direction = XFER_READ; 1725 c->Request.Timeout = 0; 1726 c->Request.CDB[0] = cmd; 1727 break; 1728 case CCISS_READ_CAPACITY_16: 1729 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID; 1730 c->Header.LUN.LogDev.Mode = 1; 1731 c->Request.CDBLen = 16; 1732 c->Request.Type.Attribute = ATTR_SIMPLE; 1733 c->Request.Type.Direction = XFER_READ; 1734 c->Request.Timeout = 0; 1735 c->Request.CDB[0] = cmd; 1736 c->Request.CDB[1] = 0x10; 1737 c->Request.CDB[10] = (size >> 24) & 0xFF; 1738 c->Request.CDB[11] = (size >> 16) & 0xFF; 1739 c->Request.CDB[12] = (size >> 8) & 0xFF; 1740 c->Request.CDB[13] = size & 0xFF; 1741 c->Request.Timeout = 0; 1742 c->Request.CDB[0] = cmd; 1743 break; 1744 case CCISS_CACHE_FLUSH: 1745 c->Request.CDBLen = 12; 1746 c->Request.Type.Attribute = ATTR_SIMPLE; 1747 c->Request.Type.Direction = XFER_WRITE; 1748 c->Request.Timeout = 0; 1749 c->Request.CDB[0] = BMIC_WRITE; 1750 c->Request.CDB[6] = BMIC_CACHE_FLUSH; 1751 break; 1752 default: 1753 printk(KERN_WARNING 1754 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd); 1755 return IO_ERROR; 1756 } 1757 } else if (cmd_type == TYPE_MSG) { 1758 switch (cmd) { 1759 case 0: /* ABORT message */ 1760 c->Request.CDBLen = 12; 1761 c->Request.Type.Attribute = ATTR_SIMPLE; 1762 c->Request.Type.Direction = XFER_WRITE; 1763 c->Request.Timeout = 0; 1764 c->Request.CDB[0] = cmd; /* abort */ 1765 c->Request.CDB[1] = 0; /* abort a command */ 1766 /* buff contains the tag of the command to abort */ 1767 memcpy(&c->Request.CDB[4], buff, 8); 1768 break; 1769 case 1: /* RESET message */ 1770 c->Request.CDBLen = 12; 1771 c->Request.Type.Attribute = ATTR_SIMPLE; 1772 c->Request.Type.Direction = XFER_WRITE; 1773 c->Request.Timeout = 0; 1774 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB)); 1775 c->Request.CDB[0] = cmd; /* reset */ 1776 c->Request.CDB[1] = 0x04; /* reset a LUN */ 1777 break; 1778 case 3: /* No-Op message */ 1779 c->Request.CDBLen = 1; 1780 c->Request.Type.Attribute = ATTR_SIMPLE; 1781 c->Request.Type.Direction = XFER_WRITE; 1782 c->Request.Timeout = 0; 1783 c->Request.CDB[0] = cmd; 1784 break; 1785 default: 1786 printk(KERN_WARNING 1787 "cciss%d: unknown message type %d\n", ctlr, cmd); 1788 return IO_ERROR; 1789 } 1790 } else { 1791 printk(KERN_WARNING 1792 "cciss%d: unknown command type %d\n", ctlr, cmd_type); 1793 return IO_ERROR; 1794 } 1795 /* Fill in the scatter gather information */ 1796 if (size > 0) { 1797 buff_dma_handle.val = (__u64) pci_map_single(h->pdev, 1798 buff, size, 1799 PCI_DMA_BIDIRECTIONAL); 1800 c->SG[0].Addr.lower = buff_dma_handle.val32.lower; 1801 c->SG[0].Addr.upper = buff_dma_handle.val32.upper; 1802 c->SG[0].Len = size; 1803 c->SG[0].Ext = 0; /* we are not chaining */ 1804 } 1805 return status; 1806} 1807 1808static int sendcmd_withirq(__u8 cmd, 1809 int ctlr, 1810 void *buff, 1811 size_t size, 1812 unsigned int use_unit_num, 1813 unsigned int log_unit, __u8 page_code, int cmd_type) 1814{ 1815 ctlr_info_t *h = hba[ctlr]; 1816 CommandList_struct *c; 1817 u64bit buff_dma_handle; 1818 unsigned long flags; 1819 int return_status; 1820 DECLARE_COMPLETION_ONSTACK(wait); 1821 1822 if ((c = cmd_alloc(h, 0)) == NULL) 1823 return -ENOMEM; 1824 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num, 1825 log_unit, page_code, NULL, cmd_type); 1826 if (return_status != IO_OK) { 1827 cmd_free(h, c, 0); 1828 return return_status; 1829 } 1830 resend_cmd2: 1831 c->waiting = &wait; 1832 1833 /* Put the request on the tail of the queue and send it */ 1834 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 1835 addQ(&h->reqQ, c); 1836 h->Qdepth++; 1837 start_io(h); 1838 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 1839 1840 wait_for_completion(&wait); 1841 1842 if (c->err_info->CommandStatus != 0) { /* an error has occurred */ 1843 switch (c->err_info->CommandStatus) { 1844 case CMD_TARGET_STATUS: 1845 printk(KERN_WARNING "cciss: cmd %p has " 1846 " completed with errors\n", c); 1847 if (c->err_info->ScsiStatus) { 1848 printk(KERN_WARNING "cciss: cmd %p " 1849 "has SCSI Status = %x\n", 1850 c, c->err_info->ScsiStatus); 1851 } 1852 1853 break; 1854 case CMD_DATA_UNDERRUN: 1855 case CMD_DATA_OVERRUN: 1856 /* expected for inquire and report lun commands */ 1857 break; 1858 case CMD_INVALID: 1859 printk(KERN_WARNING "cciss: Cmd %p is " 1860 "reported invalid\n", c); 1861 return_status = IO_ERROR; 1862 break; 1863 case CMD_PROTOCOL_ERR: 1864 printk(KERN_WARNING "cciss: cmd %p has " 1865 "protocol error \n", c); 1866 return_status = IO_ERROR; 1867 break; 1868 case CMD_HARDWARE_ERR: 1869 printk(KERN_WARNING "cciss: cmd %p had " 1870 " hardware error\n", c); 1871 return_status = IO_ERROR; 1872 break; 1873 case CMD_CONNECTION_LOST: 1874 printk(KERN_WARNING "cciss: cmd %p had " 1875 "connection lost\n", c); 1876 return_status = IO_ERROR; 1877 break; 1878 case CMD_ABORTED: 1879 printk(KERN_WARNING "cciss: cmd %p was " 1880 "aborted\n", c); 1881 return_status = IO_ERROR; 1882 break; 1883 case CMD_ABORT_FAILED: 1884 printk(KERN_WARNING "cciss: cmd %p reports " 1885 "abort failed\n", c); 1886 return_status = IO_ERROR; 1887 break; 1888 case CMD_UNSOLICITED_ABORT: 1889 printk(KERN_WARNING 1890 "cciss%d: unsolicited abort %p\n", ctlr, c); 1891 if (c->retry_count < MAX_CMD_RETRIES) { 1892 printk(KERN_WARNING 1893 "cciss%d: retrying %p\n", ctlr, c); 1894 c->retry_count++; 1895 /* erase the old error information */ 1896 memset(c->err_info, 0, 1897 sizeof(ErrorInfo_struct)); 1898 return_status = IO_OK; 1899 INIT_COMPLETION(wait); 1900 goto resend_cmd2; 1901 } 1902 return_status = IO_ERROR; 1903 break; 1904 default: 1905 printk(KERN_WARNING "cciss: cmd %p returned " 1906 "unknown status %x\n", c, 1907 c->err_info->CommandStatus); 1908 return_status = IO_ERROR; 1909 } 1910 } 1911 /* unlock the buffers from DMA */ 1912 buff_dma_handle.val32.lower = c->SG[0].Addr.lower; 1913 buff_dma_handle.val32.upper = c->SG[0].Addr.upper; 1914 pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val, 1915 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL); 1916 cmd_free(h, c, 0); 1917 return return_status; 1918} 1919 1920static void cciss_geometry_inquiry(int ctlr, int logvol, 1921 int withirq, sector_t total_size, 1922 unsigned int block_size, 1923 InquiryData_struct *inq_buff, 1924 drive_info_struct *drv) 1925{ 1926 int return_code; 1927 unsigned long t; 1928 1929 memset(inq_buff, 0, sizeof(InquiryData_struct)); 1930 if (withirq) 1931 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr, 1932 inq_buff, sizeof(*inq_buff), 1, 1933 logvol, 0xC1, TYPE_CMD); 1934 else 1935 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff, 1936 sizeof(*inq_buff), 1, logvol, 0xC1, NULL, 1937 TYPE_CMD); 1938 if (return_code == IO_OK) { 1939 if (inq_buff->data_byte[8] == 0xFF) { 1940 printk(KERN_WARNING 1941 "cciss: reading geometry failed, volume " 1942 "does not support reading geometry\n"); 1943 drv->heads = 255; 1944 drv->sectors = 32; // Sectors per track 1945 drv->cylinders = total_size + 1; 1946 drv->raid_level = RAID_UNKNOWN; 1947 } else { 1948 drv->heads = inq_buff->data_byte[6]; 1949 drv->sectors = inq_buff->data_byte[7]; 1950 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8; 1951 drv->cylinders += inq_buff->data_byte[5]; 1952 drv->raid_level = inq_buff->data_byte[8]; 1953 } 1954 drv->block_size = block_size; 1955 drv->nr_blocks = total_size + 1; 1956 t = drv->heads * drv->sectors; 1957 if (t > 1) { 1958 sector_t real_size = total_size + 1; 1959 unsigned long rem = sector_div(real_size, t); 1960 if (rem) 1961 real_size++; 1962 drv->cylinders = real_size; 1963 } 1964 } else { /* Get geometry failed */ 1965 printk(KERN_WARNING "cciss: reading geometry failed\n"); 1966 } 1967 printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n", 1968 drv->heads, drv->sectors, drv->cylinders); 1969} 1970 1971static void 1972cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size, 1973 unsigned int *block_size) 1974{ 1975 ReadCapdata_struct *buf; 1976 int return_code; 1977 1978 buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL); 1979 if (!buf) { 1980 printk(KERN_WARNING "cciss: out of memory\n"); 1981 return; 1982 } 1983 1984 if (withirq) 1985 return_code = sendcmd_withirq(CCISS_READ_CAPACITY, 1986 ctlr, buf, sizeof(ReadCapdata_struct), 1987 1, logvol, 0, TYPE_CMD); 1988 else 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(*(__be32 *) buf->total_size); 1994 *block_size = be32_to_cpu(*(__be32 *) buf->block_size); 1995 } else { /* read capacity command failed */ 1996 printk(KERN_WARNING "cciss: read capacity failed\n"); 1997 *total_size = 0; 1998 *block_size = BLOCK_SIZE; 1999 } 2000 if (*total_size != 0) 2001 printk(KERN_INFO " blocks= %llu block_size= %d\n", 2002 (unsigned long long)*total_size+1, *block_size); 2003 kfree(buf); 2004} 2005 2006static void 2007cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, unsigned int *block_size) 2008{ 2009 ReadCapdata_struct_16 *buf; 2010 int return_code; 2011 2012 buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL); 2013 if (!buf) { 2014 printk(KERN_WARNING "cciss: out of memory\n"); 2015 return; 2016 } 2017 2018 if (withirq) { 2019 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16, 2020 ctlr, buf, sizeof(ReadCapdata_struct_16), 2021 1, logvol, 0, TYPE_CMD); 2022 } 2023 else { 2024 return_code = sendcmd(CCISS_READ_CAPACITY_16, 2025 ctlr, buf, sizeof(ReadCapdata_struct_16), 2026 1, logvol, 0, NULL, TYPE_CMD); 2027 } 2028 if (return_code == IO_OK) { 2029 *total_size = be64_to_cpu(*(__be64 *) buf->total_size); 2030 *block_size = be32_to_cpu(*(__be32 *) buf->block_size); 2031 } else { /* read capacity command failed */ 2032 printk(KERN_WARNING "cciss: read capacity failed\n"); 2033 *total_size = 0; 2034 *block_size = BLOCK_SIZE; 2035 } 2036 printk(KERN_INFO " blocks= %llu block_size= %d\n", 2037 (unsigned long long)*total_size+1, *block_size); 2038 kfree(buf); 2039} 2040 2041static int cciss_revalidate(struct gendisk *disk) 2042{ 2043 ctlr_info_t *h = get_host(disk); 2044 drive_info_struct *drv = get_drv(disk); 2045 int logvol; 2046 int FOUND = 0; 2047 unsigned int block_size; 2048 sector_t total_size; 2049 InquiryData_struct *inq_buff = NULL; 2050 2051 for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) { 2052 if (h->drv[logvol].LunID == drv->LunID) { 2053 FOUND = 1; 2054 break; 2055 } 2056 } 2057 2058 if (!FOUND) 2059 return 1; 2060 2061 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); 2062 if (inq_buff == NULL) { 2063 printk(KERN_WARNING "cciss: out of memory\n"); 2064 return 1; 2065 } 2066 if (h->cciss_read == CCISS_READ_10) { 2067 cciss_read_capacity(h->ctlr, logvol, 1, 2068 &total_size, &block_size); 2069 } else { 2070 cciss_read_capacity_16(h->ctlr, logvol, 1, 2071 &total_size, &block_size); 2072 } 2073 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, 2074 inq_buff, drv); 2075 2076 blk_queue_hardsect_size(drv->queue, drv->block_size); 2077 set_capacity(disk, drv->nr_blocks); 2078 2079 kfree(inq_buff); 2080 return 0; 2081} 2082 2083/* 2084 * Wait polling for a command to complete. 2085 * The memory mapped FIFO is polled for the completion. 2086 * Used only at init time, interrupts from the HBA are disabled. 2087 */ 2088static unsigned long pollcomplete(int ctlr) 2089{ 2090 unsigned long done; 2091 int i; 2092 2093 /* Wait (up to 20 seconds) for a command to complete */ 2094 2095 for (i = 20 * HZ; i > 0; i--) { 2096 done = hba[ctlr]->access.command_completed(hba[ctlr]); 2097 if (done == FIFO_EMPTY) 2098 schedule_timeout_uninterruptible(1); 2099 else 2100 return done; 2101 } 2102 /* Invalid address to tell caller we ran out of time */ 2103 return 1; 2104} 2105 2106static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete) 2107{ 2108 /* We get in here if sendcmd() is polling for completions 2109 and gets some command back that it wasn't expecting -- 2110 something other than that which it just sent down. 2111 Ordinarily, that shouldn't happen, but it can happen when 2112 the scsi tape stuff gets into error handling mode, and 2113 starts using sendcmd() to try to abort commands and 2114 reset tape drives. In that case, sendcmd may pick up 2115 completions of commands that were sent to logical drives 2116 through the block i/o system, or cciss ioctls completing, etc. 2117 In that case, we need to save those completions for later 2118 processing by the interrupt handler. 2119 */ 2120 2121#ifdef CONFIG_CISS_SCSI_TAPE 2122 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects; 2123 2124 /* If it's not the scsi tape stuff doing error handling, (abort */ 2125 /* or reset) then we don't expect anything weird. */ 2126 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) { 2127#endif 2128 printk(KERN_WARNING "cciss cciss%d: SendCmd " 2129 "Invalid command list address returned! (%lx)\n", 2130 ctlr, complete); 2131 /* not much we can do. */ 2132#ifdef CONFIG_CISS_SCSI_TAPE 2133 return 1; 2134 } 2135 2136 /* We've sent down an abort or reset, but something else 2137 has completed */ 2138 if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) { 2139 /* Uh oh. No room to save it for later... */ 2140 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, " 2141 "reject list overflow, command lost!\n", ctlr); 2142 return 1; 2143 } 2144 /* Save it for later */ 2145 srl->complete[srl->ncompletions] = complete; 2146 srl->ncompletions++; 2147#endif 2148 return 0; 2149} 2150 2151/* 2152 * Send a command to the controller, and wait for it to complete. 2153 * Only used at init time. 2154 */ 2155static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller, 2156 1: address logical volume log_unit, 2157 2: periph device address is scsi3addr */ 2158 unsigned int log_unit, 2159 __u8 page_code, unsigned char *scsi3addr, int cmd_type) 2160{ 2161 CommandList_struct *c; 2162 int i; 2163 unsigned long complete; 2164 ctlr_info_t *info_p = hba[ctlr]; 2165 u64bit buff_dma_handle; 2166 int status, done = 0; 2167 2168 if ((c = cmd_alloc(info_p, 1)) == NULL) { 2169 printk(KERN_WARNING "cciss: unable to get memory"); 2170 return IO_ERROR; 2171 } 2172 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num, 2173 log_unit, page_code, scsi3addr, cmd_type); 2174 if (status != IO_OK) { 2175 cmd_free(info_p, c, 1); 2176 return status; 2177 } 2178 resend_cmd1: 2179 /* 2180 * Disable interrupt 2181 */ 2182#ifdef CCISS_DEBUG 2183 printk(KERN_DEBUG "cciss: turning intr off\n"); 2184#endif /* CCISS_DEBUG */ 2185 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF); 2186 2187 /* Make sure there is room in the command FIFO */ 2188 /* Actually it should be completely empty at this time */ 2189 /* unless we are in here doing error handling for the scsi */ 2190 /* tape side of the driver. */ 2191 for (i = 200000; i > 0; i--) { 2192 /* if fifo isn't full go */ 2193 if (!(info_p->access.fifo_full(info_p))) { 2194 2195 break; 2196 } 2197 udelay(10); 2198 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full," 2199 " waiting!\n", ctlr); 2200 } 2201 /* 2202 * Send the cmd 2203 */ 2204 info_p->access.submit_command(info_p, c); 2205 done = 0; 2206 do { 2207 complete = pollcomplete(ctlr); 2208 2209#ifdef CCISS_DEBUG 2210 printk(KERN_DEBUG "cciss: command completed\n"); 2211#endif /* CCISS_DEBUG */ 2212 2213 if (complete == 1) { 2214 printk(KERN_WARNING 2215 "cciss cciss%d: SendCmd Timeout out, " 2216 "No command list address returned!\n", ctlr); 2217 status = IO_ERROR; 2218 done = 1; 2219 break; 2220 } 2221 2222 /* This will need to change for direct lookup completions */ 2223 if ((complete & CISS_ERROR_BIT) 2224 && (complete & ~CISS_ERROR_BIT) == c->busaddr) { 2225 /* if data overrun or underun on Report command 2226 ignore it 2227 */ 2228 if (((c->Request.CDB[0] == CISS_REPORT_LOG) || 2229 (c->Request.CDB[0] == CISS_REPORT_PHYS) || 2230 (c->Request.CDB[0] == CISS_INQUIRY)) && 2231 ((c->err_info->CommandStatus == 2232 CMD_DATA_OVERRUN) || 2233 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN) 2234 )) { 2235 complete = c->busaddr; 2236 } else { 2237 if (c->err_info->CommandStatus == 2238 CMD_UNSOLICITED_ABORT) { 2239 printk(KERN_WARNING "cciss%d: " 2240 "unsolicited abort %p\n", 2241 ctlr, c); 2242 if (c->retry_count < MAX_CMD_RETRIES) { 2243 printk(KERN_WARNING 2244 "cciss%d: retrying %p\n", 2245 ctlr, c); 2246 c->retry_count++; 2247 /* erase the old error */ 2248 /* information */ 2249 memset(c->err_info, 0, 2250 sizeof 2251 (ErrorInfo_struct)); 2252 goto resend_cmd1; 2253 } else { 2254 printk(KERN_WARNING 2255 "cciss%d: retried %p too " 2256 "many times\n", ctlr, c); 2257 status = IO_ERROR; 2258 goto cleanup1; 2259 } 2260 } else if (c->err_info->CommandStatus == 2261 CMD_UNABORTABLE) { 2262 printk(KERN_WARNING 2263 "cciss%d: command could not be aborted.\n", 2264 ctlr); 2265 status = IO_ERROR; 2266 goto cleanup1; 2267 } 2268 printk(KERN_WARNING "ciss ciss%d: sendcmd" 2269 " Error %x \n", ctlr, 2270 c->err_info->CommandStatus); 2271 printk(KERN_WARNING "ciss ciss%d: sendcmd" 2272 " offensive info\n" 2273 " size %x\n num %x value %x\n", 2274 ctlr, 2275 c->err_info->MoreErrInfo.Invalid_Cmd. 2276 offense_size, 2277 c->err_info->MoreErrInfo.Invalid_Cmd. 2278 offense_num, 2279 c->err_info->MoreErrInfo.Invalid_Cmd. 2280 offense_value); 2281 status = IO_ERROR; 2282 goto cleanup1; 2283 } 2284 } 2285 /* This will need changing for direct lookup completions */ 2286 if (complete != c->busaddr) { 2287 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) { 2288 BUG(); /* we are pretty much hosed if we get here. */ 2289 } 2290 continue; 2291 } else 2292 done = 1; 2293 } while (!done); 2294 2295 cleanup1: 2296 /* unlock the data buffer from DMA */ 2297 buff_dma_handle.val32.lower = c->SG[0].Addr.lower; 2298 buff_dma_handle.val32.upper = c->SG[0].Addr.upper; 2299 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val, 2300 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL); 2301#ifdef CONFIG_CISS_SCSI_TAPE 2302 /* if we saved some commands for later, process them now. */ 2303 if (info_p->scsi_rejects.ncompletions > 0) 2304 do_cciss_intr(0, info_p); 2305#endif 2306 cmd_free(info_p, c, 1); 2307 return status; 2308} 2309 2310/* 2311 * Map (physical) PCI mem into (virtual) kernel space 2312 */ 2313static void __iomem *remap_pci_mem(ulong base, ulong size) 2314{ 2315 ulong page_base = ((ulong) base) & PAGE_MASK; 2316 ulong page_offs = ((ulong) base) - page_base; 2317 void __iomem *page_remapped = ioremap(page_base, page_offs + size); 2318 2319 return page_remapped ? (page_remapped + page_offs) : NULL; 2320} 2321 2322/* 2323 * Takes jobs of the Q and sends them to the hardware, then puts it on 2324 * the Q to wait for completion. 2325 */ 2326static void start_io(ctlr_info_t *h) 2327{ 2328 CommandList_struct *c; 2329 2330 while ((c = h->reqQ) != NULL) { 2331 /* can't do anything if fifo is full */ 2332 if ((h->access.fifo_full(h))) { 2333 printk(KERN_WARNING "cciss: fifo full\n"); 2334 break; 2335 } 2336 2337 /* Get the first entry from the Request Q */ 2338 removeQ(&(h->reqQ), c); 2339 h->Qdepth--; 2340 2341 /* Tell the controller execute command */ 2342 h->access.submit_command(h, c); 2343 2344 /* Put job onto the completed Q */ 2345 addQ(&(h->cmpQ), c); 2346 } 2347} 2348 2349/* Assumes that CCISS_LOCK(h->ctlr) is held. */ 2350/* Zeros out the error record and then resends the command back */ 2351/* to the controller */ 2352static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c) 2353{ 2354 /* erase the old error information */ 2355 memset(c->err_info, 0, sizeof(ErrorInfo_struct)); 2356 2357 /* add it to software queue and then send it to the controller */ 2358 addQ(&(h->reqQ), c); 2359 h->Qdepth++; 2360 if (h->Qdepth > h->maxQsinceinit) 2361 h->maxQsinceinit = h->Qdepth; 2362 2363 start_io(h); 2364} 2365 2366static inline unsigned int make_status_bytes(unsigned int scsi_status_byte, 2367 unsigned int msg_byte, unsigned int host_byte, 2368 unsigned int driver_byte) 2369{ 2370 /* inverse of macros in scsi.h */ 2371 return (scsi_status_byte & 0xff) | 2372 ((msg_byte & 0xff) << 8) | 2373 ((host_byte & 0xff) << 16) | 2374 ((driver_byte & 0xff) << 24); 2375} 2376 2377static inline int evaluate_target_status(CommandList_struct *cmd) 2378{ 2379 unsigned char sense_key; 2380 unsigned char status_byte, msg_byte, host_byte, driver_byte; 2381 int error_value; 2382 2383 /* If we get in here, it means we got "target status", that is, scsi status */ 2384 status_byte = cmd->err_info->ScsiStatus; 2385 driver_byte = DRIVER_OK; 2386 msg_byte = cmd->err_info->CommandStatus; /* correct? seems too device specific */ 2387 2388 if (blk_pc_request(cmd->rq)) 2389 host_byte = DID_PASSTHROUGH; 2390 else 2391 host_byte = DID_OK; 2392 2393 error_value = make_status_bytes(status_byte, msg_byte, 2394 host_byte, driver_byte); 2395 2396 if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) { 2397 if (!blk_pc_request(cmd->rq)) 2398 printk(KERN_WARNING "cciss: cmd %p " 2399 "has SCSI Status 0x%x\n", 2400 cmd, cmd->err_info->ScsiStatus); 2401 return error_value; 2402 } 2403 2404 /* check the sense key */ 2405 sense_key = 0xf & cmd->err_info->SenseInfo[2]; 2406 /* no status or recovered error */ 2407 if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq)) 2408 error_value = 0; 2409 2410 if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */ 2411 if (error_value != 0) 2412 printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION" 2413 " sense key = 0x%x\n", cmd, sense_key); 2414 return error_value; 2415 } 2416 2417 /* SG_IO or similar, copy sense data back */ 2418 if (cmd->rq->sense) { 2419 if (cmd->rq->sense_len > cmd->err_info->SenseLen) 2420 cmd->rq->sense_len = cmd->err_info->SenseLen; 2421 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo, 2422 cmd->rq->sense_len); 2423 } else 2424 cmd->rq->sense_len = 0; 2425 2426 return error_value; 2427} 2428 2429/* checks the status of the job and calls complete buffers to mark all 2430 * buffers for the completed job. Note that this function does not need 2431 * to hold the hba/queue lock. 2432 */ 2433static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd, 2434 int timeout) 2435{ 2436 int retry_cmd = 0; 2437 struct request *rq = cmd->rq; 2438 2439 rq->errors = 0; 2440 2441 if (timeout) 2442 rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT); 2443 2444 if (cmd->err_info->CommandStatus == 0) /* no error has occurred */ 2445 goto after_error_processing; 2446 2447 switch (cmd->err_info->CommandStatus) { 2448 case CMD_TARGET_STATUS: 2449 rq->errors = evaluate_target_status(cmd); 2450 break; 2451 case CMD_DATA_UNDERRUN: 2452 if (blk_fs_request(cmd->rq)) { 2453 printk(KERN_WARNING "cciss: cmd %p has" 2454 " completed with data underrun " 2455 "reported\n", cmd); 2456 cmd->rq->data_len = cmd->err_info->ResidualCnt; 2457 } 2458 break; 2459 case CMD_DATA_OVERRUN: 2460 if (blk_fs_request(cmd->rq)) 2461 printk(KERN_WARNING "cciss: cmd %p has" 2462 " completed with data overrun " 2463 "reported\n", cmd); 2464 break; 2465 case CMD_INVALID: 2466 printk(KERN_WARNING "cciss: cmd %p is " 2467 "reported invalid\n", cmd); 2468 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2469 cmd->err_info->CommandStatus, DRIVER_OK, 2470 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2471 break; 2472 case CMD_PROTOCOL_ERR: 2473 printk(KERN_WARNING "cciss: cmd %p has " 2474 "protocol error \n", cmd); 2475 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2476 cmd->err_info->CommandStatus, DRIVER_OK, 2477 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2478 break; 2479 case CMD_HARDWARE_ERR: 2480 printk(KERN_WARNING "cciss: cmd %p had " 2481 " hardware error\n", cmd); 2482 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2483 cmd->err_info->CommandStatus, DRIVER_OK, 2484 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2485 break; 2486 case CMD_CONNECTION_LOST: 2487 printk(KERN_WARNING "cciss: cmd %p had " 2488 "connection lost\n", cmd); 2489 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2490 cmd->err_info->CommandStatus, DRIVER_OK, 2491 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2492 break; 2493 case CMD_ABORTED: 2494 printk(KERN_WARNING "cciss: cmd %p was " 2495 "aborted\n", cmd); 2496 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2497 cmd->err_info->CommandStatus, DRIVER_OK, 2498 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT); 2499 break; 2500 case CMD_ABORT_FAILED: 2501 printk(KERN_WARNING "cciss: cmd %p reports " 2502 "abort failed\n", cmd); 2503 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2504 cmd->err_info->CommandStatus, DRIVER_OK, 2505 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2506 break; 2507 case CMD_UNSOLICITED_ABORT: 2508 printk(KERN_WARNING "cciss%d: unsolicited " 2509 "abort %p\n", h->ctlr, cmd); 2510 if (cmd->retry_count < MAX_CMD_RETRIES) { 2511 retry_cmd = 1; 2512 printk(KERN_WARNING 2513 "cciss%d: retrying %p\n", h->ctlr, cmd); 2514 cmd->retry_count++; 2515 } else 2516 printk(KERN_WARNING 2517 "cciss%d: %p retried too " 2518 "many times\n", h->ctlr, cmd); 2519 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2520 cmd->err_info->CommandStatus, DRIVER_OK, 2521 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT); 2522 break; 2523 case CMD_TIMEOUT: 2524 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd); 2525 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2526 cmd->err_info->CommandStatus, DRIVER_OK, 2527 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2528 break; 2529 default: 2530 printk(KERN_WARNING "cciss: cmd %p returned " 2531 "unknown status %x\n", cmd, 2532 cmd->err_info->CommandStatus); 2533 rq->errors = make_status_bytes(SAM_STAT_GOOD, 2534 cmd->err_info->CommandStatus, DRIVER_OK, 2535 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR); 2536 } 2537 2538after_error_processing: 2539 2540 /* We need to return this command */ 2541 if (retry_cmd) { 2542 resend_cciss_cmd(h, cmd); 2543 return; 2544 } 2545 cmd->rq->data_len = 0; 2546 cmd->rq->completion_data = cmd; 2547 blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE); 2548 blk_complete_request(cmd->rq); 2549} 2550 2551/* 2552 * Get a request and submit it to the controller. 2553 */ 2554static void do_cciss_request(struct request_queue *q) 2555{ 2556 ctlr_info_t *h = q->queuedata; 2557 CommandList_struct *c; 2558 sector_t start_blk; 2559 int seg; 2560 struct request *creq; 2561 u64bit temp64; 2562 struct scatterlist tmp_sg[MAXSGENTRIES]; 2563 drive_info_struct *drv; 2564 int i, dir; 2565 2566 /* We call start_io here in case there is a command waiting on the 2567 * queue that has not been sent. 2568 */ 2569 if (blk_queue_plugged(q)) 2570 goto startio; 2571 2572 queue: 2573 creq = elv_next_request(q); 2574 if (!creq) 2575 goto startio; 2576 2577 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES); 2578 2579 if ((c = cmd_alloc(h, 1)) == NULL) 2580 goto full; 2581 2582 blkdev_dequeue_request(creq); 2583 2584 spin_unlock_irq(q->queue_lock); 2585 2586 c->cmd_type = CMD_RWREQ; 2587 c->rq = creq; 2588 2589 /* fill in the request */ 2590 drv = creq->rq_disk->private_data; 2591 c->Header.ReplyQueue = 0; // unused in simple mode 2592 /* got command from pool, so use the command block index instead */ 2593 /* for direct lookups. */ 2594 /* The first 2 bits are reserved for controller error reporting. */ 2595 c->Header.Tag.lower = (c->cmdindex << 3); 2596 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */ 2597 c->Header.LUN.LogDev.VolId = drv->LunID; 2598 c->Header.LUN.LogDev.Mode = 1; 2599 c->Request.CDBLen = 10; // 12 byte commands not in FW yet; 2600 c->Request.Type.Type = TYPE_CMD; // It is a command. 2601 c->Request.Type.Attribute = ATTR_SIMPLE; 2602 c->Request.Type.Direction = 2603 (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE; 2604 c->Request.Timeout = 0; // Don't time out 2605 c->Request.CDB[0] = 2606 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write; 2607 start_blk = creq->sector; 2608#ifdef CCISS_DEBUG 2609 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector, 2610 (int)creq->nr_sectors); 2611#endif /* CCISS_DEBUG */ 2612 2613 sg_init_table(tmp_sg, MAXSGENTRIES); 2614 seg = blk_rq_map_sg(q, creq, tmp_sg); 2615 2616 /* get the DMA records for the setup */ 2617 if (c->Request.Type.Direction == XFER_READ) 2618 dir = PCI_DMA_FROMDEVICE; 2619 else 2620 dir = PCI_DMA_TODEVICE; 2621 2622 for (i = 0; i < seg; i++) { 2623 c->SG[i].Len = tmp_sg[i].length; 2624 temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]), 2625 tmp_sg[i].offset, 2626 tmp_sg[i].length, dir); 2627 c->SG[i].Addr.lower = temp64.val32.lower; 2628 c->SG[i].Addr.upper = temp64.val32.upper; 2629 c->SG[i].Ext = 0; // we are not chaining 2630 } 2631 /* track how many SG entries we are using */ 2632 if (seg > h->maxSG) 2633 h->maxSG = seg; 2634 2635#ifdef CCISS_DEBUG 2636 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", 2637 creq->nr_sectors, seg); 2638#endif /* CCISS_DEBUG */ 2639 2640 c->Header.SGList = c->Header.SGTotal = seg; 2641 if (likely(blk_fs_request(creq))) { 2642 if(h->cciss_read == CCISS_READ_10) { 2643 c->Request.CDB[1] = 0; 2644 c->Request.CDB[2] = (start_blk >> 24) & 0xff; //MSB 2645 c->Request.CDB[3] = (start_blk >> 16) & 0xff; 2646 c->Request.CDB[4] = (start_blk >> 8) & 0xff; 2647 c->Request.CDB[5] = start_blk & 0xff; 2648 c->Request.CDB[6] = 0; // (sect >> 24) & 0xff; MSB 2649 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff; 2650 c->Request.CDB[8] = creq->nr_sectors & 0xff; 2651 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0; 2652 } else { 2653 c->Request.CDBLen = 16; 2654 c->Request.CDB[1]= 0; 2655 c->Request.CDB[2]= (start_blk >> 56) & 0xff; //MSB 2656 c->Request.CDB[3]= (start_blk >> 48) & 0xff; 2657 c->Request.CDB[4]= (start_blk >> 40) & 0xff; 2658 c->Request.CDB[5]= (start_blk >> 32) & 0xff; 2659 c->Request.CDB[6]= (start_blk >> 24) & 0xff; 2660 c->Request.CDB[7]= (start_blk >> 16) & 0xff; 2661 c->Request.CDB[8]= (start_blk >> 8) & 0xff; 2662 c->Request.CDB[9]= start_blk & 0xff; 2663 c->Request.CDB[10]= (creq->nr_sectors >> 24) & 0xff; 2664 c->Request.CDB[11]= (creq->nr_sectors >> 16) & 0xff; 2665 c->Request.CDB[12]= (creq->nr_sectors >> 8) & 0xff; 2666 c->Request.CDB[13]= creq->nr_sectors & 0xff; 2667 c->Request.CDB[14] = c->Request.CDB[15] = 0; 2668 } 2669 } else if (blk_pc_request(creq)) { 2670 c->Request.CDBLen = creq->cmd_len; 2671 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB); 2672 } else { 2673 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type); 2674 BUG(); 2675 } 2676 2677 spin_lock_irq(q->queue_lock); 2678 2679 addQ(&(h->reqQ), c); 2680 h->Qdepth++; 2681 if (h->Qdepth > h->maxQsinceinit) 2682 h->maxQsinceinit = h->Qdepth; 2683 2684 goto queue; 2685full: 2686 blk_stop_queue(q); 2687startio: 2688 /* We will already have the driver lock here so not need 2689 * to lock it. 2690 */ 2691 start_io(h); 2692} 2693 2694static inline unsigned long get_next_completion(ctlr_info_t *h) 2695{ 2696#ifdef CONFIG_CISS_SCSI_TAPE 2697 /* Any rejects from sendcmd() lying around? Process them first */ 2698 if (h->scsi_rejects.ncompletions == 0) 2699 return h->access.command_completed(h); 2700 else { 2701 struct sendcmd_reject_list *srl; 2702 int n; 2703 srl = &h->scsi_rejects; 2704 n = --srl->ncompletions; 2705 /* printk("cciss%d: processing saved reject\n", h->ctlr); */ 2706 printk("p"); 2707 return srl->complete[n]; 2708 } 2709#else 2710 return h->access.command_completed(h); 2711#endif 2712} 2713 2714static inline int interrupt_pending(ctlr_info_t *h) 2715{ 2716#ifdef CONFIG_CISS_SCSI_TAPE 2717 return (h->access.intr_pending(h) 2718 || (h->scsi_rejects.ncompletions > 0)); 2719#else 2720 return h->access.intr_pending(h); 2721#endif 2722} 2723 2724static inline long interrupt_not_for_us(ctlr_info_t *h) 2725{ 2726#ifdef CONFIG_CISS_SCSI_TAPE 2727 return (((h->access.intr_pending(h) == 0) || 2728 (h->interrupts_enabled == 0)) 2729 && (h->scsi_rejects.ncompletions == 0)); 2730#else 2731 return (((h->access.intr_pending(h) == 0) || 2732 (h->interrupts_enabled == 0))); 2733#endif 2734} 2735 2736static irqreturn_t do_cciss_intr(int irq, void *dev_id) 2737{ 2738 ctlr_info_t *h = dev_id; 2739 CommandList_struct *c; 2740 unsigned long flags; 2741 __u32 a, a1, a2; 2742 2743 if (interrupt_not_for_us(h)) 2744 return IRQ_NONE; 2745 /* 2746 * If there are completed commands in the completion queue, 2747 * we had better do something about it. 2748 */ 2749 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); 2750 while (interrupt_pending(h)) { 2751 while ((a = get_next_completion(h)) != FIFO_EMPTY) { 2752 a1 = a; 2753 if ((a & 0x04)) { 2754 a2 = (a >> 3); 2755 if (a2 >= h->nr_cmds) { 2756 printk(KERN_WARNING 2757 "cciss: controller cciss%d failed, stopping.\n", 2758 h->ctlr); 2759 fail_all_cmds(h->ctlr); 2760 return IRQ_HANDLED; 2761 } 2762 2763 c = h->cmd_pool + a2; 2764 a = c->busaddr; 2765 2766 } else { 2767 a &= ~3; 2768 if ((c = h->cmpQ) == NULL) { 2769 printk(KERN_WARNING 2770 "cciss: Completion of %08x ignored\n", 2771 a1); 2772 continue; 2773 } 2774 while (c->busaddr != a) { 2775 c = c->next; 2776 if (c == h->cmpQ) 2777 break; 2778 } 2779 } 2780 /* 2781 * If we've found the command, take it off the 2782 * completion Q and free it 2783 */ 2784 if (c->busaddr == a) { 2785 removeQ(&h->cmpQ, c); 2786 if (c->cmd_type == CMD_RWREQ) { 2787 complete_command(h, c, 0); 2788 } else if (c->cmd_type == CMD_IOCTL_PEND) { 2789 complete(c->waiting); 2790 } 2791# ifdef CONFIG_CISS_SCSI_TAPE 2792 else if (c->cmd_type == CMD_SCSI) 2793 complete_scsi_command(c, 0, a1); 2794# endif 2795 continue; 2796 } 2797 } 2798 } 2799 2800 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); 2801 return IRQ_HANDLED; 2802} 2803 2804/* 2805 * We cannot read the structure directly, for portability we must use 2806 * the io functions. 2807 * This is for debug only. 2808 */ 2809#ifdef CCISS_DEBUG 2810static void print_cfg_table(CfgTable_struct *tb) 2811{ 2812 int i; 2813 char temp_name[17]; 2814 2815 printk("Controller Configuration information\n"); 2816 printk("------------------------------------\n"); 2817 for (i = 0; i < 4; i++) 2818 temp_name[i] = readb(&(tb->Signature[i])); 2819 temp_name[4] = '\0'; 2820 printk(" Signature = %s\n", temp_name); 2821 printk(" Spec Number = %d\n", readl(&(tb->SpecValence))); 2822 printk(" Transport methods supported = 0x%x\n", 2823 readl(&(tb->TransportSupport))); 2824 printk(" Transport methods active = 0x%x\n", 2825 readl(&(tb->TransportActive))); 2826 printk(" Requested transport Method = 0x%x\n", 2827 readl(&(tb->HostWrite.TransportRequest))); 2828 printk(" Coalesce Interrupt Delay = 0x%x\n", 2829 readl(&(tb->HostWrite.CoalIntDelay))); 2830 printk(" Coalesce Interrupt Count = 0x%x\n", 2831 readl(&(tb->HostWrite.CoalIntCount))); 2832 printk(" Max outstanding commands = 0x%d\n", 2833 readl(&(tb->CmdsOutMax))); 2834 printk(" Bus Types = 0x%x\n", readl(&(tb->BusTypes))); 2835 for (i = 0; i < 16; i++) 2836 temp_name[i] = readb(&(tb->ServerName[i])); 2837 temp_name[16] = '\0'; 2838 printk(" Server Name = %s\n", temp_name); 2839 printk(" Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat))); 2840} 2841#endif /* CCISS_DEBUG */ 2842 2843static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr) 2844{ 2845 int i, offset, mem_type, bar_type; 2846 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */ 2847 return 0; 2848 offset = 0; 2849 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { 2850 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE; 2851 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO) 2852 offset += 4; 2853 else { 2854 mem_type = pci_resource_flags(pdev, i) & 2855 PCI_BASE_ADDRESS_MEM_TYPE_MASK; 2856 switch (mem_type) { 2857 case PCI_BASE_ADDRESS_MEM_TYPE_32: 2858 case PCI_BASE_ADDRESS_MEM_TYPE_1M: 2859 offset += 4; /* 32 bit */ 2860 break; 2861 case PCI_BASE_ADDRESS_MEM_TYPE_64: 2862 offset += 8; 2863 break; 2864 default: /* reserved in PCI 2.2 */ 2865 printk(KERN_WARNING 2866 "Base address is invalid\n"); 2867 return -1; 2868 break; 2869 } 2870 } 2871 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0) 2872 return i + 1; 2873 } 2874 return -1; 2875} 2876 2877/* If MSI/MSI-X is supported by the kernel we will try to enable it on 2878 * controllers that are capable. If not, we use IO-APIC mode. 2879 */ 2880 2881static void __devinit cciss_interrupt_mode(ctlr_info_t *c, 2882 struct pci_dev *pdev, __u32 board_id) 2883{ 2884#ifdef CONFIG_PCI_MSI 2885 int err; 2886 struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1}, 2887 {0, 2}, {0, 3} 2888 }; 2889 2890 /* Some boards advertise MSI but don't really support it */ 2891 if ((board_id == 0x40700E11) || 2892 (board_id == 0x40800E11) || 2893 (board_id == 0x40820E11) || (board_id == 0x40830E11)) 2894 goto default_int_mode; 2895 2896 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) { 2897 err = pci_enable_msix(pdev, cciss_msix_entries, 4); 2898 if (!err) { 2899 c->intr[0] = cciss_msix_entries[0].vector; 2900 c->intr[1] = cciss_msix_entries[1].vector; 2901 c->intr[2] = cciss_msix_entries[2].vector; 2902 c->intr[3] = cciss_msix_entries[3].vector; 2903 c->msix_vector = 1; 2904 return; 2905 } 2906 if (err > 0) { 2907 printk(KERN_WARNING "cciss: only %d MSI-X vectors " 2908 "available\n", err); 2909 goto default_int_mode; 2910 } else { 2911 printk(KERN_WARNING "cciss: MSI-X init failed %d\n", 2912 err); 2913 goto default_int_mode; 2914 } 2915 } 2916 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) { 2917 if (!pci_enable_msi(pdev)) { 2918 c->msi_vector = 1; 2919 } else { 2920 printk(KERN_WARNING "cciss: MSI init failed\n"); 2921 } 2922 } 2923default_int_mode: 2924#endif /* CONFIG_PCI_MSI */ 2925 /* if we get here we're going to use the default interrupt mode */ 2926 c->intr[SIMPLE_MODE_INT] = pdev->irq; 2927 return; 2928} 2929 2930static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev) 2931{ 2932 ushort subsystem_vendor_id, subsystem_device_id, command; 2933 __u32 board_id, scratchpad = 0; 2934 __u64 cfg_offset; 2935 __u32 cfg_base_addr; 2936 __u64 cfg_base_addr_index; 2937 int i, err; 2938 2939 /* check to see if controller has been disabled */ 2940 /* BEFORE trying to enable it */ 2941 (void)pci_read_config_word(pdev, PCI_COMMAND, &command); 2942 if (!(command & 0x02)) { 2943 printk(KERN_WARNING 2944 "cciss: controller appears to be disabled\n"); 2945 return -ENODEV; 2946 } 2947 2948 err = pci_enable_device(pdev); 2949 if (err) { 2950 printk(KERN_ERR "cciss: Unable to Enable PCI device\n"); 2951 return err; 2952 } 2953 2954 err = pci_request_regions(pdev, "cciss"); 2955 if (err) { 2956 printk(KERN_ERR "cciss: Cannot obtain PCI resources, " 2957 "aborting\n"); 2958 return err; 2959 } 2960 2961 subsystem_vendor_id = pdev->subsystem_vendor; 2962 subsystem_device_id = pdev->subsystem_device; 2963 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) | 2964 subsystem_vendor_id); 2965 2966#ifdef CCISS_DEBUG 2967 printk("command = %x\n", command); 2968 printk("irq = %x\n", pdev->irq); 2969 printk("board_id = %x\n", board_id); 2970#endif /* CCISS_DEBUG */ 2971 2972/* If the kernel supports MSI/MSI-X we will try to enable that functionality, 2973 * else we use the IO-APIC interrupt assigned to us by system ROM. 2974 */ 2975 cciss_interrupt_mode(c, pdev, board_id); 2976 2977 /* 2978 * Memory base addr is first addr , the second points to the config 2979 * table 2980 */ 2981 2982 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */ 2983#ifdef CCISS_DEBUG 2984 printk("address 0 = %x\n", c->paddr); 2985#endif /* CCISS_DEBUG */ 2986 c->vaddr = remap_pci_mem(c->paddr, 0x250); 2987 2988 /* Wait for the board to become ready. (PCI hotplug needs this.) 2989 * We poll for up to 120 secs, once per 100ms. */ 2990 for (i = 0; i < 1200; i++) { 2991 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET); 2992 if (scratchpad == CCISS_FIRMWARE_READY) 2993 break; 2994 set_current_state(TASK_INTERRUPTIBLE); 2995 schedule_timeout(HZ / 10); /* wait 100ms */ 2996 } 2997 if (scratchpad != CCISS_FIRMWARE_READY) { 2998 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n"); 2999 err = -ENODEV; 3000 goto err_out_free_res; 3001 } 3002 3003 /* get the address index number */ 3004 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET); 3005 cfg_base_addr &= (__u32) 0x0000ffff; 3006#ifdef CCISS_DEBUG 3007 printk("cfg base address = %x\n", cfg_base_addr); 3008#endif /* CCISS_DEBUG */ 3009 cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr); 3010#ifdef CCISS_DEBUG 3011 printk("cfg base address index = %x\n", cfg_base_addr_index); 3012#endif /* CCISS_DEBUG */ 3013 if (cfg_base_addr_index == -1) { 3014 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n"); 3015 err = -ENODEV; 3016 goto err_out_free_res; 3017 } 3018 3019 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET); 3020#ifdef CCISS_DEBUG 3021 printk("cfg offset = %x\n", cfg_offset); 3022#endif /* CCISS_DEBUG */ 3023 c->cfgtable = remap_pci_mem(pci_resource_start(pdev, 3024 cfg_base_addr_index) + 3025 cfg_offset, sizeof(CfgTable_struct)); 3026 c->board_id = board_id; 3027 3028#ifdef CCISS_DEBUG 3029 print_cfg_table(c->cfgtable); 3030#endif /* CCISS_DEBUG */ 3031 3032 for (i = 0; i < ARRAY_SIZE(products); i++) { 3033 if (board_id == products[i].board_id) { 3034 c->product_name = products[i].product_name; 3035 c->access = *(products[i].access); 3036 c->nr_cmds = products[i].nr_cmds; 3037 break; 3038 } 3039 } 3040 if ((readb(&c->cfgtable->Signature[0]) != 'C') || 3041 (readb(&c->cfgtable->Signature[1]) != 'I') || 3042 (readb(&c->cfgtable->Signature[2]) != 'S') || 3043 (readb(&c->cfgtable->Signature[3]) != 'S')) { 3044 printk("Does not appear to be a valid CISS config table\n"); 3045 err = -ENODEV; 3046 goto err_out_free_res; 3047 } 3048 /* We didn't find the controller in our list. We know the 3049 * signature is valid. If it's an HP device let's try to 3050 * bind to the device and fire it up. Otherwise we bail. 3051 */ 3052 if (i == ARRAY_SIZE(products)) { 3053 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) { 3054 c->product_name = products[i-1].product_name; 3055 c->access = *(products[i-1].access); 3056 c->nr_cmds = products[i-1].nr_cmds; 3057 printk(KERN_WARNING "cciss: This is an unknown " 3058 "Smart Array controller.\n" 3059 "cciss: Please update to the latest driver " 3060 "available from www.hp.com.\n"); 3061 } else { 3062 printk(KERN_WARNING "cciss: Sorry, I don't know how" 3063 " to access the Smart Array controller %08lx\n" 3064 , (unsigned long)board_id); 3065 err = -ENODEV; 3066 goto err_out_free_res; 3067 } 3068 } 3069#ifdef CONFIG_X86 3070 { 3071 /* Need to enable prefetch in the SCSI core for 6400 in x86 */ 3072 __u32 prefetch; 3073 prefetch = readl(&(c->cfgtable->SCSI_Prefetch)); 3074 prefetch |= 0x100; 3075 writel(prefetch, &(c->cfgtable->SCSI_Prefetch)); 3076 } 3077#endif 3078 3079 /* Disabling DMA prefetch and refetch for the P600. 3080 * An ASIC bug may result in accesses to invalid memory addresses. 3081 * We've disabled prefetch for some time now. Testing with XEN 3082 * kernels revealed a bug in the refetch if dom0 resides on a P600. 3083 */ 3084 if(board_id == 0x3225103C) { 3085 __u32 dma_prefetch; 3086 __u32 dma_refetch; 3087 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG); 3088 dma_prefetch |= 0x8000; 3089 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG); 3090 pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch); 3091 dma_refetch |= 0x1; 3092 pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch); 3093 } 3094 3095#ifdef CCISS_DEBUG 3096 printk("Trying to put board into Simple mode\n"); 3097#endif /* CCISS_DEBUG */ 3098 c->max_commands = readl(&(c->cfgtable->CmdsOutMax)); 3099 /* Update the field, and then ring the doorbell */ 3100 writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest)); 3101 writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL); 3102 3103 /* under certain very rare conditions, this can take awhile. 3104 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right 3105 * as we enter this code.) */ 3106 for (i = 0; i < MAX_CONFIG_WAIT; i++) { 3107 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq)) 3108 break; 3109 /* delay and try again */ 3110 set_current_state(TASK_INTERRUPTIBLE); 3111 schedule_timeout(10); 3112 } 3113 3114#ifdef CCISS_DEBUG 3115 printk(KERN_DEBUG "I counter got to %d %x\n", i, 3116 readl(c->vaddr + SA5_DOORBELL)); 3117#endif /* CCISS_DEBUG */ 3118#ifdef CCISS_DEBUG 3119 print_cfg_table(c->cfgtable); 3120#endif /* CCISS_DEBUG */ 3121 3122 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) { 3123 printk(KERN_WARNING "cciss: unable to get board into" 3124 " simple mode\n"); 3125 err = -ENODEV; 3126 goto err_out_free_res; 3127 } 3128 return 0; 3129 3130err_out_free_res: 3131 /* 3132 * Deliberately omit pci_disable_device(): it does something nasty to 3133 * Smart Array controllers that pci_enable_device does not undo 3134 */ 3135 pci_release_regions(pdev); 3136 return err; 3137} 3138 3139/* 3140 * Gets information about the local volumes attached to the controller. 3141 */ 3142static void cciss_getgeometry(int cntl_num) 3143{ 3144 ReportLunData_struct *ld_buff; 3145 InquiryData_struct *inq_buff; 3146 int return_code; 3147 int i; 3148 int listlength = 0; 3149 __u32 lunid = 0; 3150 unsigned block_size; 3151 sector_t total_size; 3152 3153 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL); 3154 if (ld_buff == NULL) { 3155 printk(KERN_ERR "cciss: out of memory\n"); 3156 return; 3157 } 3158 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); 3159 if (inq_buff == NULL) { 3160 printk(KERN_ERR "cciss: out of memory\n"); 3161 kfree(ld_buff); 3162 return; 3163 } 3164 /* Get the firmware version */ 3165 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff, 3166 sizeof(InquiryData_struct), 0, 0, 0, NULL, 3167 TYPE_CMD); 3168 if (return_code == IO_OK) { 3169 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32]; 3170 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33]; 3171 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34]; 3172 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35]; 3173 } else { /* send command failed */ 3174 3175 printk(KERN_WARNING "cciss: unable to determine firmware" 3176 " version of controller\n"); 3177 } 3178 /* Get the number of logical volumes */ 3179 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff, 3180 sizeof(ReportLunData_struct), 0, 0, 0, NULL, 3181 TYPE_CMD); 3182 3183 if (return_code == IO_OK) { 3184#ifdef CCISS_DEBUG 3185 printk("LUN Data\n--------------------------\n"); 3186#endif /* CCISS_DEBUG */ 3187 3188 listlength |= 3189 (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24; 3190 listlength |= 3191 (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16; 3192 listlength |= 3193 (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8; 3194 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]); 3195 } else { /* reading number of logical volumes failed */ 3196 3197 printk(KERN_WARNING "cciss: report logical volume" 3198 " command failed\n"); 3199 listlength = 0; 3200 } 3201 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry 3202 if (hba[cntl_num]->num_luns > CISS_MAX_LUN) { 3203 printk(KERN_ERR 3204 "ciss: only %d number of logical volumes supported\n", 3205 CISS_MAX_LUN); 3206 hba[cntl_num]->num_luns = CISS_MAX_LUN; 3207 } 3208#ifdef CCISS_DEBUG 3209 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", 3210 ld_buff->LUNListLength[0], ld_buff->LUNListLength[1], 3211 ld_buff->LUNListLength[2], ld_buff->LUNListLength[3], 3212 hba[cntl_num]->num_luns); 3213#endif /* CCISS_DEBUG */ 3214 3215 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1; 3216 for (i = 0; i < CISS_MAX_LUN; i++) { 3217 if (i < hba[cntl_num]->num_luns) { 3218 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3])) 3219 << 24; 3220 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2])) 3221 << 16; 3222 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1])) 3223 << 8; 3224 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]); 3225 3226 hba[cntl_num]->drv[i].LunID = lunid; 3227 3228#ifdef CCISS_DEBUG 3229 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i, 3230 ld_buff->LUN[i][0], ld_buff->LUN[i][1], 3231 ld_buff->LUN[i][2], ld_buff->LUN[i][3], 3232 hba[cntl_num]->drv[i].LunID); 3233#endif /* CCISS_DEBUG */ 3234 3235 /* testing to see if 16-byte CDBs are already being used */ 3236 if(hba[cntl_num]->cciss_read == CCISS_READ_16) { 3237 cciss_read_capacity_16(cntl_num, i, 0, 3238 &total_size, &block_size); 3239 goto geo_inq; 3240 } 3241 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size); 3242 3243 /* If read_capacity returns all F's the logical is >2TB */ 3244 /* so we switch to 16-byte CDBs for all read/write ops */ 3245 if(total_size == 0xFFFFFFFFULL) { 3246 cciss_read_capacity_16(cntl_num, i, 0, 3247 &total_size, &block_size); 3248 hba[cntl_num]->cciss_read = CCISS_READ_16; 3249 hba[cntl_num]->cciss_write = CCISS_WRITE_16; 3250 } else { 3251 hba[cntl_num]->cciss_read = CCISS_READ_10; 3252 hba[cntl_num]->cciss_write = CCISS_WRITE_10; 3253 } 3254geo_inq: 3255 cciss_geometry_inquiry(cntl_num, i, 0, total_size, 3256 block_size, inq_buff, 3257 &hba[cntl_num]->drv[i]); 3258 } else { 3259 /* initialize raid_level to indicate a free space */ 3260 hba[cntl_num]->drv[i].raid_level = -1; 3261 } 3262 } 3263 kfree(ld_buff); 3264 kfree(inq_buff); 3265} 3266 3267/* Function to find the first free pointer into our hba[] array */ 3268/* Returns -1 if no free entries are left. */ 3269static int alloc_cciss_hba(void) 3270{ 3271 int i; 3272 3273 for (i = 0; i < MAX_CTLR; i++) { 3274 if (!hba[i]) { 3275 ctlr_info_t *p; 3276 3277 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL); 3278 if (!p) 3279 goto Enomem; 3280 p->gendisk[0] = alloc_disk(1 << NWD_SHIFT); 3281 if (!p->gendisk[0]) { 3282 kfree(p); 3283 goto Enomem; 3284 } 3285 hba[i] = p; 3286 return i; 3287 } 3288 } 3289 printk(KERN_WARNING "cciss: This driver supports a maximum" 3290 " of %d controllers.\n", MAX_CTLR); 3291 return -1; 3292Enomem: 3293 printk(KERN_ERR "cciss: out of memory.\n"); 3294 return -1; 3295} 3296 3297static void free_hba(int i) 3298{ 3299 ctlr_info_t *p = hba[i]; 3300 int n; 3301 3302 hba[i] = NULL; 3303 for (n = 0; n < CISS_MAX_LUN; n++) 3304 put_disk(p->gendisk[n]); 3305 kfree(p); 3306} 3307 3308/* 3309 * This is it. Find all the controllers and register them. I really hate 3310 * stealing all these major device numbers. 3311 * returns the number of block devices registered. 3312 */ 3313static int __devinit cciss_init_one(struct pci_dev *pdev, 3314 const struct pci_device_id *ent) 3315{ 3316 int i; 3317 int j = 0; 3318 int rc; 3319 int dac; 3320 3321 i = alloc_cciss_hba(); 3322 if (i < 0) 3323 return -1; 3324 3325 hba[i]->busy_initializing = 1; 3326 3327 if (cciss_pci_init(hba[i], pdev) != 0) 3328 goto clean1; 3329 3330 sprintf(hba[i]->devname, "cciss%d", i); 3331 hba[i]->ctlr = i; 3332 hba[i]->pdev = pdev; 3333 3334 /* configure PCI DMA stuff */ 3335 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) 3336 dac = 1; 3337 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) 3338 dac = 0; 3339 else { 3340 printk(KERN_ERR "cciss: no suitable DMA available\n"); 3341 goto clean1; 3342 } 3343 3344 /* 3345 * register with the major number, or get a dynamic major number 3346 * by passing 0 as argument. This is done for greater than 3347 * 8 controller support. 3348 */ 3349 if (i < MAX_CTLR_ORIG) 3350 hba[i]->major = COMPAQ_CISS_MAJOR + i; 3351 rc = register_blkdev(hba[i]->major, hba[i]->devname); 3352 if (rc == -EBUSY || rc == -EINVAL) { 3353 printk(KERN_ERR 3354 "cciss: Unable to get major number %d for %s " 3355 "on hba %d\n", hba[i]->major, hba[i]->devname, i); 3356 goto clean1; 3357 } else { 3358 if (i >= MAX_CTLR_ORIG) 3359 hba[i]->major = rc; 3360 } 3361 3362 /* make sure the board interrupts are off */ 3363 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF); 3364 if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr, 3365 IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) { 3366 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n", 3367 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname); 3368 goto clean2; 3369 } 3370 3371 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n", 3372 hba[i]->devname, pdev->device, pci_name(pdev), 3373 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not"); 3374 3375 hba[i]->cmd_pool_bits = 3376 kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG - 3377 1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL); 3378 hba[i]->cmd_pool = (CommandList_struct *) 3379 pci_alloc_consistent(hba[i]->pdev, 3380 hba[i]->nr_cmds * sizeof(CommandList_struct), 3381 &(hba[i]->cmd_pool_dhandle)); 3382 hba[i]->errinfo_pool = (ErrorInfo_struct *) 3383 pci_alloc_consistent(hba[i]->pdev, 3384 hba[i]->nr_cmds * sizeof(ErrorInfo_struct), 3385 &(hba[i]->errinfo_pool_dhandle)); 3386 if ((hba[i]->cmd_pool_bits == NULL) 3387 || (hba[i]->cmd_pool == NULL) 3388 || (hba[i]->errinfo_pool == NULL)) { 3389 printk(KERN_ERR "cciss: out of memory"); 3390 goto clean4; 3391 } 3392#ifdef CONFIG_CISS_SCSI_TAPE 3393 hba[i]->scsi_rejects.complete = 3394 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) * 3395 (hba[i]->nr_cmds + 5), GFP_KERNEL); 3396 if (hba[i]->scsi_rejects.complete == NULL) { 3397 printk(KERN_ERR "cciss: out of memory"); 3398 goto clean4; 3399 } 3400#endif 3401 spin_lock_init(&hba[i]->lock); 3402 3403 /* Initialize the pdev driver private data. 3404 have it point to hba[i]. */ 3405 pci_set_drvdata(pdev, hba[i]); 3406 /* command and error info recs zeroed out before 3407 they are used */ 3408 memset(hba[i]->cmd_pool_bits, 0, 3409 ((hba[i]->nr_cmds + BITS_PER_LONG - 3410 1) / BITS_PER_LONG) * sizeof(unsigned long)); 3411 3412#ifdef CCISS_DEBUG 3413 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i); 3414#endif /* CCISS_DEBUG */ 3415 3416 cciss_getgeometry(i); 3417 3418 cciss_scsi_setup(i); 3419 3420 /* Turn the interrupts on so we can service requests */ 3421 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON); 3422 3423 cciss_procinit(i); 3424 3425 hba[i]->cciss_max_sectors = 2048; 3426 3427 hba[i]->busy_initializing = 0; 3428 3429 do { 3430 drive_info_struct *drv = &(hba[i]->drv[j]); 3431 struct gendisk *disk = hba[i]->gendisk[j]; 3432 struct request_queue *q; 3433 3434 /* Check if the disk was allocated already */ 3435 if (!disk){ 3436 hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT); 3437 disk = hba[i]->gendisk[j]; 3438 } 3439 3440 /* Check that the disk was able to be allocated */ 3441 if (!disk) { 3442 printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j); 3443 goto clean4; 3444 } 3445 3446 q = blk_init_queue(do_cciss_request, &hba[i]->lock); 3447 if (!q) { 3448 printk(KERN_ERR 3449 "cciss: unable to allocate queue for disk %d\n", 3450 j); 3451 goto clean4; 3452 } 3453 drv->queue = q; 3454 3455 q->backing_dev_info.ra_pages = READ_AHEAD; 3456 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask); 3457 3458 /* This is a hardware imposed limit. */ 3459 blk_queue_max_hw_segments(q, MAXSGENTRIES); 3460 3461 /* This is a limit in the driver and could be eliminated. */ 3462 blk_queue_max_phys_segments(q, MAXSGENTRIES); 3463 3464 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors); 3465 3466 blk_queue_softirq_done(q, cciss_softirq_done); 3467 3468 q->queuedata = hba[i]; 3469 sprintf(disk->disk_name, "cciss/c%dd%d", i, j); 3470 disk->major = hba[i]->major; 3471 disk->first_minor = j << NWD_SHIFT; 3472 disk->fops = &cciss_fops; 3473 disk->queue = q; 3474 disk->private_data = drv; 3475 disk->driverfs_dev = &pdev->dev; 3476 /* we must register the controller even if no disks exist */ 3477 /* this is for the online array utilities */ 3478 if (!drv->heads && j) 3479 continue; 3480 blk_queue_hardsect_size(q, drv->block_size); 3481 set_capacity(disk, drv->nr_blocks); 3482 add_disk(disk); 3483 j++; 3484 } while (j <= hba[i]->highest_lun); 3485 3486 return 1; 3487 3488 clean4: 3489#ifdef CONFIG_CISS_SCSI_TAPE 3490 kfree(hba[i]->scsi_rejects.complete); 3491#endif 3492 kfree(hba[i]->cmd_pool_bits); 3493 if (hba[i]->cmd_pool) 3494 pci_free_consistent(hba[i]->pdev, 3495 hba[i]->nr_cmds * sizeof(CommandList_struct), 3496 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle); 3497 if (hba[i]->errinfo_pool) 3498 pci_free_consistent(hba[i]->pdev, 3499 hba[i]->nr_cmds * sizeof(ErrorInfo_struct), 3500 hba[i]->errinfo_pool, 3501 hba[i]->errinfo_pool_dhandle); 3502 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]); 3503 clean2: 3504 unregister_blkdev(hba[i]->major, hba[i]->devname); 3505 clean1: 3506 hba[i]->busy_initializing = 0; 3507 /* cleanup any queues that may have been initialized */ 3508 for (j=0; j <= hba[i]->highest_lun; j++){ 3509 drive_info_struct *drv = &(hba[i]->drv[j]); 3510 if (drv->queue) 3511 blk_cleanup_queue(drv->queue); 3512 } 3513 /* 3514 * Deliberately omit pci_disable_device(): it does something nasty to 3515 * Smart Array controllers that pci_enable_device does not undo 3516 */ 3517 pci_release_regions(pdev); 3518 pci_set_drvdata(pdev, NULL); 3519 free_hba(i); 3520 return -1; 3521} 3522 3523static void cciss_shutdown(struct pci_dev *pdev) 3524{ 3525 ctlr_info_t *tmp_ptr; 3526 int i; 3527 char flush_buf[4]; 3528 int return_code; 3529 3530 tmp_ptr = pci_get_drvdata(pdev); 3531 if (tmp_ptr == NULL) 3532 return; 3533 i = tmp_ptr->ctlr; 3534 if (hba[i] == NULL) 3535 return; 3536 3537 /* Turn board interrupts off and send the flush cache command */ 3538 /* sendcmd will turn off interrupt, and send the flush... 3539 * To write all data in the battery backed cache to disks */ 3540 memset(flush_buf, 0, 4); 3541 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL, 3542 TYPE_CMD); 3543 if (return_code == IO_OK) { 3544 printk(KERN_INFO "Completed flushing cache on controller %d\n", i); 3545 } else { 3546 printk(KERN_WARNING "Error flushing cache on controller %d\n", i); 3547 } 3548 free_irq(hba[i]->intr[2], hba[i]); 3549} 3550 3551static void __devexit cciss_remove_one(struct pci_dev *pdev) 3552{ 3553 ctlr_info_t *tmp_ptr; 3554 int i, j; 3555 3556 if (pci_get_drvdata(pdev) == NULL) { 3557 printk(KERN_ERR "cciss: Unable to remove device \n"); 3558 return; 3559 } 3560 tmp_ptr = pci_get_drvdata(pdev); 3561 i = tmp_ptr->ctlr; 3562 if (hba[i] == NULL) { 3563 printk(KERN_ERR "cciss: device appears to " 3564 "already be removed \n"); 3565 return; 3566 } 3567 3568 remove_proc_entry(hba[i]->devname, proc_cciss); 3569 unregister_blkdev(hba[i]->major, hba[i]->devname); 3570 3571 /* remove it from the disk list */ 3572 for (j = 0; j < CISS_MAX_LUN; j++) { 3573 struct gendisk *disk = hba[i]->gendisk[j]; 3574 if (disk) { 3575 struct request_queue *q = disk->queue; 3576 3577 if (disk->flags & GENHD_FL_UP) 3578 del_gendisk(disk); 3579 if (q) 3580 blk_cleanup_queue(q); 3581 } 3582 } 3583 3584 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */ 3585 3586 cciss_shutdown(pdev); 3587 3588#ifdef CONFIG_PCI_MSI 3589 if (hba[i]->msix_vector) 3590 pci_disable_msix(hba[i]->pdev); 3591 else if (hba[i]->msi_vector) 3592 pci_disable_msi(hba[i]->pdev); 3593#endif /* CONFIG_PCI_MSI */ 3594 3595 iounmap(hba[i]->vaddr); 3596 3597 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct), 3598 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle); 3599 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct), 3600 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle); 3601 kfree(hba[i]->cmd_pool_bits); 3602#ifdef CONFIG_CISS_SCSI_TAPE 3603 kfree(hba[i]->scsi_rejects.complete); 3604#endif 3605 /* 3606 * Deliberately omit pci_disable_device(): it does something nasty to 3607 * Smart Array controllers that pci_enable_device does not undo 3608 */ 3609 pci_release_regions(pdev); 3610 pci_set_drvdata(pdev, NULL); 3611 free_hba(i); 3612} 3613 3614static struct pci_driver cciss_pci_driver = { 3615 .name = "cciss", 3616 .probe = cciss_init_one, 3617 .remove = __devexit_p(cciss_remove_one), 3618 .id_table = cciss_pci_device_id, /* id_table */ 3619 .shutdown = cciss_shutdown, 3620}; 3621 3622/* 3623 * This is it. Register the PCI driver information for the cards we control 3624 * the OS will call our registered routines when it finds one of our cards. 3625 */ 3626static int __init cciss_init(void) 3627{ 3628 printk(KERN_INFO DRIVER_NAME "\n"); 3629 3630 /* Register for our PCI devices */ 3631 return pci_register_driver(&cciss_pci_driver); 3632} 3633 3634static void __exit cciss_cleanup(void) 3635{ 3636 int i; 3637 3638 pci_unregister_driver(&cciss_pci_driver); 3639 /* double check that all controller entrys have been removed */ 3640 for (i = 0; i < MAX_CTLR; i++) { 3641 if (hba[i] != NULL) { 3642 printk(KERN_WARNING "cciss: had to remove" 3643 " controller %d\n", i); 3644 cciss_remove_one(hba[i]->pdev); 3645 } 3646 } 3647 remove_proc_entry("cciss", proc_root_driver); 3648} 3649 3650static void fail_all_cmds(unsigned long ctlr) 3651{ 3652 /* If we get here, the board is apparently dead. */ 3653 ctlr_info_t *h = hba[ctlr]; 3654 CommandList_struct *c; 3655 unsigned long flags; 3656 3657 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr); 3658 h->alive = 0; /* the controller apparently died... */ 3659 3660 spin_lock_irqsave(CCISS_LOCK(ctlr), flags); 3661 3662 pci_disable_device(h->pdev); /* Make sure it is really dead. */ 3663 3664 /* move everything off the request queue onto the completed queue */ 3665 while ((c = h->reqQ) != NULL) { 3666 removeQ(&(h->reqQ), c); 3667 h->Qdepth--; 3668 addQ(&(h->cmpQ), c); 3669 } 3670 3671 /* Now, fail everything on the completed queue with a HW error */ 3672 while ((c = h->cmpQ) != NULL) { 3673 removeQ(&h->cmpQ, c); 3674 c->err_info->CommandStatus = CMD_HARDWARE_ERR; 3675 if (c->cmd_type == CMD_RWREQ) { 3676 complete_command(h, c, 0); 3677 } else if (c->cmd_type == CMD_IOCTL_PEND) 3678 complete(c->waiting); 3679#ifdef CONFIG_CISS_SCSI_TAPE 3680 else if (c->cmd_type == CMD_SCSI) 3681 complete_scsi_command(c, 0, 0); 3682#endif 3683 } 3684 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); 3685 return; 3686} 3687 3688module_init(cciss_init); 3689module_exit(cciss_cleanup); 3690