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