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