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