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