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