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