projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cciss: return -EFAULT if copy_from_user() fails
[GitHub/mt8127/android_kernel_alcatel_ttab.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)) {
f7108f91 1137 status = -EFAULT;
7c832835
BH		 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 }
7b30f092
JA		 1295 }
1296 }
1297}
1298
ca1e0484
MM		 1299static void cciss_softirq_done(struct request *rq)
1300{
1301 CommandList_struct *cmd = rq->completion_data;
1302 ctlr_info_t *h = hba[cmd->ctlr];
1303 unsigned long flags;
1304 u64bit temp64;
1305 int i, ddir;
1306
1307 if (cmd->Request.Type.Direction == XFER_READ)
1308 ddir = PCI_DMA_FROMDEVICE;
1309 else
1310 ddir = PCI_DMA_TODEVICE;
1311
1312 /* command did not need to be retried */
1313 /* unmap the DMA mapping for all the scatter gather elements */
7c832835 1314 for (i = 0; i < cmd->Header.SGList; i++) {
ca1e0484
MM		 1315 temp64.val32.lower = cmd->SG[i].Addr.lower;
1316 temp64.val32.upper = cmd->SG[i].Addr.upper;
1317 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1318 }
1319
ca1e0484
MM		 1320#ifdef CCISS_DEBUG
1321 printk("Done with %p\n", rq);
7c832835 1322#endif /* CCISS_DEBUG */
ca1e0484 1323
3daeea29
KU		 1324 if (blk_end_request(rq, (rq->errors == 0) ? 0 : -EIO, blk_rq_bytes(rq)))
1325 BUG();
1326
ca1e0484 1327 spin_lock_irqsave(&h->lock, flags);
7c832835 1328 cmd_free(h, cmd, 1);
7b30f092 1329 cciss_check_queues(h);
ca1e0484
MM		 1330 spin_unlock_irqrestore(&h->lock, flags);
1331}
1332
ddd47442
MM		 1333/* This function will check the usage_count of the drive to be updated/added.
1334 * If the usage_count is zero then the drive information will be updated and
1335 * the disk will be re-registered with the kernel. If not then it will be
1336 * left alone for the next reboot. The exception to this is disk 0 which
1337 * will always be left registered with the kernel since it is also the
1338 * controller node. Any changes to disk 0 will show up on the next
1339 * reboot.
7c832835 1340 */
ddd47442 1341static void cciss_update_drive_info(int ctlr, int drv_index)
7c832835 1342{
ddd47442
MM		 1343 ctlr_info_t *h = hba[ctlr];
1344 struct gendisk *disk;
ddd47442
MM		 1345 InquiryData_struct *inq_buff = NULL;
1346 unsigned int block_size;
00988a35 1347 sector_t total_size;
ddd47442
MM		 1348 unsigned long flags = 0;
1349 int ret = 0;
1350
7c832835
BH		 1351 /* if the disk already exists then deregister it before proceeding */
1352 if (h->drv[drv_index].raid_level != -1) {
ddd47442
MM		 1353 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1354 h->drv[drv_index].busy_configuring = 1;
1355 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
e14ac670 1356
1357 /* deregister_disk sets h->drv[drv_index].queue = NULL */
1358 /* which keeps the interrupt handler from starting */
1359 /* the queue. */
ddd47442 1360 ret = deregister_disk(h->gendisk[drv_index],
7c832835 1361 &h->drv[drv_index], 0);
ddd47442
MM		 1362 h->drv[drv_index].busy_configuring = 0;
1363 }
1364
1365 /* If the disk is in use return */
1366 if (ret)
1367 return;
1368
d14c4ab5 1369 /* Get information about the disk and modify the driver structure */
7c832835 1370 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
ddd47442
MM		 1371 if (inq_buff == NULL)
1372 goto mem_msg;
1373
97c06978
MMOD		 1374 /* testing to see if 16-byte CDBs are already being used */
1375 if (h->cciss_read == CCISS_READ_16) {
1376 cciss_read_capacity_16(h->ctlr, drv_index, 1,
1377 &total_size, &block_size);
1378 goto geo_inq;
1379 }
1380
00988a35 1381 cciss_read_capacity(ctlr, drv_index, 1,
7c832835 1382 &total_size, &block_size);
00988a35 1383
97c06978
MMOD		 1384 /* if read_capacity returns all F's this volume is >2TB in size */
1385 /* so we switch to 16-byte CDB's for all read/write ops */
1386 if (total_size == 0xFFFFFFFFULL) {
00988a35
MMOD		 1387 cciss_read_capacity_16(ctlr, drv_index, 1,
1388 &total_size, &block_size);
1389 h->cciss_read = CCISS_READ_16;
1390 h->cciss_write = CCISS_WRITE_16;
1391 } else {
1392 h->cciss_read = CCISS_READ_10;
1393 h->cciss_write = CCISS_WRITE_10;
1394 }
97c06978 1395geo_inq:
ddd47442 1396 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
7c832835 1397 inq_buff, &h->drv[drv_index]);
ddd47442
MM		 1398
1399 ++h->num_luns;
1400 disk = h->gendisk[drv_index];
1401 set_capacity(disk, h->drv[drv_index].nr_blocks);
1402
ddd47442 1403 /* if it's the controller it's already added */
7c832835 1404 if (drv_index) {
ddd47442 1405 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
799202cb
MM		 1406 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
1407 disk->major = h->major;
1408 disk->first_minor = drv_index << NWD_SHIFT;
1409 disk->fops = &cciss_fops;
1410 disk->private_data = &h->drv[drv_index];
ddd47442
MM		 1411
1412 /* Set up queue information */
ddd47442
MM		 1413 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1414
1415 /* This is a hardware imposed limit. */
1416 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1417
1418 /* This is a limit in the driver and could be eliminated. */
1419 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1420
92c4231a 1421 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
ddd47442 1422
ca1e0484
MM		 1423 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1424
ddd47442
MM		 1425 disk->queue->queuedata = hba[ctlr];
1426
1427 blk_queue_hardsect_size(disk->queue,
7c832835 1428 hba[ctlr]->drv[drv_index].block_size);
ddd47442 1429
e14ac670 1430 /* Make sure all queue data is written out before */
1431 /* setting h->drv[drv_index].queue, as setting this */
1432 /* allows the interrupt handler to start the queue */
1433 wmb();
ddd47442
MM		 1434 h->drv[drv_index].queue = disk->queue;
1435 add_disk(disk);
1436 }
1437
7c832835 1438 freeret:
ddd47442
MM		 1439 kfree(inq_buff);
1440 return;
7c832835 1441 mem_msg:
ddd47442
MM		 1442 printk(KERN_ERR "cciss: out of memory\n");
1443 goto freeret;
1444}
1445
1446/* This function will find the first index of the controllers drive array
1447 * that has a -1 for the raid_level and will return that index. This is
1448 * where new drives will be added. If the index to be returned is greater
1449 * than the highest_lun index for the controller then highest_lun is set
1450 * to this new index. If there are no available indexes then -1 is returned.
7c832835 1451 */
ddd47442
MM		 1452static int cciss_find_free_drive_index(int ctlr)
1453{
1454 int i;
1455
7c832835
BH		 1456 for (i = 0; i < CISS_MAX_LUN; i++) {
1457 if (hba[ctlr]->drv[i].raid_level == -1) {
ddd47442
MM		 1458 if (i > hba[ctlr]->highest_lun)
1459 hba[ctlr]->highest_lun = i;
1460 return i;
1461 }
1462 }
1463 return -1;
1464}
1465
1466/* This function will add and remove logical drives from the Logical
d14c4ab5 1467 * drive array of the controller and maintain persistency of ordering
ddd47442
MM		 1468 * so that mount points are preserved until the next reboot. This allows
1469 * for the removal of logical drives in the middle of the drive array
1470 * without a re-ordering of those drives.
1471 * INPUT
1472 * h = The controller to perform the operations on
1473 * del_disk = The disk to remove if specified. If the value given
1474 * is NULL then no disk is removed.
7c832835 1475 */
ddd47442 1476static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1da177e4 1477{
ddd47442
MM		 1478 int ctlr = h->ctlr;
1479 int num_luns;
1480 ReportLunData_struct *ld_buff = NULL;
1481 drive_info_struct *drv = NULL;
1482 int return_code;
1483 int listlength = 0;
1484 int i;
1485 int drv_found;
1486 int drv_index = 0;
1487 __u32 lunid = 0;
1da177e4 1488 unsigned long flags;
ddd47442
MM		 1489
1490 /* Set busy_configuring flag for this operation */
1491 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
7c832835 1492 if (h->busy_configuring) {
ddd47442
MM		 1493 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1494 return -EBUSY;
1495 }
1496 h->busy_configuring = 1;
1497
1498 /* if del_disk is NULL then we are being called to add a new disk
1499 * and update the logical drive table. If it is not NULL then
1500 * we will check if the disk is in use or not.
1501 */
7c832835 1502 if (del_disk != NULL) {
ddd47442
MM		 1503 drv = get_drv(del_disk);
1504 drv->busy_configuring = 1;
1505 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1506 return_code = deregister_disk(del_disk, drv, 1);
1507 drv->busy_configuring = 0;
1508 h->busy_configuring = 0;
1509 return return_code;
1510 } else {
1511 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1512 if (!capable(CAP_SYS_RAWIO))
1513 return -EPERM;
1514
1515 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1516 if (ld_buff == NULL)
1517 goto mem_msg;
1518
1519 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
7c832835
BH		 1520 sizeof(ReportLunData_struct), 0,
1521 0, 0, TYPE_CMD);
1522
1523 if (return_code == IO_OK) {
799202cb 1524 listlength =
4c1f2b31 1525 be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
7c832835 1526 } else { /* reading number of logical volumes failed */
ddd47442 1527 printk(KERN_WARNING "cciss: report logical volume"
7c832835 1528 " command failed\n");
ddd47442
MM		 1529 listlength = 0;
1530 goto freeret;
1531 }
1532
1533 num_luns = listlength / 8; /* 8 bytes per entry */
7c832835 1534 if (num_luns > CISS_MAX_LUN) {
ddd47442
MM		 1535 num_luns = CISS_MAX_LUN;
1536 printk(KERN_WARNING "cciss: more luns configured"
7c832835
BH		 1537 " on controller than can be handled by"
1538 " this driver.\n");
ddd47442
MM		 1539 }
1540
1541 /* Compare controller drive array to drivers drive array.
7c832835
BH		 1542 * Check for updates in the drive information and any new drives
1543 * on the controller.
1544 */
1545 for (i = 0; i < num_luns; i++) {
ddd47442
MM		 1546 int j;
1547
1548 drv_found = 0;
1549
7c832835
BH		 1550 lunid = (0xff &
1551 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1552 lunid |= (0xff &
1553 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1554 lunid |= (0xff &
1555 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1556 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
ddd47442
MM		 1557
1558 /* Find if the LUN is already in the drive array
1559 * of the controller. If so then update its info
1560 * if not is use. If it does not exist then find
1561 * the first free index and add it.
7c832835
BH		 1562 */
1563 for (j = 0; j <= h->highest_lun; j++) {
1564 if (h->drv[j].LunID == lunid) {
ddd47442
MM		 1565 drv_index = j;
1566 drv_found = 1;
1567 }
1568 }
1569
1570 /* check if the drive was found already in the array */
7c832835 1571 if (!drv_found) {
ddd47442
MM		 1572 drv_index = cciss_find_free_drive_index(ctlr);
1573 if (drv_index == -1)
1574 goto freeret;
1575
799202cb
MM		 1576 /*Check if the gendisk needs to be allocated */
1577 if (!h->gendisk[drv_index]){
1578 h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
1579 if (!h->gendisk[drv_index]){
1580 printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
1581 goto mem_msg;
1582 }
1583 }
ddd47442
MM		 1584 }
1585 h->drv[drv_index].LunID = lunid;
1586 cciss_update_drive_info(ctlr, drv_index);
7c832835
BH		 1587 } /* end for */
1588 } /* end else */
ddd47442 1589
7c832835 1590 freeret:
ddd47442
MM		 1591 kfree(ld_buff);
1592 h->busy_configuring = 0;
1593 /* We return -1 here to tell the ACU that we have registered/updated
1594 * all of the drives that we can and to keep it from calling us
1595 * additional times.
7c832835 1596 */
ddd47442 1597 return -1;
7c832835 1598 mem_msg:
ddd47442
MM		 1599 printk(KERN_ERR "cciss: out of memory\n");
1600 goto freeret;
1601}
1602
1603/* This function will deregister the disk and it's queue from the
1604 * kernel. It must be called with the controller lock held and the
1605 * drv structures busy_configuring flag set. It's parameters are:
1606 *
1607 * disk = This is the disk to be deregistered
1608 * drv = This is the drive_info_struct associated with the disk to be
1609 * deregistered. It contains information about the disk used
1610 * by the driver.
1611 * clear_all = This flag determines whether or not the disk information
1612 * is going to be completely cleared out and the highest_lun
1613 * reset. Sometimes we want to clear out information about
d14c4ab5 1614 * the disk in preparation for re-adding it. In this case
ddd47442
MM		 1615 * the highest_lun should be left unchanged and the LunID
1616 * should not be cleared.
1617*/
1618static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1619 int clear_all)
1620{
799202cb 1621 int i;
1da177e4 1622 ctlr_info_t *h = get_host(disk);
1da177e4
LT		 1623
1624 if (!capable(CAP_SYS_RAWIO))
1625 return -EPERM;
1626
1da177e4 1627 /* make sure logical volume is NOT is use */
7c832835
BH		 1628 if (clear_all || (h->gendisk[0] == disk)) {
1629 if (drv->usage_count > 1)
1630 return -EBUSY;
1631 } else if (drv->usage_count > 0)
1632 return -EBUSY;
1da177e4 1633
ddd47442
MM		 1634 /* invalidate the devices and deregister the disk. If it is disk
1635 * zero do not deregister it but just zero out it's values. This
1636 * allows us to delete disk zero but keep the controller registered.
7c832835
BH		 1637 */
1638 if (h->gendisk[0] != disk) {
5a9df732
AB		 1639 struct request_queue *q = disk->queue;
1640 if (disk->flags & GENHD_FL_UP)
1641 del_gendisk(disk);
1642 if (q) {
1643 blk_cleanup_queue(q);
1644 /* Set drv->queue to NULL so that we do not try
1645 * to call blk_start_queue on this queue in the
1646 * interrupt handler
1647 */
1648 drv->queue = NULL;
1649 }
1650 /* If clear_all is set then we are deleting the logical
1651 * drive, not just refreshing its info. For drives
1652 * other than disk 0 we will call put_disk. We do not
1653 * do this for disk 0 as we need it to be able to
1654 * configure the controller.
1655 */
1656 if (clear_all){
1657 /* This isn't pretty, but we need to find the
1658 * disk in our array and NULL our the pointer.
1659 * This is so that we will call alloc_disk if
1660 * this index is used again later.
799202cb 1661 */
5a9df732
AB		 1662 for (i=0; i < CISS_MAX_LUN; i++){
1663 if(h->gendisk[i] == disk){
1664 h->gendisk[i] = NULL;
1665 break;
799202cb 1666 }
799202cb 1667 }
5a9df732 1668 put_disk(disk);
ddd47442 1669 }
799202cb
MM		 1670 } else {
1671 set_capacity(disk, 0);
ddd47442
MM		 1672 }
1673
1674 --h->num_luns;
1675 /* zero out the disk size info */
1676 drv->nr_blocks = 0;
1677 drv->block_size = 0;
1678 drv->heads = 0;
1679 drv->sectors = 0;
1680 drv->cylinders = 0;
1681 drv->raid_level = -1; /* This can be used as a flag variable to
1682 * indicate that this element of the drive
1683 * array is free.
7c832835
BH		 1684 */
1685
1686 if (clear_all) {
1687 /* check to see if it was the last disk */
1688 if (drv == h->drv + h->highest_lun) {
1689 /* if so, find the new hightest lun */
1690 int i, newhighest = -1;
1691 for (i = 0; i < h->highest_lun; i++) {
1692 /* if the disk has size > 0, it is available */
ddd47442 1693 if (h->drv[i].heads)
7c832835
BH		 1694 newhighest = i;
1695 }
1696 h->highest_lun = newhighest;
1da177e4 1697 }
ddd47442 1698
7c832835 1699 drv->LunID = 0;
ddd47442 1700 }
e2019b58 1701 return 0;
1da177e4 1702}
ddd47442 1703
7c832835
BH		 1704static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
1705 1: address logical volume log_unit,
1706 2: periph device address is scsi3addr */
1707 unsigned int log_unit, __u8 page_code,
1708 unsigned char *scsi3addr, int cmd_type)
1da177e4 1709{
7c832835 1710 ctlr_info_t *h = hba[ctlr];
1da177e4
LT		 1711 u64bit buff_dma_handle;
1712 int status = IO_OK;
1713
1714 c->cmd_type = CMD_IOCTL_PEND;
1715 c->Header.ReplyQueue = 0;
7c832835 1716 if (buff != NULL) {
1da177e4 1717 c->Header.SGList = 1;
7c832835 1718 c->Header.SGTotal = 1;
1da177e4
LT		 1719 } else {
1720 c->Header.SGList = 0;
7c832835 1721 c->Header.SGTotal = 0;
1da177e4
LT		 1722 }
1723 c->Header.Tag.lower = c->busaddr;
1724
1725 c->Request.Type.Type = cmd_type;
1726 if (cmd_type == TYPE_CMD) {
7c832835
BH		 1727 switch (cmd) {
1728 case CISS_INQUIRY:
1da177e4 1729 /* If the logical unit number is 0 then, this is going
7c832835
BH		 1730 to controller so It's a physical command
1731 mode = 0 target = 0. So we have nothing to write.
1732 otherwise, if use_unit_num == 1,
1733 mode = 1(volume set addressing) target = LUNID
1734 otherwise, if use_unit_num == 2,
1735 mode = 0(periph dev addr) target = scsi3addr */
1da177e4 1736 if (use_unit_num == 1) {
7c832835
BH		 1737 c->Header.LUN.LogDev.VolId =
1738 h->drv[log_unit].LunID;
1739 c->Header.LUN.LogDev.Mode = 1;
1da177e4 1740 } else if (use_unit_num == 2) {
7c832835
BH		 1741 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1742 8);
1da177e4
LT		 1743 c->Header.LUN.LogDev.Mode = 0;
1744 }
1745 /* are we trying to read a vital product page */
7c832835 1746 if (page_code != 0) {
1da177e4
LT		 1747 c->Request.CDB[1] = 0x01;
1748 c->Request.CDB[2] = page_code;
1749 }
1750 c->Request.CDBLen = 6;
7c832835 1751 c->Request.Type.Attribute = ATTR_SIMPLE;
1da177e4
LT		 1752 c->Request.Type.Direction = XFER_READ;
1753 c->Request.Timeout = 0;
7c832835
BH		 1754 c->Request.CDB[0] = CISS_INQUIRY;
1755 c->Request.CDB[4] = size & 0xFF;
1756 break;
1da177e4
LT		 1757 case CISS_REPORT_LOG:
1758 case CISS_REPORT_PHYS:
7c832835 1759 /* Talking to controller so It's a physical command
1da177e4 1760 mode = 00 target = 0. Nothing to write.
7c832835 1761 */
1da177e4
LT		 1762 c->Request.CDBLen = 12;
1763 c->Request.Type.Attribute = ATTR_SIMPLE;
1764 c->Request.Type.Direction = XFER_READ;
1765 c->Request.Timeout = 0;
1766 c->Request.CDB[0] = cmd;
7c832835 1767 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1da177e4
LT		 1768 c->Request.CDB[7] = (size >> 16) & 0xFF;
1769 c->Request.CDB[8] = (size >> 8) & 0xFF;
1770 c->Request.CDB[9] = size & 0xFF;
1771 break;
1772
1773 case CCISS_READ_CAPACITY:
1774 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1775 c->Header.LUN.LogDev.Mode = 1;
1776 c->Request.CDBLen = 10;
1777 c->Request.Type.Attribute = ATTR_SIMPLE;
1778 c->Request.Type.Direction = XFER_READ;
1779 c->Request.Timeout = 0;
1780 c->Request.CDB[0] = cmd;
7c832835 1781 break;
00988a35
MMOD		 1782 case CCISS_READ_CAPACITY_16:
1783 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1784 c->Header.LUN.LogDev.Mode = 1;
1785 c->Request.CDBLen = 16;
1786 c->Request.Type.Attribute = ATTR_SIMPLE;
1787 c->Request.Type.Direction = XFER_READ;
1788 c->Request.Timeout = 0;
1789 c->Request.CDB[0] = cmd;
1790 c->Request.CDB[1] = 0x10;
1791 c->Request.CDB[10] = (size >> 24) & 0xFF;
1792 c->Request.CDB[11] = (size >> 16) & 0xFF;
1793 c->Request.CDB[12] = (size >> 8) & 0xFF;
1794 c->Request.CDB[13] = size & 0xFF;
1795 c->Request.Timeout = 0;
1796 c->Request.CDB[0] = cmd;
1797 break;
1da177e4
LT		 1798 case CCISS_CACHE_FLUSH:
1799 c->Request.CDBLen = 12;
1800 c->Request.Type.Attribute = ATTR_SIMPLE;
1801 c->Request.Type.Direction = XFER_WRITE;
1802 c->Request.Timeout = 0;
1803 c->Request.CDB[0] = BMIC_WRITE;
1804 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
7c832835 1805 break;
1da177e4
LT		 1806 default:
1807 printk(KERN_WARNING
7c832835 1808 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
e2019b58 1809 return IO_ERROR;
1da177e4
LT		 1810 }
1811 } else if (cmd_type == TYPE_MSG) {
1812 switch (cmd) {
7c832835 1813 case 0: /* ABORT message */
3da8b713 1814 c->Request.CDBLen = 12;
1815 c->Request.Type.Attribute = ATTR_SIMPLE;
1816 c->Request.Type.Direction = XFER_WRITE;
1817 c->Request.Timeout = 0;
7c832835
BH		 1818 c->Request.CDB[0] = cmd; /* abort */
1819 c->Request.CDB[1] = 0; /* abort a command */
3da8b713 1820 /* buff contains the tag of the command to abort */
1821 memcpy(&c->Request.CDB[4], buff, 8);
1822 break;
7c832835 1823 case 1: /* RESET message */
3da8b713 1824 c->Request.CDBLen = 12;
1825 c->Request.Type.Attribute = ATTR_SIMPLE;
1826 c->Request.Type.Direction = XFER_WRITE;
1827 c->Request.Timeout = 0;
1828 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
7c832835
BH		 1829 c->Request.CDB[0] = cmd; /* reset */
1830 c->Request.CDB[1] = 0x04; /* reset a LUN */
00988a35 1831 break;
1da177e4
LT		 1832 case 3: /* No-Op message */
1833 c->Request.CDBLen = 1;
1834 c->Request.Type.Attribute = ATTR_SIMPLE;
1835 c->Request.Type.Direction = XFER_WRITE;
1836 c->Request.Timeout = 0;
1837 c->Request.CDB[0] = cmd;
1838 break;
1839 default:
1840 printk(KERN_WARNING
7c832835 1841 "cciss%d: unknown message type %d\n", ctlr, cmd);
1da177e4
LT		 1842 return IO_ERROR;
1843 }
1844 } else {
1845 printk(KERN_WARNING
7c832835 1846 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1da177e4
LT		 1847 return IO_ERROR;
1848 }
1849 /* Fill in the scatter gather information */
1850 if (size > 0) {
1851 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
7c832835
BH		 1852 buff, size,
1853 PCI_DMA_BIDIRECTIONAL);
1da177e4
LT		 1854 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1855 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1856 c->SG[0].Len = size;
7c832835 1857 c->SG[0].Ext = 0; /* we are not chaining */
1da177e4
LT		 1858 }
1859 return status;
1860}
7c832835
BH		 1861
1862static int sendcmd_withirq(__u8 cmd,
1863 int ctlr,
1864 void *buff,
1865 size_t size,
1866 unsigned int use_unit_num,
1867 unsigned int log_unit, __u8 page_code, int cmd_type)
1da177e4
LT		 1868{
1869 ctlr_info_t *h = hba[ctlr];
1870 CommandList_struct *c;
7c832835 1871 u64bit buff_dma_handle;
1da177e4
LT		 1872 unsigned long flags;
1873 int return_status;
6e9a4738 1874 DECLARE_COMPLETION_ONSTACK(wait);
7c832835
BH		 1875
1876 if ((c = cmd_alloc(h, 0)) == NULL)
1da177e4
LT		 1877 return -ENOMEM;
1878 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
7c832835 1879 log_unit, page_code, NULL, cmd_type);
1da177e4
LT		 1880 if (return_status != IO_OK) {
1881 cmd_free(h, c, 0);
1882 return return_status;
1883 }
7c832835 1884 resend_cmd2:
1da177e4 1885 c->waiting = &wait;
7c832835 1886
1da177e4
LT		 1887 /* Put the request on the tail of the queue and send it */
1888 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1889 addQ(&h->reqQ, c);
1890 h->Qdepth++;
1891 start_io(h);
1892 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
7c832835 1893
1da177e4
LT		 1894 wait_for_completion(&wait);
1895
7c832835
BH		 1896 if (c->err_info->CommandStatus != 0) { /* an error has occurred */
1897 switch (c->err_info->CommandStatus) {
1898 case CMD_TARGET_STATUS:
1899 printk(KERN_WARNING "cciss: cmd %p has "
1900 " completed with errors\n", c);
1901 if (c->err_info->ScsiStatus) {
1902 printk(KERN_WARNING "cciss: cmd %p "
1903 "has SCSI Status = %x\n",
1904 c, c->err_info->ScsiStatus);
1905 }
1da177e4
LT		 1906
1907 break;
7c832835
BH		 1908 case CMD_DATA_UNDERRUN:
1909 case CMD_DATA_OVERRUN:
1da177e4
LT		 1910 /* expected for inquire and report lun commands */
1911 break;
7c832835
BH		 1912 case CMD_INVALID:
1913 printk(KERN_WARNING "cciss: Cmd %p is "
1914 "reported invalid\n", c);
1915 return_status = IO_ERROR;
1da177e4 1916 break;
7c832835
BH		 1917 case CMD_PROTOCOL_ERR:
1918 printk(KERN_WARNING "cciss: cmd %p has "
1919 "protocol error \n", c);
1920 return_status = IO_ERROR;
1da177e4 1921 break;
7c832835
BH		 1922 case CMD_HARDWARE_ERR:
1923 printk(KERN_WARNING "cciss: cmd %p had "
1924 " hardware error\n", c);
1925 return_status = IO_ERROR;
1da177e4 1926 break;
7c832835
BH		 1927 case CMD_CONNECTION_LOST:
1928 printk(KERN_WARNING "cciss: cmd %p had "
1929 "connection lost\n", c);
1930 return_status = IO_ERROR;
1da177e4 1931 break;
7c832835
BH		 1932 case CMD_ABORTED:
1933 printk(KERN_WARNING "cciss: cmd %p was "
1934 "aborted\n", c);
1935 return_status = IO_ERROR;
1da177e4 1936 break;
7c832835
BH		 1937 case CMD_ABORT_FAILED:
1938 printk(KERN_WARNING "cciss: cmd %p reports "
1939 "abort failed\n", c);
1940 return_status = IO_ERROR;
1941 break;
1942 case CMD_UNSOLICITED_ABORT:
1943 printk(KERN_WARNING
1944 "cciss%d: unsolicited abort %p\n", ctlr, c);
1945 if (c->retry_count < MAX_CMD_RETRIES) {
1946 printk(KERN_WARNING
1947 "cciss%d: retrying %p\n", ctlr, c);
1948 c->retry_count++;
1949 /* erase the old error information */
1950 memset(c->err_info, 0,
1951 sizeof(ErrorInfo_struct));
1952 return_status = IO_OK;
1953 INIT_COMPLETION(wait);
1954 goto resend_cmd2;
1955 }
1956 return_status = IO_ERROR;
1957 break;
1958 default:
1959 printk(KERN_WARNING "cciss: cmd %p returned "
1960 "unknown status %x\n", c,
1961 c->err_info->CommandStatus);
1962 return_status = IO_ERROR;
1da177e4 1963 }
7c832835 1964 }
1da177e4 1965 /* unlock the buffers from DMA */
bb2a37bf
MM		 1966 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1967 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
7c832835
BH		 1968 pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
1969 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1da177e4 1970 cmd_free(h, c, 0);
7c832835 1971 return return_status;
1da177e4 1972}
7c832835 1973
1da177e4 1974static void cciss_geometry_inquiry(int ctlr, int logvol,
00988a35 1975 int withirq, sector_t total_size,
7c832835
BH		 1976 unsigned int block_size,
1977 InquiryData_struct *inq_buff,
1978 drive_info_struct *drv)
1da177e4
LT		 1979{
1980 int return_code;
00988a35 1981 unsigned long t;
00988a35 1982
1da177e4
LT		 1983 memset(inq_buff, 0, sizeof(InquiryData_struct));
1984 if (withirq)
1985 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
7c832835
BH		 1986 inq_buff, sizeof(*inq_buff), 1,
1987 logvol, 0xC1, TYPE_CMD);
1da177e4
LT		 1988 else
1989 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
7c832835
BH		 1990 sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
1991 TYPE_CMD);
1da177e4 1992 if (return_code == IO_OK) {
7c832835 1993 if (inq_buff->data_byte[8] == 0xFF) {
1da177e4 1994 printk(KERN_WARNING
7c832835
BH		 1995 "cciss: reading geometry failed, volume "
1996 "does not support reading geometry\n");
1da177e4 1997 drv->heads = 255;
7c832835 1998 drv->sectors = 32; // Sectors per track
7f42d3b8 1999 drv->cylinders = total_size + 1;
89f97ad1 2000 drv->raid_level = RAID_UNKNOWN;
1da177e4 2001 } else {
1da177e4
LT		 2002 drv->heads = inq_buff->data_byte[6];
2003 drv->sectors = inq_buff->data_byte[7];
2004 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
2005 drv->cylinders += inq_buff->data_byte[5];
2006 drv->raid_level = inq_buff->data_byte[8];
3f7705ea
MW		 2007 }
2008 drv->block_size = block_size;
97c06978 2009 drv->nr_blocks = total_size + 1;
3f7705ea
MW		 2010 t = drv->heads * drv->sectors;
2011 if (t > 1) {
97c06978
MMOD		 2012 sector_t real_size = total_size + 1;
2013 unsigned long rem = sector_div(real_size, t);
3f7705ea 2014 if (rem)
97c06978
MMOD		 2015 real_size++;
2016 drv->cylinders = real_size;
1da177e4 2017 }
7c832835 2018 } else { /* Get geometry failed */
1da177e4
LT		 2019 printk(KERN_WARNING "cciss: reading geometry failed\n");
2020 }
cc088d10 2021 printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n",
7c832835 2022 drv->heads, drv->sectors, drv->cylinders);
1da177e4 2023}
7c832835 2024
1da177e4 2025static void
00988a35 2026cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
7c832835 2027 unsigned int *block_size)
1da177e4 2028{
00988a35 2029 ReadCapdata_struct *buf;
1da177e4 2030 int return_code;
1aebe187
MK		 2031
2032 buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
2033 if (!buf) {
00988a35
MMOD		 2034 printk(KERN_WARNING "cciss: out of memory\n");
2035 return;
2036 }
1aebe187 2037
1da177e4
LT		 2038 if (withirq)
2039 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
00988a35
MMOD		 2040 ctlr, buf, sizeof(ReadCapdata_struct),
2041 1, logvol, 0, TYPE_CMD);
1da177e4
LT		 2042 else
2043 return_code = sendcmd(CCISS_READ_CAPACITY,
00988a35
MMOD		 2044 ctlr, buf, sizeof(ReadCapdata_struct),
2045 1, logvol, 0, NULL, TYPE_CMD);
1da177e4 2046 if (return_code == IO_OK) {
4c1f2b31
AV		 2047 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
2048 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
7c832835 2049 } else { /* read capacity command failed */
1da177e4
LT		 2050 printk(KERN_WARNING "cciss: read capacity failed\n");
2051 *total_size = 0;
2052 *block_size = BLOCK_SIZE;
2053 }
97c06978 2054 if (*total_size != 0)
7b92aadf 2055 printk(KERN_INFO " blocks= %llu block_size= %d\n",
97c06978 2056 (unsigned long long)*total_size+1, *block_size);
00988a35 2057 kfree(buf);
00988a35
MMOD		 2058}
2059
2060static void
2061cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, unsigned int *block_size)
2062{
2063 ReadCapdata_struct_16 *buf;
2064 int return_code;
1aebe187
MK		 2065
2066 buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
2067 if (!buf) {
00988a35
MMOD		 2068 printk(KERN_WARNING "cciss: out of memory\n");
2069 return;
2070 }
1aebe187 2071
00988a35
MMOD		 2072 if (withirq) {
2073 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2074 ctlr, buf, sizeof(ReadCapdata_struct_16),
2075 1, logvol, 0, TYPE_CMD);
2076 }
2077 else {
2078 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2079 ctlr, buf, sizeof(ReadCapdata_struct_16),
2080 1, logvol, 0, NULL, TYPE_CMD);
2081 }
2082 if (return_code == IO_OK) {
4c1f2b31
AV		 2083 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
2084 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
00988a35
MMOD		 2085 } else { /* read capacity command failed */
2086 printk(KERN_WARNING "cciss: read capacity failed\n");
2087 *total_size = 0;
2088 *block_size = BLOCK_SIZE;
2089 }
7b92aadf 2090 printk(KERN_INFO " blocks= %llu block_size= %d\n",
97c06978 2091 (unsigned long long)*total_size+1, *block_size);
00988a35 2092 kfree(buf);
1da177e4
LT		 2093}
2094
1da177e4
LT		 2095static int cciss_revalidate(struct gendisk *disk)
2096{
2097 ctlr_info_t *h = get_host(disk);
2098 drive_info_struct *drv = get_drv(disk);
2099 int logvol;
7c832835 2100 int FOUND = 0;
1da177e4 2101 unsigned int block_size;
00988a35 2102 sector_t total_size;
1da177e4
LT		 2103 InquiryData_struct *inq_buff = NULL;
2104
7c832835
BH		 2105 for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2106 if (h->drv[logvol].LunID == drv->LunID) {
2107 FOUND = 1;
1da177e4
LT		 2108 break;
2109 }
2110 }
2111
7c832835
BH		 2112 if (!FOUND)
2113 return 1;
1da177e4 2114
7c832835
BH		 2115 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2116 if (inq_buff == NULL) {
2117 printk(KERN_WARNING "cciss: out of memory\n");
7c832835
BH		 2118 return 1;
2119 }
00988a35
MMOD		 2120 if (h->cciss_read == CCISS_READ_10) {
2121 cciss_read_capacity(h->ctlr, logvol, 1,
2122 &total_size, &block_size);
2123 } else {
2124 cciss_read_capacity_16(h->ctlr, logvol, 1,
2125 &total_size, &block_size);
2126 }
7c832835
BH		 2127 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2128 inq_buff, drv);
1da177e4 2129
ad2b9312 2130 blk_queue_hardsect_size(drv->queue, drv->block_size);
1da177e4
LT		 2131 set_capacity(disk, drv->nr_blocks);
2132
1da177e4
LT		 2133 kfree(inq_buff);
2134 return 0;
2135}
2136
2137/*
2138 * Wait polling for a command to complete.
2139 * The memory mapped FIFO is polled for the completion.
2140 * Used only at init time, interrupts from the HBA are disabled.
2141 */
2142static unsigned long pollcomplete(int ctlr)
2143{
2144 unsigned long done;
2145 int i;
2146
2147 /* Wait (up to 20 seconds) for a command to complete */
2148
2149 for (i = 20 * HZ; i > 0; i--) {
2150 done = hba[ctlr]->access.command_completed(hba[ctlr]);
86e84862
NA		 2151 if (done == FIFO_EMPTY)
2152 schedule_timeout_uninterruptible(1);
2153 else
e2019b58 2154 return done;
1da177e4
LT		 2155 }
2156 /* Invalid address to tell caller we ran out of time */
2157 return 1;
2158}
3da8b713 2159
2160static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2161{
2162 /* We get in here if sendcmd() is polling for completions
7c832835
BH		 2163 and gets some command back that it wasn't expecting --
2164 something other than that which it just sent down.
2165 Ordinarily, that shouldn't happen, but it can happen when
3da8b713 2166 the scsi tape stuff gets into error handling mode, and
7c832835 2167 starts using sendcmd() to try to abort commands and
3da8b713 2168 reset tape drives. In that case, sendcmd may pick up
2169 completions of commands that were sent to logical drives
7c832835 2170 through the block i/o system, or cciss ioctls completing, etc.
3da8b713 2171 In that case, we need to save those completions for later
2172 processing by the interrupt handler.
7c832835 2173 */
3da8b713 2174
2175#ifdef CONFIG_CISS_SCSI_TAPE
7c832835 2176 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
3da8b713 2177
2178 /* If it's not the scsi tape stuff doing error handling, (abort */
2179 /* or reset) then we don't expect anything weird. */
2180 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2181#endif
7c832835
BH		 2182 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2183 "Invalid command list address returned! (%lx)\n",
2184 ctlr, complete);
3da8b713 2185 /* not much we can do. */
2186#ifdef CONFIG_CISS_SCSI_TAPE
2187 return 1;
2188 }
2189
2190 /* We've sent down an abort or reset, but something else
2191 has completed */
f880632f 2192 if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
3da8b713 2193 /* Uh oh. No room to save it for later... */
2194 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
7c832835 2195 "reject list overflow, command lost!\n", ctlr);
3da8b713 2196 return 1;
2197 }
2198 /* Save it for later */
2199 srl->complete[srl->ncompletions] = complete;
2200 srl->ncompletions++;
2201#endif
2202 return 0;
2203}
2204
1da177e4 2205/*
7c832835
BH		 2206 * Send a command to the controller, and wait for it to complete.
2207 * Only used at init time.
1da177e4 2208 */
7c832835
BH		 2209static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
2210 1: address logical volume log_unit,
2211 2: periph device address is scsi3addr */
2212 unsigned int log_unit,
2213 __u8 page_code, unsigned char *scsi3addr, int cmd_type)
1da177e4
LT		 2214{
2215 CommandList_struct *c;
2216 int i;
2217 unsigned long complete;
7c832835 2218 ctlr_info_t *info_p = hba[ctlr];
1da177e4 2219 u64bit buff_dma_handle;
3da8b713 2220 int status, done = 0;
1da177e4
LT		 2221
2222 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2223 printk(KERN_WARNING "cciss: unable to get memory");
e2019b58 2224 return IO_ERROR;
1da177e4
LT		 2225 }
2226 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
7c832835 2227 log_unit, page_code, scsi3addr, cmd_type);
1da177e4
LT		 2228 if (status != IO_OK) {
2229 cmd_free(info_p, c, 1);
2230 return status;
2231 }
7c832835 2232 resend_cmd1:
1da177e4 2233 /*
7c832835
BH		 2234 * Disable interrupt
2235 */
1da177e4
LT		 2236#ifdef CCISS_DEBUG
2237 printk(KERN_DEBUG "cciss: turning intr off\n");
7c832835
BH		 2238#endif /* CCISS_DEBUG */
2239 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2240
1da177e4 2241 /* Make sure there is room in the command FIFO */
7c832835 2242 /* Actually it should be completely empty at this time */
3da8b713 2243 /* unless we are in here doing error handling for the scsi */
2244 /* tape side of the driver. */
7c832835 2245 for (i = 200000; i > 0; i--) {
1da177e4 2246 /* if fifo isn't full go */
7c832835
BH		 2247 if (!(info_p->access.fifo_full(info_p))) {
2248
2249 break;
2250 }
2251 udelay(10);
2252 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2253 " waiting!\n", ctlr);
2254 }
2255 /*
2256 * Send the cmd
2257 */
2258 info_p->access.submit_command(info_p, c);
3da8b713 2259 done = 0;
2260 do {
2261 complete = pollcomplete(ctlr);
1da177e4
LT		 2262
2263#ifdef CCISS_DEBUG
3da8b713 2264 printk(KERN_DEBUG "cciss: command completed\n");
7c832835 2265#endif /* CCISS_DEBUG */
1da177e4 2266
3da8b713 2267 if (complete == 1) {
7c832835
BH		 2268 printk(KERN_WARNING
2269 "cciss cciss%d: SendCmd Timeout out, "
2270 "No command list address returned!\n", ctlr);
3da8b713 2271 status = IO_ERROR;
2272 done = 1;
2273 break;
2274 }
2275
2276 /* This will need to change for direct lookup completions */
7c832835
BH		 2277 if ((complete & CISS_ERROR_BIT)
2278 && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2279 /* if data overrun or underun on Report command
2280 ignore it
2281 */
1da177e4
LT		 2282 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2283 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2284 (c->Request.CDB[0] == CISS_INQUIRY)) &&
7c832835
BH		 2285 ((c->err_info->CommandStatus ==
2286 CMD_DATA_OVERRUN) ||
2287 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2288 )) {
1da177e4
LT		 2289 complete = c->busaddr;
2290 } else {
2291 if (c->err_info->CommandStatus ==
7c832835 2292 CMD_UNSOLICITED_ABORT) {
1da177e4 2293 printk(KERN_WARNING "cciss%d: "
7c832835
BH		 2294 "unsolicited abort %p\n",
2295 ctlr, c);
1da177e4
LT		 2296 if (c->retry_count < MAX_CMD_RETRIES) {
2297 printk(KERN_WARNING
7c832835
BH		 2298 "cciss%d: retrying %p\n",
2299 ctlr, c);
1da177e4
LT		 2300 c->retry_count++;
2301 /* erase the old error */
2302 /* information */
2303 memset(c->err_info, 0,
7c832835
BH		 2304 sizeof
2305 (ErrorInfo_struct));
1da177e4
LT		 2306 goto resend_cmd1;
2307 } else {
2308 printk(KERN_WARNING
7c832835
BH		 2309 "cciss%d: retried %p too "
2310 "many times\n", ctlr, c);
1da177e4
LT		 2311 status = IO_ERROR;
2312 goto cleanup1;
2313 }
7c832835
BH		 2314 } else if (c->err_info->CommandStatus ==
2315 CMD_UNABORTABLE) {
2316 printk(KERN_WARNING
2317 "cciss%d: command could not be aborted.\n",
2318 ctlr);
3da8b713 2319 status = IO_ERROR;
2320 goto cleanup1;
1da177e4
LT		 2321 }
2322 printk(KERN_WARNING "ciss ciss%d: sendcmd"
7c832835
BH		 2323 " Error %x \n", ctlr,
2324 c->err_info->CommandStatus);
1da177e4 2325 printk(KERN_WARNING "ciss ciss%d: sendcmd"
7c832835
BH		 2326 " offensive info\n"
2327 " size %x\n num %x value %x\n",
2328 ctlr,
2329 c->err_info->MoreErrInfo.Invalid_Cmd.
2330 offense_size,
2331 c->err_info->MoreErrInfo.Invalid_Cmd.
2332 offense_num,
2333 c->err_info->MoreErrInfo.Invalid_Cmd.
2334 offense_value);
1da177e4
LT		 2335 status = IO_ERROR;
2336 goto cleanup1;
2337 }
2338 }
3da8b713 2339 /* This will need changing for direct lookup completions */
7c832835 2340 if (complete != c->busaddr) {
3da8b713 2341 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
7c832835 2342 BUG(); /* we are pretty much hosed if we get here. */
3da8b713 2343 }
2344 continue;
7c832835 2345 } else
3da8b713 2346 done = 1;
7c832835
BH		 2347 } while (!done);
2348
2349 cleanup1:
1da177e4 2350 /* unlock the data buffer from DMA */
bb2a37bf
MM		 2351 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2352 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1da177e4 2353 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
7c832835 2354 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
3da8b713 2355#ifdef CONFIG_CISS_SCSI_TAPE
2356 /* if we saved some commands for later, process them now. */
2357 if (info_p->scsi_rejects.ncompletions > 0)
7d12e780 2358 do_cciss_intr(0, info_p);
3da8b713 2359#endif
1da177e4 2360 cmd_free(info_p, c, 1);
e2019b58 2361 return status;
7c832835
BH		 2362}
2363
1da177e4
LT		 2364/*
2365 * Map (physical) PCI mem into (virtual) kernel space
2366 */
2367static void __iomem *remap_pci_mem(ulong base, ulong size)
2368{
7c832835
BH		 2369 ulong page_base = ((ulong) base) & PAGE_MASK;
2370 ulong page_offs = ((ulong) base) - page_base;
2371 void __iomem *page_remapped = ioremap(page_base, page_offs + size);
1da177e4 2372
7c832835 2373 return page_remapped ? (page_remapped + page_offs) : NULL;
1da177e4
LT		 2374}
2375
7c832835
BH		 2376/*
2377 * Takes jobs of the Q and sends them to the hardware, then puts it on
2378 * the Q to wait for completion.
2379 */
2380static void start_io(ctlr_info_t *h)
1da177e4
LT		 2381{
2382 CommandList_struct *c;
7c832835
BH		 2383
2384 while ((c = h->reqQ) != NULL) {
1da177e4
LT		 2385 /* can't do anything if fifo is full */
2386 if ((h->access.fifo_full(h))) {
2387 printk(KERN_WARNING "cciss: fifo full\n");
2388 break;
2389 }
2390
7c832835 2391 /* Get the first entry from the Request Q */
1da177e4
LT		 2392 removeQ(&(h->reqQ), c);
2393 h->Qdepth--;
7c832835
BH		 2394
2395 /* Tell the controller execute command */
1da177e4 2396 h->access.submit_command(h, c);
7c832835
BH		 2397
2398 /* Put job onto the completed Q */
2399 addQ(&(h->cmpQ), c);
1da177e4
LT		 2400 }
2401}
7c832835 2402
1da177e4
LT		 2403/* Assumes that CCISS_LOCK(h->ctlr) is held. */
2404/* Zeros out the error record and then resends the command back */
2405/* to the controller */
7c832835 2406static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
1da177e4
LT		 2407{
2408 /* erase the old error information */
2409 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2410
2411 /* add it to software queue and then send it to the controller */
7c832835 2412 addQ(&(h->reqQ), c);
1da177e4 2413 h->Qdepth++;
7c832835 2414 if (h->Qdepth > h->maxQsinceinit)
1da177e4
LT		 2415 h->maxQsinceinit = h->Qdepth;
2416
2417 start_io(h);
2418}
a9925a06 2419
1a614f50
SC		 2420static inline unsigned int make_status_bytes(unsigned int scsi_status_byte,
2421 unsigned int msg_byte, unsigned int host_byte,
2422 unsigned int driver_byte)
2423{
2424 /* inverse of macros in scsi.h */
2425 return (scsi_status_byte & 0xff) |
2426 ((msg_byte & 0xff) << 8) |
2427 ((host_byte & 0xff) << 16) |
2428 ((driver_byte & 0xff) << 24);
2429}
2430
03bbfee5
MMOD		 2431static inline int evaluate_target_status(CommandList_struct *cmd)
2432{
2433 unsigned char sense_key;
1a614f50
SC		 2434 unsigned char status_byte, msg_byte, host_byte, driver_byte;
2435 int error_value;
2436
2437 /* If we get in here, it means we got "target status", that is, scsi status */
2438 status_byte = cmd->err_info->ScsiStatus;
2439 driver_byte = DRIVER_OK;
2440 msg_byte = cmd->err_info->CommandStatus; /* correct? seems too device specific */
2441
2442 if (blk_pc_request(cmd->rq))
2443 host_byte = DID_PASSTHROUGH;
2444 else
2445 host_byte = DID_OK;
2446
2447 error_value = make_status_bytes(status_byte, msg_byte,
2448 host_byte, driver_byte);
03bbfee5 2449
1a614f50 2450 if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
03bbfee5
MMOD		 2451 if (!blk_pc_request(cmd->rq))
2452 printk(KERN_WARNING "cciss: cmd %p "
2453 "has SCSI Status 0x%x\n",
2454 cmd, cmd->err_info->ScsiStatus);
1a614f50 2455 return error_value;
03bbfee5
MMOD		 2456 }
2457
2458 /* check the sense key */
2459 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2460 /* no status or recovered error */
1a614f50
SC		 2461 if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
2462 error_value = 0;
03bbfee5
MMOD		 2463
2464 if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
1a614f50 2465 if (error_value != 0)
03bbfee5
MMOD		 2466 printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
2467 " sense key = 0x%x\n", cmd, sense_key);
1a614f50 2468 return error_value;
03bbfee5
MMOD		 2469 }
2470
2471 /* SG_IO or similar, copy sense data back */
2472 if (cmd->rq->sense) {
2473 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
2474 cmd->rq->sense_len = cmd->err_info->SenseLen;
2475 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
2476 cmd->rq->sense_len);
2477 } else
2478 cmd->rq->sense_len = 0;
2479
1a614f50 2480 return error_value;
03bbfee5
MMOD		 2481}
2482
7c832835 2483/* checks the status of the job and calls complete buffers to mark all
a9925a06
JA		 2484 * buffers for the completed job. Note that this function does not need
2485 * to hold the hba/queue lock.
7c832835
BH		 2486 */
2487static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2488 int timeout)
1da177e4 2489{
1da177e4 2490 int retry_cmd = 0;
198b7660
MMOD		 2491 struct request *rq = cmd->rq;
2492
2493 rq->errors = 0;
7c832835 2494
1da177e4 2495 if (timeout)
1a614f50 2496 rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT);
1da177e4 2497
d38ae168
MMOD		 2498 if (cmd->err_info->CommandStatus == 0) /* no error has occurred */
2499 goto after_error_processing;
7c832835 2500
d38ae168 2501 switch (cmd->err_info->CommandStatus) {
d38ae168 2502 case CMD_TARGET_STATUS:
198b7660 2503 rq->errors = evaluate_target_status(cmd);
d38ae168
MMOD		 2504 break;
2505 case CMD_DATA_UNDERRUN:
03bbfee5
MMOD		 2506 if (blk_fs_request(cmd->rq)) {
2507 printk(KERN_WARNING "cciss: cmd %p has"
2508 " completed with data underrun "
2509 "reported\n", cmd);
2510 cmd->rq->data_len = cmd->err_info->ResidualCnt;
2511 }
d38ae168
MMOD		 2512 break;
2513 case CMD_DATA_OVERRUN:
03bbfee5
MMOD		 2514 if (blk_fs_request(cmd->rq))
2515 printk(KERN_WARNING "cciss: cmd %p has"
2516 " completed with data overrun "
2517 "reported\n", cmd);
d38ae168
MMOD		 2518 break;
2519 case CMD_INVALID:
2520 printk(KERN_WARNING "cciss: cmd %p is "
2521 "reported invalid\n", cmd);
1a614f50
SC		 2522 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2523 cmd->err_info->CommandStatus, DRIVER_OK,
2524 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
d38ae168
MMOD		 2525 break;
2526 case CMD_PROTOCOL_ERR:
2527 printk(KERN_WARNING "cciss: cmd %p has "
2528 "protocol error \n", cmd);
1a614f50
SC		 2529 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2530 cmd->err_info->CommandStatus, DRIVER_OK,
2531 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
d38ae168
MMOD		 2532 break;
2533 case CMD_HARDWARE_ERR:
2534 printk(KERN_WARNING "cciss: cmd %p had "
2535 " hardware error\n", cmd);
1a614f50
SC		 2536 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2537 cmd->err_info->CommandStatus, DRIVER_OK,
2538 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
d38ae168
MMOD		 2539 break;
2540 case CMD_CONNECTION_LOST:
2541 printk(KERN_WARNING "cciss: cmd %p had "
2542 "connection lost\n", cmd);
1a614f50
SC		 2543 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2544 cmd->err_info->CommandStatus, DRIVER_OK,
2545 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
d38ae168
MMOD		 2546 break;
2547 case CMD_ABORTED:
2548 printk(KERN_WARNING "cciss: cmd %p was "
2549 "aborted\n", cmd);
1a614f50
SC		 2550 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2551 cmd->err_info->CommandStatus, DRIVER_OK,
2552 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
d38ae168
MMOD		 2553 break;
2554 case CMD_ABORT_FAILED:
2555 printk(KERN_WARNING "cciss: cmd %p reports "
2556 "abort failed\n", cmd);
1a614f50
SC		 2557 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2558 cmd->err_info->CommandStatus, DRIVER_OK,
2559 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
d38ae168
MMOD		 2560 break;
2561 case CMD_UNSOLICITED_ABORT:
2562 printk(KERN_WARNING "cciss%d: unsolicited "
2563 "abort %p\n", h->ctlr, cmd);
2564 if (cmd->retry_count < MAX_CMD_RETRIES) {
2565 retry_cmd = 1;
2566 printk(KERN_WARNING
2567 "cciss%d: retrying %p\n", h->ctlr, cmd);
2568 cmd->retry_count++;
2569 } else
2570 printk(KERN_WARNING
2571 "cciss%d: %p retried too "
2572 "many times\n", h->ctlr, cmd);
1a614f50
SC		 2573 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2574 cmd->err_info->CommandStatus, DRIVER_OK,
2575 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
d38ae168
MMOD		 2576 break;
2577 case CMD_TIMEOUT:
2578 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
1a614f50
SC		 2579 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2580 cmd->err_info->CommandStatus, DRIVER_OK,
2581 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
d38ae168
MMOD		 2582 break;
2583 default:
2584 printk(KERN_WARNING "cciss: cmd %p returned "
2585 "unknown status %x\n", cmd,
2586 cmd->err_info->CommandStatus);
1a614f50
SC		 2587 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2588 cmd->err_info->CommandStatus, DRIVER_OK,
2589 blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
1da177e4 2590 }
d38ae168
MMOD		 2591
2592after_error_processing:
2593
1da177e4 2594 /* We need to return this command */
7c832835
BH		 2595 if (retry_cmd) {
2596 resend_cciss_cmd(h, cmd);
1da177e4 2597 return;
7c832835 2598 }
03bbfee5 2599 cmd->rq->completion_data = cmd;
a9925a06 2600 blk_complete_request(cmd->rq);
1da177e4
LT		 2601}
2602
7c832835
BH		 2603/*
2604 * Get a request and submit it to the controller.
1da177e4 2605 */
165125e1 2606static void do_cciss_request(struct request_queue *q)
1da177e4 2607{
7c832835 2608 ctlr_info_t *h = q->queuedata;
1da177e4 2609 CommandList_struct *c;
00988a35
MMOD		 2610 sector_t start_blk;
2611 int seg;
1da177e4
LT		 2612 struct request *creq;
2613 u64bit temp64;
2614 struct scatterlist tmp_sg[MAXSGENTRIES];
2615 drive_info_struct *drv;
2616 int i, dir;
2617
2618 /* We call start_io here in case there is a command waiting on the
2619 * queue that has not been sent.
7c832835 2620 */
1da177e4
LT		 2621 if (blk_queue_plugged(q))
2622 goto startio;
2623
7c832835 2624 queue:
1da177e4
LT		 2625 creq = elv_next_request(q);
2626 if (!creq)
2627 goto startio;
2628
089fe1b2 2629 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
1da177e4 2630
7c832835 2631 if ((c = cmd_alloc(h, 1)) == NULL)
1da177e4
LT		 2632 goto full;
2633
2634 blkdev_dequeue_request(creq);
2635
2636 spin_unlock_irq(q->queue_lock);
2637
2638 c->cmd_type = CMD_RWREQ;
2639 c->rq = creq;
7c832835
BH		 2640
2641 /* fill in the request */
1da177e4 2642 drv = creq->rq_disk->private_data;
7c832835 2643 c->Header.ReplyQueue = 0; // unused in simple mode
33079b21
MM		 2644 /* got command from pool, so use the command block index instead */
2645 /* for direct lookups. */
2646 /* The first 2 bits are reserved for controller error reporting. */
2647 c->Header.Tag.lower = (c->cmdindex << 3);
7c832835
BH		 2648 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2649 c->Header.LUN.LogDev.VolId = drv->LunID;
1da177e4 2650 c->Header.LUN.LogDev.Mode = 1;
7c832835
BH		 2651 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2652 c->Request.Type.Type = TYPE_CMD; // It is a command.
2653 c->Request.Type.Attribute = ATTR_SIMPLE;
2654 c->Request.Type.Direction =
a52de245 2655 (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
7c832835
BH		 2656 c->Request.Timeout = 0; // Don't time out
2657 c->Request.CDB[0] =
00988a35 2658 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
1da177e4
LT		 2659 start_blk = creq->sector;
2660#ifdef CCISS_DEBUG
7c832835
BH		 2661 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2662 (int)creq->nr_sectors);
2663#endif /* CCISS_DEBUG */
1da177e4 2664
45711f1a 2665 sg_init_table(tmp_sg, MAXSGENTRIES);
1da177e4
LT		 2666 seg = blk_rq_map_sg(q, creq, tmp_sg);
2667
7c832835 2668 /* get the DMA records for the setup */
1da177e4
LT		 2669 if (c->Request.Type.Direction == XFER_READ)
2670 dir = PCI_DMA_FROMDEVICE;
2671 else
2672 dir = PCI_DMA_TODEVICE;
2673
7c832835 2674 for (i = 0; i < seg; i++) {
1da177e4 2675 c->SG[i].Len = tmp_sg[i].length;
45711f1a 2676 temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]),
7c832835
BH		 2677 tmp_sg[i].offset,
2678 tmp_sg[i].length, dir);
1da177e4 2679 c->SG[i].Addr.lower = temp64.val32.lower;
7c832835
BH		 2680 c->SG[i].Addr.upper = temp64.val32.upper;
2681 c->SG[i].Ext = 0; // we are not chaining
1da177e4 2682 }
7c832835
BH		 2683 /* track how many SG entries we are using */
2684 if (seg > h->maxSG)
2685 h->maxSG = seg;
1da177e4
LT		 2686
2687#ifdef CCISS_DEBUG
7c832835
BH		 2688 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2689 creq->nr_sectors, seg);
2690#endif /* CCISS_DEBUG */
1da177e4
LT		 2691
2692 c->Header.SGList = c->Header.SGTotal = seg;
03bbfee5
MMOD		 2693 if (likely(blk_fs_request(creq))) {
2694 if(h->cciss_read == CCISS_READ_10) {
2695 c->Request.CDB[1] = 0;
2696 c->Request.CDB[2] = (start_blk >> 24) & 0xff; //MSB
2697 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2698 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2699 c->Request.CDB[5] = start_blk & 0xff;
2700 c->Request.CDB[6] = 0; // (sect >> 24) & 0xff; MSB
2701 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2702 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2703 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2704 } else {
582539e5
RD		 2705 u32 upper32 = upper_32_bits(start_blk);
2706
03bbfee5
MMOD		 2707 c->Request.CDBLen = 16;
2708 c->Request.CDB[1]= 0;
582539e5
RD		 2709 c->Request.CDB[2]= (upper32 >> 24) & 0xff; //MSB
2710 c->Request.CDB[3]= (upper32 >> 16) & 0xff;
2711 c->Request.CDB[4]= (upper32 >> 8) & 0xff;
2712 c->Request.CDB[5]= upper32 & 0xff;
03bbfee5
MMOD		 2713 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2714 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2715 c->Request.CDB[8]= (start_blk >> 8) & 0xff;
2716 c->Request.CDB[9]= start_blk & 0xff;
2717 c->Request.CDB[10]= (creq->nr_sectors >> 24) & 0xff;
2718 c->Request.CDB[11]= (creq->nr_sectors >> 16) & 0xff;
2719 c->Request.CDB[12]= (creq->nr_sectors >> 8) & 0xff;
2720 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2721 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2722 }
2723 } else if (blk_pc_request(creq)) {
2724 c->Request.CDBLen = creq->cmd_len;
2725 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
00988a35 2726 } else {
03bbfee5
MMOD		 2727 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
2728 BUG();
00988a35 2729 }
1da177e4
LT		 2730
2731 spin_lock_irq(q->queue_lock);
2732
7c832835 2733 addQ(&(h->reqQ), c);
1da177e4 2734 h->Qdepth++;
7c832835
BH		 2735 if (h->Qdepth > h->maxQsinceinit)
2736 h->maxQsinceinit = h->Qdepth;
1da177e4
LT		 2737
2738 goto queue;
00988a35 2739full:
1da177e4 2740 blk_stop_queue(q);
00988a35 2741startio:
1da177e4
LT		 2742 /* We will already have the driver lock here so not need
2743 * to lock it.
7c832835 2744 */
1da177e4
LT		 2745 start_io(h);
2746}
2747
3da8b713 2748static inline unsigned long get_next_completion(ctlr_info_t *h)
2749{
2750#ifdef CONFIG_CISS_SCSI_TAPE
2751 /* Any rejects from sendcmd() lying around? Process them first */
2752 if (h->scsi_rejects.ncompletions == 0)
2753 return h->access.command_completed(h);
2754 else {
2755 struct sendcmd_reject_list *srl;
2756 int n;
2757 srl = &h->scsi_rejects;
2758 n = --srl->ncompletions;
2759 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2760 printk("p");
2761 return srl->complete[n];
2762 }
2763#else
2764 return h->access.command_completed(h);
2765#endif
2766}
2767
2768static inline int interrupt_pending(ctlr_info_t *h)
2769{
2770#ifdef CONFIG_CISS_SCSI_TAPE
7c832835 2771 return (h->access.intr_pending(h)
3da8b713 2772 || (h->scsi_rejects.ncompletions > 0));
2773#else
2774 return h->access.intr_pending(h);
2775#endif
2776}
2777
2778static inline long interrupt_not_for_us(ctlr_info_t *h)
2779{
2780#ifdef CONFIG_CISS_SCSI_TAPE
7c832835
BH		 2781 return (((h->access.intr_pending(h) == 0) ||
2782 (h->interrupts_enabled == 0))
2783 && (h->scsi_rejects.ncompletions == 0));
3da8b713 2784#else
7c832835 2785 return (((h->access.intr_pending(h) == 0) ||
3da8b713 2786 (h->interrupts_enabled == 0)));
2787#endif
2788}
2789
7d12e780 2790static irqreturn_t do_cciss_intr(int irq, void *dev_id)
1da177e4
LT		 2791{
2792 ctlr_info_t *h = dev_id;
2793 CommandList_struct *c;
2794 unsigned long flags;
33079b21 2795 __u32 a, a1, a2;
1da177e4 2796
3da8b713 2797 if (interrupt_not_for_us(h))
1da177e4 2798 return IRQ_NONE;
1da177e4
LT		 2799 /*
2800 * If there are completed commands in the completion queue,
2801 * we had better do something about it.
2802 */
2803 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
3da8b713 2804 while (interrupt_pending(h)) {
7c832835 2805 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
1da177e4 2806 a1 = a;
33079b21
MM		 2807 if ((a & 0x04)) {
2808 a2 = (a >> 3);
f880632f 2809 if (a2 >= h->nr_cmds) {
7c832835
BH		 2810 printk(KERN_WARNING
2811 "cciss: controller cciss%d failed, stopping.\n",
2812 h->ctlr);
33079b21
MM		 2813 fail_all_cmds(h->ctlr);
2814 return IRQ_HANDLED;
2815 }
2816
2817 c = h->cmd_pool + a2;
2818 a = c->busaddr;
2819
2820 } else {
7c832835 2821 a &= ~3;
33079b21 2822 if ((c = h->cmpQ) == NULL) {
7c832835
BH		 2823 printk(KERN_WARNING
2824 "cciss: Completion of %08x ignored\n",
2825 a1);
2826 continue;
2827 }
2828 while (c->busaddr != a) {
2829 c = c->next;
2830 if (c == h->cmpQ)
2831 break;
2832 }
33079b21 2833 }
1da177e4
LT		 2834 /*
2835 * If we've found the command, take it off the
2836 * completion Q and free it
2837 */
7c832835 2838 if (c->busaddr == a) {
1da177e4
LT		 2839 removeQ(&h->cmpQ, c);
2840 if (c->cmd_type == CMD_RWREQ) {
2841 complete_command(h, c, 0);
2842 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2843 complete(c->waiting);
2844 }
2845# ifdef CONFIG_CISS_SCSI_TAPE
2846 else if (c->cmd_type == CMD_SCSI)
2847 complete_scsi_command(c, 0, a1);
2848# endif
2849 continue;
2850 }
2851 }
2852 }
2853
1da177e4
LT		 2854 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2855 return IRQ_HANDLED;
2856}
7c832835
BH		 2857
2858/*
d14c4ab5 2859 * We cannot read the structure directly, for portability we must use
1da177e4 2860 * the io functions.
7c832835 2861 * This is for debug only.
1da177e4
LT		 2862 */
2863#ifdef CCISS_DEBUG
7c832835 2864static void print_cfg_table(CfgTable_struct *tb)
1da177e4
LT		 2865{
2866 int i;
2867 char temp_name[17];
2868
2869 printk("Controller Configuration information\n");
2870 printk("------------------------------------\n");
7c832835 2871 for (i = 0; i < 4; i++)
1da177e4 2872 temp_name[i] = readb(&(tb->Signature[i]));
7c832835
BH		 2873 temp_name[4] = '\0';
2874 printk(" Signature = %s\n", temp_name);
1da177e4 2875 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
7c832835
BH		 2876 printk(" Transport methods supported = 0x%x\n",
2877 readl(&(tb->TransportSupport)));
2878 printk(" Transport methods active = 0x%x\n",
2879 readl(&(tb->TransportActive)));
2880 printk(" Requested transport Method = 0x%x\n",
2881 readl(&(tb->HostWrite.TransportRequest)));
d14c4ab5 2882 printk(" Coalesce Interrupt Delay = 0x%x\n",
7c832835 2883 readl(&(tb->HostWrite.CoalIntDelay)));
d14c4ab5 2884 printk(" Coalesce Interrupt Count = 0x%x\n",
7c832835
BH		 2885 readl(&(tb->HostWrite.CoalIntCount)));
2886 printk(" Max outstanding commands = 0x%d\n",
2887 readl(&(tb->CmdsOutMax)));
2888 printk(" Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2889 for (i = 0; i < 16; i++)
1da177e4
LT		 2890 temp_name[i] = readb(&(tb->ServerName[i]));
2891 temp_name[16] = '\0';
2892 printk(" Server Name = %s\n", temp_name);
7c832835 2893 printk(" Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
1da177e4 2894}
7c832835 2895#endif /* CCISS_DEBUG */
1da177e4 2896
7c832835 2897static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
1da177e4
LT		 2898{
2899 int i, offset, mem_type, bar_type;
7c832835 2900 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
1da177e4
LT		 2901 return 0;
2902 offset = 0;
7c832835
BH		 2903 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2904 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
1da177e4
LT		 2905 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2906 offset += 4;
2907 else {
2908 mem_type = pci_resource_flags(pdev, i) &
7c832835 2909 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
1da177e4 2910 switch (mem_type) {
7c832835
BH		 2911 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2912 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2913 offset += 4; /* 32 bit */
2914 break;
2915 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2916 offset += 8;
2917 break;
2918 default: /* reserved in PCI 2.2 */
2919 printk(KERN_WARNING
2920 "Base address is invalid\n");
2921 return -1;
1da177e4
LT		 2922 break;
2923 }
2924 }
7c832835
BH		 2925 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2926 return i + 1;
1da177e4
LT		 2927 }
2928 return -1;
2929}
2930
fb86a35b
MM		 2931/* If MSI/MSI-X is supported by the kernel we will try to enable it on
2932 * controllers that are capable. If not, we use IO-APIC mode.
2933 */
2934
7c832835
BH		 2935static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
2936 struct pci_dev *pdev, __u32 board_id)
fb86a35b
MM		 2937{
2938#ifdef CONFIG_PCI_MSI
7c832835
BH		 2939 int err;
2940 struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
2941 {0, 2}, {0, 3}
2942 };
fb86a35b
MM		 2943
2944 /* Some boards advertise MSI but don't really support it */
2945 if ((board_id == 0x40700E11) ||
7c832835
BH		 2946 (board_id == 0x40800E11) ||
2947 (board_id == 0x40820E11) || (board_id == 0x40830E11))
fb86a35b
MM		 2948 goto default_int_mode;
2949
7c832835
BH		 2950 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2951 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2952 if (!err) {
2953 c->intr[0] = cciss_msix_entries[0].vector;
2954 c->intr[1] = cciss_msix_entries[1].vector;
2955 c->intr[2] = cciss_msix_entries[2].vector;
2956 c->intr[3] = cciss_msix_entries[3].vector;
2957 c->msix_vector = 1;
2958 return;
2959 }
2960 if (err > 0) {
2961 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2962 "available\n", err);
1ecb9c0f 2963 goto default_int_mode;
7c832835
BH		 2964 } else {
2965 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2966 err);
1ecb9c0f 2967 goto default_int_mode;
7c832835
BH		 2968 }
2969 }
2970 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2971 if (!pci_enable_msi(pdev)) {
7c832835 2972 c->msi_vector = 1;
7c832835
BH		 2973 } else {
2974 printk(KERN_WARNING "cciss: MSI init failed\n");
7c832835
BH		 2975 }
2976 }
1ecb9c0f 2977default_int_mode:
7c832835 2978#endif /* CONFIG_PCI_MSI */
fb86a35b 2979 /* if we get here we're going to use the default interrupt mode */
7c832835 2980 c->intr[SIMPLE_MODE_INT] = pdev->irq;
fb86a35b
MM		 2981 return;
2982}
2983
7d1fd970 2984static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
1da177e4
LT		 2985{
2986 ushort subsystem_vendor_id, subsystem_device_id, command;
2987 __u32 board_id, scratchpad = 0;
2988 __u64 cfg_offset;
2989 __u32 cfg_base_addr;
2990 __u64 cfg_base_addr_index;
c33ac89b 2991 int i, err;
1da177e4
LT		 2992
2993 /* check to see if controller has been disabled */
2994 /* BEFORE trying to enable it */
7c832835
BH		 2995 (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
2996 if (!(command & 0x02)) {
2997 printk(KERN_WARNING
2998 "cciss: controller appears to be disabled\n");
c33ac89b 2999 return -ENODEV;
1da177e4
LT		 3000 }
3001
c33ac89b 3002 err = pci_enable_device(pdev);
7c832835 3003 if (err) {
1da177e4 3004 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
c33ac89b 3005 return err;
1da177e4 3006 }
1da177e4 3007
4e570309
BH		 3008 err = pci_request_regions(pdev, "cciss");
3009 if (err) {
3010 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
7c832835 3011 "aborting\n");
872225ca 3012 return err;
4e570309
BH		 3013 }
3014
1da177e4
LT		 3015 subsystem_vendor_id = pdev->subsystem_vendor;
3016 subsystem_device_id = pdev->subsystem_device;
3017 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
7c832835 3018 subsystem_vendor_id);
1da177e4 3019
1da177e4
LT		 3020#ifdef CCISS_DEBUG
3021 printk("command = %x\n", command);
3022 printk("irq = %x\n", pdev->irq);
3023 printk("board_id = %x\n", board_id);
7c832835 3024#endif /* CCISS_DEBUG */
1da177e4 3025
fb86a35b
MM		 3026/* If the kernel supports MSI/MSI-X we will try to enable that functionality,
3027 * else we use the IO-APIC interrupt assigned to us by system ROM.
3028 */
3029 cciss_interrupt_mode(c, pdev, board_id);
1da177e4
LT		 3030
3031 /*
3032 * Memory base addr is first addr , the second points to the config
7c832835 3033 * table
1da177e4
LT		 3034 */
3035
7c832835 3036 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
1da177e4
LT		 3037#ifdef CCISS_DEBUG
3038 printk("address 0 = %x\n", c->paddr);
7c832835 3039#endif /* CCISS_DEBUG */
a5b92873 3040 c->vaddr = remap_pci_mem(c->paddr, 0x250);
1da177e4
LT		 3041
3042 /* Wait for the board to become ready. (PCI hotplug needs this.)
3043 * We poll for up to 120 secs, once per 100ms. */
7c832835 3044 for (i = 0; i < 1200; i++) {
1da177e4
LT		 3045 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
3046 if (scratchpad == CCISS_FIRMWARE_READY)
3047 break;
3048 set_current_state(TASK_INTERRUPTIBLE);
7c832835 3049 schedule_timeout(HZ / 10); /* wait 100ms */
1da177e4
LT		 3050 }
3051 if (scratchpad != CCISS_FIRMWARE_READY) {
3052 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
c33ac89b 3053 err = -ENODEV;
4e570309 3054 goto err_out_free_res;
1da177e4
LT		 3055 }
3056
3057 /* get the address index number */
3058 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
3059 cfg_base_addr &= (__u32) 0x0000ffff;
3060#ifdef CCISS_DEBUG
3061 printk("cfg base address = %x\n", cfg_base_addr);
7c832835
BH		 3062#endif /* CCISS_DEBUG */
3063 cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
1da177e4
LT		 3064#ifdef CCISS_DEBUG
3065 printk("cfg base address index = %x\n", cfg_base_addr_index);
7c832835 3066#endif /* CCISS_DEBUG */
1da177e4
LT		 3067 if (cfg_base_addr_index == -1) {
3068 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
c33ac89b 3069 err = -ENODEV;
4e570309 3070 goto err_out_free_res;
1da177e4
LT		 3071 }
3072
3073 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
3074#ifdef CCISS_DEBUG
3075 printk("cfg offset = %x\n", cfg_offset);
7c832835
BH		 3076#endif /* CCISS_DEBUG */
3077 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
3078 cfg_base_addr_index) +
3079 cfg_offset, sizeof(CfgTable_struct));
1da177e4
LT		 3080 c->board_id = board_id;
3081
3082#ifdef CCISS_DEBUG
945f390f 3083 print_cfg_table(c->cfgtable);
7c832835 3084#endif /* CCISS_DEBUG */
1da177e4 3085
49153998
MM		 3086 /* Some controllers support Zero Memory Raid (ZMR).
3087 * When configured in ZMR mode the number of supported
3088 * commands drops to 64. So instead of just setting an
3089 * arbitrary value we make the driver a little smarter.
3090 * We read the config table to tell us how many commands
3091 * are supported on the controller then subtract 4 to
3092 * leave a little room for ioctl calls.
3093 */
3094 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
7c832835 3095 for (i = 0; i < ARRAY_SIZE(products); i++) {
1da177e4
LT		 3096 if (board_id == products[i].board_id) {
3097 c->product_name = products[i].product_name;
3098 c->access = *(products[i].access);
49153998 3099 c->nr_cmds = c->max_commands - 4;
1da177e4
LT		 3100 break;
3101 }
3102 }
7c832835
BH		 3103 if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
3104 (readb(&c->cfgtable->Signature[1]) != 'I') ||
3105 (readb(&c->cfgtable->Signature[2]) != 'S') ||
3106 (readb(&c->cfgtable->Signature[3]) != 'S')) {
1da177e4 3107 printk("Does not appear to be a valid CISS config table\n");
c33ac89b 3108 err = -ENODEV;
4e570309 3109 goto err_out_free_res;
1da177e4 3110 }
4ff9a9a4
MM		 3111 /* We didn't find the controller in our list. We know the
3112 * signature is valid. If it's an HP device let's try to
3113 * bind to the device and fire it up. Otherwise we bail.
3114 */
3115 if (i == ARRAY_SIZE(products)) {
3116 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
3117 c->product_name = products[i-1].product_name;
3118 c->access = *(products[i-1].access);
49153998 3119 c->nr_cmds = c->max_commands - 4;
4ff9a9a4
MM		 3120 printk(KERN_WARNING "cciss: This is an unknown "
3121 "Smart Array controller.\n"
3122 "cciss: Please update to the latest driver "
3123 "available from www.hp.com.\n");
3124 } else {
3125 printk(KERN_WARNING "cciss: Sorry, I don't know how"
3126 " to access the Smart Array controller %08lx\n"
3127 , (unsigned long)board_id);
3128 err = -ENODEV;
3129 goto err_out_free_res;
3130 }
3131 }
1da177e4 3132#ifdef CONFIG_X86
7c832835
BH		 3133 {
3134 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
3135 __u32 prefetch;
3136 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
3137 prefetch |= 0x100;
3138 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
3139 }
1da177e4
LT		 3140#endif
3141
8bf50f71
MMOD		 3142 /* Disabling DMA prefetch and refetch for the P600.
3143 * An ASIC bug may result in accesses to invalid memory addresses.
3144 * We've disabled prefetch for some time now. Testing with XEN
3145 * kernels revealed a bug in the refetch if dom0 resides on a P600.
f92e2f5f
MM		 3146 */
3147 if(board_id == 0x3225103C) {
3148 __u32 dma_prefetch;
8bf50f71 3149 __u32 dma_refetch;
f92e2f5f
MM		 3150 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
3151 dma_prefetch |= 0x8000;
3152 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
8bf50f71
MMOD		 3153 pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch);
3154 dma_refetch |= 0x1;
3155 pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch);
f92e2f5f
MM		 3156 }
3157
1da177e4
LT		 3158#ifdef CCISS_DEBUG
3159 printk("Trying to put board into Simple mode\n");
7c832835 3160#endif /* CCISS_DEBUG */
1da177e4 3161 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
7c832835
BH		 3162 /* Update the field, and then ring the doorbell */
3163 writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
3164 writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
1da177e4
LT		 3165
3166 /* under certain very rare conditions, this can take awhile.
3167 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
3168 * as we enter this code.) */
7c832835 3169 for (i = 0; i < MAX_CONFIG_WAIT; i++) {
1da177e4
LT		 3170 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3171 break;
3172 /* delay and try again */
3173 set_current_state(TASK_INTERRUPTIBLE);
3174 schedule_timeout(10);
7c832835 3175 }
1da177e4
LT		 3176
3177#ifdef CCISS_DEBUG
7c832835
BH		 3178 printk(KERN_DEBUG "I counter got to %d %x\n", i,
3179 readl(c->vaddr + SA5_DOORBELL));
3180#endif /* CCISS_DEBUG */
1da177e4 3181#ifdef CCISS_DEBUG
7c832835
BH		 3182 print_cfg_table(c->cfgtable);
3183#endif /* CCISS_DEBUG */
1da177e4 3184
7c832835 3185 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
1da177e4 3186 printk(KERN_WARNING "cciss: unable to get board into"
7c832835 3187 " simple mode\n");
c33ac89b 3188 err = -ENODEV;
4e570309 3189 goto err_out_free_res;
1da177e4
LT		 3190 }
3191 return 0;
3192
5faad620 3193err_out_free_res:
872225ca
MM		 3194 /*
3195 * Deliberately omit pci_disable_device(): it does something nasty to
3196 * Smart Array controllers that pci_enable_device does not undo
3197 */
4e570309 3198 pci_release_regions(pdev);
c33ac89b 3199 return err;
1da177e4
LT		 3200}
3201
7c832835
BH		 3202/*
3203 * Gets information about the local volumes attached to the controller.
3204 */
1da177e4
LT		 3205static void cciss_getgeometry(int cntl_num)
3206{
3207 ReportLunData_struct *ld_buff;
1da177e4
LT		 3208 InquiryData_struct *inq_buff;
3209 int return_code;
3210 int i;
3211 int listlength = 0;
3212 __u32 lunid = 0;
b4482a4b 3213 unsigned block_size;
00988a35 3214 sector_t total_size;
1da177e4 3215
06ff37ff 3216 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
7c832835
BH		 3217 if (ld_buff == NULL) {
3218 printk(KERN_ERR "cciss: out of memory\n");
3219 return;
3220 }
7c832835
BH		 3221 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3222 if (inq_buff == NULL) {
3223 printk(KERN_ERR "cciss: out of memory\n");
1da177e4 3224 kfree(ld_buff);
7c832835
BH		 3225 return;
3226 }
3227 /* Get the firmware version */
3228 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3229 sizeof(InquiryData_struct), 0, 0, 0, NULL,
3230 TYPE_CMD);
3231 if (return_code == IO_OK) {
1da177e4
LT		 3232 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3233 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3234 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3235 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
7c832835
BH		 3236 } else { /* send command failed */
3237
1da177e4 3238 printk(KERN_WARNING "cciss: unable to determine firmware"
7c832835 3239 " version of controller\n");
1da177e4 3240 }
7c832835
BH		 3241 /* Get the number of logical volumes */
3242 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3243 sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3244 TYPE_CMD);
1da177e4 3245
7c832835 3246 if (return_code == IO_OK) {
1da177e4
LT		 3247#ifdef CCISS_DEBUG
3248 printk("LUN Data\n--------------------------\n");
7c832835
BH		 3249#endif /* CCISS_DEBUG */
3250
3251 listlength |=
3252 (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3253 listlength |=
3254 (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3255 listlength |=
3256 (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
1da177e4 3257 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
7c832835
BH		 3258 } else { /* reading number of logical volumes failed */
3259
1da177e4 3260 printk(KERN_WARNING "cciss: report logical volume"
7c832835 3261 " command failed\n");
1da177e4
LT		 3262 listlength = 0;
3263 }
7c832835
BH		 3264 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
3265 if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3266 printk(KERN_ERR
3267 "ciss: only %d number of logical volumes supported\n",
3268 CISS_MAX_LUN);
1da177e4
LT		 3269 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3270 }
3271#ifdef CCISS_DEBUG
7c832835
BH		 3272 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3273 ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3274 ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3275 hba[cntl_num]->num_luns);
3276#endif /* CCISS_DEBUG */
3277
3278 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
7c832835
BH		 3279 for (i = 0; i < CISS_MAX_LUN; i++) {
3280 if (i < hba[cntl_num]->num_luns) {
3281 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3282 << 24;
3283 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3284 << 16;
3285 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3286 << 8;
3287 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3288
3289 hba[cntl_num]->drv[i].LunID = lunid;
1da177e4
LT		 3290
3291#ifdef CCISS_DEBUG
7c832835
BH		 3292 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
3293 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3294 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3295 hba[cntl_num]->drv[i].LunID);
3296#endif /* CCISS_DEBUG */
00988a35
MMOD		 3297
3298 /* testing to see if 16-byte CDBs are already being used */
3299 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3300 cciss_read_capacity_16(cntl_num, i, 0,
7c832835 3301 &total_size, &block_size);
00988a35
MMOD		 3302 goto geo_inq;
3303 }
3304 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3305
97c06978
MMOD		 3306 /* If read_capacity returns all F's the logical is >2TB */
3307 /* so we switch to 16-byte CDBs for all read/write ops */
3308 if(total_size == 0xFFFFFFFFULL) {
00988a35
MMOD		 3309 cciss_read_capacity_16(cntl_num, i, 0,
3310 &total_size, &block_size);
3311 hba[cntl_num]->cciss_read = CCISS_READ_16;
3312 hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3313 } else {
3314 hba[cntl_num]->cciss_read = CCISS_READ_10;
3315 hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3316 }
3317geo_inq:
ddd47442 3318 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
7c832835
BH		 3319 block_size, inq_buff,
3320 &hba[cntl_num]->drv[i]);
ddd47442
MM		 3321 } else {
3322 /* initialize raid_level to indicate a free space */
3323 hba[cntl_num]->drv[i].raid_level = -1;
3324 }
1da177e4
LT		 3325 }
3326 kfree(ld_buff);
1da177e4 3327 kfree(inq_buff);
7c832835 3328}
1da177e4
LT		 3329
3330/* Function to find the first free pointer into our hba[] array */
3331/* Returns -1 if no free entries are left. */
3332static int alloc_cciss_hba(void)
3333{
799202cb 3334 int i;
1da177e4 3335
7c832835 3336 for (i = 0; i < MAX_CTLR; i++) {
1da177e4
LT		 3337 if (!hba[i]) {
3338 ctlr_info_t *p;
f2912a12 3339
06ff37ff 3340 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
1da177e4
LT		 3341 if (!p)
3342 goto Enomem;
799202cb 3343 p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
f2912a12
JJ		 3344 if (!p->gendisk[0]) {
3345 kfree(p);
799202cb 3346 goto Enomem;
f2912a12 3347 }
1da177e4
LT		 3348 hba[i] = p;
3349 return i;
3350 }
3351 }
3352 printk(KERN_WARNING "cciss: This driver supports a maximum"
7c832835 3353 " of %d controllers.\n", MAX_CTLR);
799202cb
MM		 3354 return -1;
3355Enomem:
1da177e4 3356 printk(KERN_ERR "cciss: out of memory.\n");
1da177e4
LT		 3357 return -1;
3358}
3359
3360static void free_hba(int i)
3361{
3362 ctlr_info_t *p = hba[i];
3363 int n;
3364
3365 hba[i] = NULL;
799202cb 3366 for (n = 0; n < CISS_MAX_LUN; n++)
1da177e4
LT		 3367 put_disk(p->gendisk[n]);
3368 kfree(p);
3369}
3370
3371/*
3372 * This is it. Find all the controllers and register them. I really hate
3373 * stealing all these major device numbers.
3374 * returns the number of block devices registered.
3375 */
3376static int __devinit cciss_init_one(struct pci_dev *pdev,
7c832835 3377 const struct pci_device_id *ent)
1da177e4 3378{
1da177e4 3379 int i;
799202cb 3380 int j = 0;
1da177e4 3381 int rc;
40aabb58 3382 int dac;
1da177e4 3383
1da177e4 3384 i = alloc_cciss_hba();
7c832835 3385 if (i < 0)
e2019b58 3386 return -1;
1f8ef380
MM		 3387
3388 hba[i]->busy_initializing = 1;
3389
1da177e4
LT		 3390 if (cciss_pci_init(hba[i], pdev) != 0)
3391 goto clean1;
3392
3393 sprintf(hba[i]->devname, "cciss%d", i);
3394 hba[i]->ctlr = i;
3395 hba[i]->pdev = pdev;
3396
3397 /* configure PCI DMA stuff */
eb0df996 3398 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
40aabb58 3399 dac = 1;
eb0df996 3400 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
40aabb58 3401 dac = 0;
1da177e4 3402 else {
40aabb58 3403 printk(KERN_ERR "cciss: no suitable DMA available\n");
1da177e4
LT		 3404 goto clean1;
3405 }
3406
3407 /*
3408 * register with the major number, or get a dynamic major number
3409 * by passing 0 as argument. This is done for greater than
3410 * 8 controller support.
3411 */
3412 if (i < MAX_CTLR_ORIG)
564de74a 3413 hba[i]->major = COMPAQ_CISS_MAJOR + i;
1da177e4 3414 rc = register_blkdev(hba[i]->major, hba[i]->devname);
7c832835 3415 if (rc == -EBUSY || rc == -EINVAL) {
1da177e4 3416 printk(KERN_ERR
7c832835
BH		 3417 "cciss: Unable to get major number %d for %s "
3418 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
1da177e4 3419 goto clean1;
7c832835 3420 } else {
1da177e4
LT		 3421 if (i >= MAX_CTLR_ORIG)
3422 hba[i]->major = rc;
3423 }
3424
3425 /* make sure the board interrupts are off */
3426 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
7c832835 3427 if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
69ab3912 3428 IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
1da177e4 3429 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
7c832835 3430 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
1da177e4
LT		 3431 goto clean2;
3432 }
40aabb58
BH		 3433
3434 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
7c832835
BH		 3435 hba[i]->devname, pdev->device, pci_name(pdev),
3436 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3437
3438 hba[i]->cmd_pool_bits =
f880632f 3439 kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
7c832835
BH		 3440 1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3441 hba[i]->cmd_pool = (CommandList_struct *)
3442 pci_alloc_consistent(hba[i]->pdev,
f880632f 3443 hba[i]->nr_cmds * sizeof(CommandList_struct),
7c832835
BH		 3444 &(hba[i]->cmd_pool_dhandle));
3445 hba[i]->errinfo_pool = (ErrorInfo_struct *)
3446 pci_alloc_consistent(hba[i]->pdev,
f880632f 3447 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
7c832835
BH		 3448 &(hba[i]->errinfo_pool_dhandle));
3449 if ((hba[i]->cmd_pool_bits == NULL)
3450 || (hba[i]->cmd_pool == NULL)
3451 || (hba[i]->errinfo_pool == NULL)) {
3452 printk(KERN_ERR "cciss: out of memory");
1da177e4
LT		 3453 goto clean4;
3454 }
3da8b713 3455#ifdef CONFIG_CISS_SCSI_TAPE
7c832835
BH		 3456 hba[i]->scsi_rejects.complete =
3457 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
f880632f 3458 (hba[i]->nr_cmds + 5), GFP_KERNEL);
3da8b713 3459 if (hba[i]->scsi_rejects.complete == NULL) {
7c832835 3460 printk(KERN_ERR "cciss: out of memory");
3da8b713 3461 goto clean4;
3462 }
3463#endif
1da177e4 3464 spin_lock_init(&hba[i]->lock);
1da177e4 3465
7c832835
BH		 3466 /* Initialize the pdev driver private data.
3467 have it point to hba[i]. */
1da177e4 3468 pci_set_drvdata(pdev, hba[i]);
7c832835
BH		 3469 /* command and error info recs zeroed out before
3470 they are used */
3471 memset(hba[i]->cmd_pool_bits, 0,
f880632f 3472 ((hba[i]->nr_cmds + BITS_PER_LONG -
7c832835 3473 1) / BITS_PER_LONG) * sizeof(unsigned long));
1da177e4 3474
7c832835
BH		 3475#ifdef CCISS_DEBUG
3476 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3477#endif /* CCISS_DEBUG */
1da177e4
LT		 3478
3479 cciss_getgeometry(i);
3480
3481 cciss_scsi_setup(i);
3482
3483 /* Turn the interrupts on so we can service requests */
3484 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3485
3486 cciss_procinit(i);
92c4231a
MM		 3487
3488 hba[i]->cciss_max_sectors = 2048;
3489
d6dbf42e 3490 hba[i]->busy_initializing = 0;
1da177e4 3491
799202cb 3492 do {
ad2b9312
MM		 3493 drive_info_struct *drv = &(hba[i]->drv[j]);
3494 struct gendisk *disk = hba[i]->gendisk[j];
165125e1 3495 struct request_queue *q;
799202cb
MM		 3496
3497 /* Check if the disk was allocated already */
3498 if (!disk){
3499 hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
3500 disk = hba[i]->gendisk[j];
3501 }
3502
3503 /* Check that the disk was able to be allocated */
3504 if (!disk) {
3505 printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
3506 goto clean4;
3507 }
ad2b9312
MM		 3508
3509 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3510 if (!q) {
3511 printk(KERN_ERR
7c832835
BH		 3512 "cciss: unable to allocate queue for disk %d\n",
3513 j);
799202cb 3514 goto clean4;
ad2b9312
MM		 3515 }
3516 drv->queue = q;
3517
a9925a06
JA		 3518 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3519
3520 /* This is a hardware imposed limit. */
3521 blk_queue_max_hw_segments(q, MAXSGENTRIES);
1da177e4 3522
a9925a06
JA		 3523 /* This is a limit in the driver and could be eliminated. */
3524 blk_queue_max_phys_segments(q, MAXSGENTRIES);
1da177e4 3525
92c4231a 3526 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
1da177e4 3527
a9925a06 3528 blk_queue_softirq_done(q, cciss_softirq_done);
1da177e4 3529
ad2b9312 3530 q->queuedata = hba[i];
1da177e4 3531 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
1da177e4
LT		 3532 disk->major = hba[i]->major;
3533 disk->first_minor = j << NWD_SHIFT;
3534 disk->fops = &cciss_fops;
ad2b9312 3535 disk->queue = q;
1da177e4 3536 disk->private_data = drv;
27c0ff86 3537 disk->driverfs_dev = &pdev->dev;
1da177e4
LT		 3538 /* we must register the controller even if no disks exist */
3539 /* this is for the online array utilities */
7c832835 3540 if (!drv->heads && j)
1da177e4 3541 continue;
ad2b9312 3542 blk_queue_hardsect_size(q, drv->block_size);
1da177e4 3543 set_capacity(disk, drv->nr_blocks);
799202cb
MM		 3544 j++;
3545 } while (j <= hba[i]->highest_lun);
ad2b9312 3546
e14ac670 3547 /* Make sure all queue data is written out before */
3548 /* interrupt handler, triggered by add_disk, */
3549 /* is allowed to start them. */
3550 wmb();
3551
3552 for (j = 0; j <= hba[i]->highest_lun; j++)
3553 add_disk(hba[i]->gendisk[j]);
3554
77b96bd7
SC		 3555 /* we must register the controller even if no disks exist */
3556 if (hba[i]->highest_lun == -1)
3557 add_disk(hba[i]->gendisk[0]);
3558
e2019b58 3559 return 1;
1da177e4 3560
7c832835 3561 clean4:
3da8b713 3562#ifdef CONFIG_CISS_SCSI_TAPE
1acc0b0b 3563 kfree(hba[i]->scsi_rejects.complete);
3da8b713 3564#endif
6044ec88 3565 kfree(hba[i]->cmd_pool_bits);
7c832835 3566 if (hba[i]->cmd_pool)
1da177e4 3567 pci_free_consistent(hba[i]->pdev,
f880632f 3568 hba[i]->nr_cmds * sizeof(CommandList_struct),
7c832835
BH		 3569 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3570 if (hba[i]->errinfo_pool)
1da177e4 3571 pci_free_consistent(hba[i]->pdev,
f880632f 3572 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
7c832835
BH		 3573 hba[i]->errinfo_pool,
3574 hba[i]->errinfo_pool_dhandle);
fb86a35b 3575 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
7c832835 3576 clean2:
1da177e4 3577 unregister_blkdev(hba[i]->major, hba[i]->devname);
7c832835 3578 clean1:
1f8ef380 3579 hba[i]->busy_initializing = 0;
799202cb
MM		 3580 /* cleanup any queues that may have been initialized */
3581 for (j=0; j <= hba[i]->highest_lun; j++){
3582 drive_info_struct *drv = &(hba[i]->drv[j]);
3583 if (drv->queue)
3584 blk_cleanup_queue(drv->queue);
3585 }
872225ca
MM		 3586 /*
3587 * Deliberately omit pci_disable_device(): it does something nasty to
3588 * Smart Array controllers that pci_enable_device does not undo
3589 */
799202cb 3590 pci_release_regions(pdev);
799202cb 3591 pci_set_drvdata(pdev, NULL);
61808c2b 3592 free_hba(i);
e2019b58 3593 return -1;
1da177e4
LT		 3594}
3595
e9ca75b5 3596static void cciss_shutdown(struct pci_dev *pdev)
1da177e4
LT		 3597{
3598 ctlr_info_t *tmp_ptr;
e9ca75b5 3599 int i;
1da177e4 3600 char flush_buf[4];
7c832835 3601 int return_code;
1da177e4 3602
e9ca75b5
GB		 3603 tmp_ptr = pci_get_drvdata(pdev);
3604 if (tmp_ptr == NULL)
3605 return;
3606 i = tmp_ptr->ctlr;
3607 if (hba[i] == NULL)
3608 return;
3609
3610 /* Turn board interrupts off and send the flush cache command */
3611 /* sendcmd will turn off interrupt, and send the flush...
3612 * To write all data in the battery backed cache to disks */
3613 memset(flush_buf, 0, 4);
3614 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3615 TYPE_CMD);
3616 if (return_code == IO_OK) {
3617 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
3618 } else {
3619 printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
3620 }
3621 free_irq(hba[i]->intr[2], hba[i]);
3622}
3623
3624static void __devexit cciss_remove_one(struct pci_dev *pdev)
3625{
3626 ctlr_info_t *tmp_ptr;
3627 int i, j;
3628
7c832835
BH		 3629 if (pci_get_drvdata(pdev) == NULL) {
3630 printk(KERN_ERR "cciss: Unable to remove device \n");
1da177e4
LT		 3631 return;
3632 }
3633 tmp_ptr = pci_get_drvdata(pdev);
3634 i = tmp_ptr->ctlr;
7c832835 3635 if (hba[i] == NULL) {
1da177e4 3636 printk(KERN_ERR "cciss: device appears to "
7c832835 3637 "already be removed \n");
1da177e4
LT		 3638 return;
3639 }
b6550777
BH		 3640
3641 remove_proc_entry(hba[i]->devname, proc_cciss);
3642 unregister_blkdev(hba[i]->major, hba[i]->devname);
3643
3644 /* remove it from the disk list */
3645 for (j = 0; j < CISS_MAX_LUN; j++) {
3646 struct gendisk *disk = hba[i]->gendisk[j];
3647 if (disk) {
165125e1 3648 struct request_queue *q = disk->queue;
b6550777
BH		 3649
3650 if (disk->flags & GENHD_FL_UP)
3651 del_gendisk(disk);
3652 if (q)
3653 blk_cleanup_queue(q);
3654 }
3655 }
3656
3657 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3658
e9ca75b5 3659 cciss_shutdown(pdev);
fb86a35b
MM		 3660
3661#ifdef CONFIG_PCI_MSI
7c832835
BH		 3662 if (hba[i]->msix_vector)
3663 pci_disable_msix(hba[i]->pdev);
3664 else if (hba[i]->msi_vector)
3665 pci_disable_msi(hba[i]->pdev);
3666#endif /* CONFIG_PCI_MSI */
fb86a35b 3667
1da177e4 3668 iounmap(hba[i]->vaddr);
1da177e4 3669
f880632f 3670 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
1da177e4 3671 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
f880632f 3672 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
7c832835 3673 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
1da177e4 3674 kfree(hba[i]->cmd_pool_bits);
3da8b713 3675#ifdef CONFIG_CISS_SCSI_TAPE
3676 kfree(hba[i]->scsi_rejects.complete);
3677#endif
872225ca
MM		 3678 /*
3679 * Deliberately omit pci_disable_device(): it does something nasty to
3680 * Smart Array controllers that pci_enable_device does not undo
3681 */
7c832835 3682 pci_release_regions(pdev);
4e570309 3683 pci_set_drvdata(pdev, NULL);
1da177e4 3684 free_hba(i);
7c832835 3685}
1da177e4
LT		 3686
3687static struct pci_driver cciss_pci_driver = {
7c832835
BH		 3688 .name = "cciss",
3689 .probe = cciss_init_one,
3690 .remove = __devexit_p(cciss_remove_one),
3691 .id_table = cciss_pci_device_id, /* id_table */
e9ca75b5 3692 .shutdown = cciss_shutdown,
1da177e4
LT		 3693};
3694
3695/*
3696 * This is it. Register the PCI driver information for the cards we control
7c832835 3697 * the OS will call our registered routines when it finds one of our cards.
1da177e4
LT		 3698 */
3699static int __init cciss_init(void)
3700{
3701 printk(KERN_INFO DRIVER_NAME "\n");
3702
3703 /* Register for our PCI devices */
9bfab8ce 3704 return pci_register_driver(&cciss_pci_driver);
1da177e4
LT		 3705}
3706
3707static void __exit cciss_cleanup(void)
3708{
3709 int i;
3710
3711 pci_unregister_driver(&cciss_pci_driver);
3712 /* double check that all controller entrys have been removed */
7c832835
BH		 3713 for (i = 0; i < MAX_CTLR; i++) {
3714 if (hba[i] != NULL) {
1da177e4 3715 printk(KERN_WARNING "cciss: had to remove"
7c832835 3716 " controller %d\n", i);
1da177e4
LT		 3717 cciss_remove_one(hba[i]->pdev);
3718 }
3719 }
928b4d8c 3720 remove_proc_entry("driver/cciss", NULL);
1da177e4
LT		 3721}
3722
33079b21
MM		 3723static void fail_all_cmds(unsigned long ctlr)
3724{
3725 /* If we get here, the board is apparently dead. */
3726 ctlr_info_t *h = hba[ctlr];
3727 CommandList_struct *c;
3728 unsigned long flags;
3729
3730 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
7c832835 3731 h->alive = 0; /* the controller apparently died... */
33079b21
MM		 3732
3733 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3734
7c832835 3735 pci_disable_device(h->pdev); /* Make sure it is really dead. */
33079b21
MM		 3736
3737 /* move everything off the request queue onto the completed queue */
7c832835 3738 while ((c = h->reqQ) != NULL) {
33079b21
MM		 3739 removeQ(&(h->reqQ), c);
3740 h->Qdepth--;
7c832835 3741 addQ(&(h->cmpQ), c);
33079b21
MM		 3742 }
3743
3744 /* Now, fail everything on the completed queue with a HW error */
7c832835 3745 while ((c = h->cmpQ) != NULL) {
33079b21
MM		 3746 removeQ(&h->cmpQ, c);
3747 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3748 if (c->cmd_type == CMD_RWREQ) {
3749 complete_command(h, c, 0);
3750 } else if (c->cmd_type == CMD_IOCTL_PEND)
3751 complete(c->waiting);
3752#ifdef CONFIG_CISS_SCSI_TAPE
7c832835
BH		 3753 else if (c->cmd_type == CMD_SCSI)
3754 complete_scsi_command(c, 0, 0);
33079b21
MM		 3755#endif
3756 }
3757 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3758 return;
3759}
3760
1da177e4
LT		 3761module_init(cciss_init);
3762module_exit(cciss_cleanup);
kernel source for telekom puls (alcatel/mediatek)