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