git.oblomov.eu Git - linux-2.6/blob - drivers/block/cciss.c

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