err.no Git - linux-2.6/blob - drivers/block/cciss.c

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