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