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