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