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