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