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