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