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