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