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