cciss.c 101.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *    Disk Array driver for HP SA 5xxx and 6xxx Controllers
3
 *    Copyright 2000, 2006 Hewlett-Packard Development Company, L.P.
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *    NON INFRINGEMENT.  See the GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
 *
 */

#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/major.h>
#include <linux/fs.h>
#include <linux/bio.h>
#include <linux/blkpg.h>
#include <linux/timer.h>
#include <linux/proc_fs.h>
36
#include <linux/init.h>
L
Linus Torvalds 已提交
37 38 39
#include <linux/hdreg.h>
#include <linux/spinlock.h>
#include <linux/compat.h>
40
#include <linux/blktrace_api.h>
L
Linus Torvalds 已提交
41 42 43
#include <asm/uaccess.h>
#include <asm/io.h>

44
#include <linux/dma-mapping.h>
L
Linus Torvalds 已提交
45 46 47
#include <linux/blkdev.h>
#include <linux/genhd.h>
#include <linux/completion.h>
48
#include <scsi/scsi.h>
49 50 51
#include <scsi/sg.h>
#include <scsi/scsi_ioctl.h>
#include <linux/cdrom.h>
L
Linus Torvalds 已提交
52 53

#define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
M
Mike Miller 已提交
54 55
#define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
#define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,14)
L
Linus Torvalds 已提交
56 57 58

/* Embedded module documentation macros - see modules.h */
MODULE_AUTHOR("Hewlett-Packard Company");
M
Mike Miller 已提交
59
MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.14");
L
Linus Torvalds 已提交
60
MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
61
			" SA6i P600 P800 P400 P400i E200 E200i E500");
M
Mike Miller 已提交
62
MODULE_VERSION("3.6.14");
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70
MODULE_LICENSE("GPL");

#include "cciss_cmd.h"
#include "cciss.h"
#include <linux/cciss_ioctl.h>

/* define the PCI info for the cards we can control */
static const struct pci_device_id cciss_pci_device_id[] = {
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,  0x0E11, 0x4070},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
	{PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSA,     0x103C, 0x3225},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3235},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3211},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3212},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3213},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3214},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3215},
89
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3237},
90
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x323D},
91 92
	{PCI_VENDOR_ID_HP,     PCI_ANY_ID,	PCI_ANY_ID, PCI_ANY_ID,
		PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
L
Linus Torvalds 已提交
93 94
	{0,}
};
95

L
Linus Torvalds 已提交
96 97 98 99
MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);

/*  board_id = Subsystem Device ID & Vendor ID
 *  product = Marketing Name for the board
100
 *  access = Address of the struct of function pointers
101
 *  nr_cmds = Number of commands supported by controller
L
Linus Torvalds 已提交
102 103
 */
static struct board_type products[] = {
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
	{0x40700E11, "Smart Array 5300", &SA5_access, 512},
	{0x40800E11, "Smart Array 5i", &SA5B_access, 512},
	{0x40820E11, "Smart Array 532", &SA5B_access, 512},
	{0x40830E11, "Smart Array 5312", &SA5B_access, 512},
	{0x409A0E11, "Smart Array 641", &SA5_access, 512},
	{0x409B0E11, "Smart Array 642", &SA5_access, 512},
	{0x409C0E11, "Smart Array 6400", &SA5_access, 512},
	{0x409D0E11, "Smart Array 6400 EM", &SA5_access, 512},
	{0x40910E11, "Smart Array 6i", &SA5_access, 512},
	{0x3225103C, "Smart Array P600", &SA5_access, 512},
	{0x3223103C, "Smart Array P800", &SA5_access, 512},
	{0x3234103C, "Smart Array P400", &SA5_access, 512},
	{0x3235103C, "Smart Array P400i", &SA5_access, 512},
	{0x3211103C, "Smart Array E200i", &SA5_access, 120},
	{0x3212103C, "Smart Array E200", &SA5_access, 120},
	{0x3213103C, "Smart Array E200i", &SA5_access, 120},
	{0x3214103C, "Smart Array E200i", &SA5_access, 120},
	{0x3215103C, "Smart Array E200i", &SA5_access, 120},
122
	{0x3237103C, "Smart Array E500", &SA5_access, 512},
123
	{0x323D103C, "Smart Array P700m", &SA5_access, 512},
124
	{0xFFFF103C, "Unknown Smart Array", &SA5_access, 120},
L
Linus Torvalds 已提交
125 126
};

127
/* How long to wait (in milliseconds) for board to go into simple mode */
128
#define MAX_CONFIG_WAIT 30000
L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142
#define MAX_IOCTL_CONFIG_WAIT 1000

/*define how many times we will try a command because of bus resets */
#define MAX_CMD_RETRIES 3

#define READ_AHEAD 	 1024
#define MAX_CTLR	32

/* Originally cciss driver only supports 8 major numbers */
#define MAX_CTLR_ORIG 	8

static ctlr_info_t *hba[MAX_CTLR];

static void do_cciss_request(request_queue_t *q);
143
static irqreturn_t do_cciss_intr(int irq, void *dev_id);
L
Linus Torvalds 已提交
144 145
static int cciss_open(struct inode *inode, struct file *filep);
static int cciss_release(struct inode *inode, struct file *filep);
146 147
static int cciss_ioctl(struct inode *inode, struct file *filep,
		       unsigned int cmd, unsigned long arg);
148
static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
L
Linus Torvalds 已提交
149 150

static int cciss_revalidate(struct gendisk *disk);
151
static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
152 153
static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
			   int clear_all);
L
Linus Torvalds 已提交
154

155 156 157 158 159 160 161
static void cciss_read_capacity(int ctlr, int logvol, int withirq,
			sector_t *total_size, unsigned int *block_size);
static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
			sector_t *total_size, unsigned int *block_size);
static void cciss_geometry_inquiry(int ctlr, int logvol,
			int withirq, sector_t total_size,
			unsigned int block_size, InquiryData_struct *inq_buff,
162
				   drive_info_struct *drv);
L
Linus Torvalds 已提交
163
static void cciss_getgeometry(int cntl_num);
164 165 166 167 168 169 170 171 172
static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
					   __u32);
static void start_io(ctlr_info_t *h);
static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
		   unsigned int use_unit_num, unsigned int log_unit,
		   __u8 page_code, unsigned char *scsi3addr, int cmd_type);
static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
			   unsigned int use_unit_num, unsigned int log_unit,
			   __u8 page_code, int cmd_type);
L
Linus Torvalds 已提交
173

174 175
static void fail_all_cmds(unsigned long ctlr);

L
Linus Torvalds 已提交
176
#ifdef CONFIG_PROC_FS
177 178
static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
			       int length, int *eof, void *data);
L
Linus Torvalds 已提交
179 180
static void cciss_procinit(int i);
#else
181 182 183 184
static void cciss_procinit(int i)
{
}
#endif				/* CONFIG_PROC_FS */
L
Linus Torvalds 已提交
185 186 187 188 189

#ifdef CONFIG_COMPAT
static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
#endif

190 191 192 193 194 195
static struct block_device_operations cciss_fops = {
	.owner = THIS_MODULE,
	.open = cciss_open,
	.release = cciss_release,
	.ioctl = cciss_ioctl,
	.getgeo = cciss_getgeo,
L
Linus Torvalds 已提交
196
#ifdef CONFIG_COMPAT
197
	.compat_ioctl = cciss_compat_ioctl,
L
Linus Torvalds 已提交
198
#endif
199
	.revalidate_disk = cciss_revalidate,
L
Linus Torvalds 已提交
200 201 202 203 204 205 206
};

/*
 * Enqueuing and dequeuing functions for cmdlists.
 */
static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
{
207 208 209 210 211 212 213 214 215
	if (*Qptr == NULL) {
		*Qptr = c;
		c->next = c->prev = c;
	} else {
		c->prev = (*Qptr)->prev;
		c->next = (*Qptr);
		(*Qptr)->prev->next = c;
		(*Qptr)->prev = c;
	}
L
Linus Torvalds 已提交
216 217
}

218 219
static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
					  CommandList_struct *c)
L
Linus Torvalds 已提交
220
{
221 222 223 224 225 226 227 228 229
	if (c && c->next != c) {
		if (*Qptr == c)
			*Qptr = c->next;
		c->prev->next = c->next;
		c->next->prev = c->prev;
	} else {
		*Qptr = NULL;
	}
	return c;
L
Linus Torvalds 已提交
230 231 232 233
}

#include "cciss_scsi.c"		/* For SCSI tape support */

R
Randy Dunlap 已提交
234 235
#define RAID_UNKNOWN 6

L
Linus Torvalds 已提交
236 237 238 239 240 241 242
#ifdef CONFIG_PROC_FS

/*
 * Report information about this controller.
 */
#define ENG_GIG 1000000000
#define ENG_GIG_FACTOR (ENG_GIG/512)
243 244 245
static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
	"UNKNOWN"
};
L
Linus Torvalds 已提交
246 247 248

static struct proc_dir_entry *proc_cciss;

249 250
static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
			       int length, int *eof, void *data)
L
Linus Torvalds 已提交
251
{
252 253 254 255 256
	off_t pos = 0;
	off_t len = 0;
	int size, i, ctlr;
	ctlr_info_t *h = (ctlr_info_t *) data;
	drive_info_struct *drv;
L
Linus Torvalds 已提交
257
	unsigned long flags;
258
	sector_t vol_sz, vol_sz_frac;
L
Linus Torvalds 已提交
259

260
	ctlr = h->ctlr;
L
Linus Torvalds 已提交
261 262 263 264 265 266 267

	/* prevent displaying bogus info during configuration
	 * or deconfiguration of a logical volume
	 */
	spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
	if (h->busy_configuring) {
		spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
268
		return -EBUSY;
L
Linus Torvalds 已提交
269 270 271 272
	}
	h->busy_configuring = 1;
	spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);

273 274 275 276 277
	size = sprintf(buffer, "%s: HP %s Controller\n"
		       "Board ID: 0x%08lx\n"
		       "Firmware Version: %c%c%c%c\n"
		       "IRQ: %d\n"
		       "Logical drives: %d\n"
278
		       "Max sectors: %d\n"
279 280 281 282 283 284 285 286 287 288
		       "Current Q depth: %d\n"
		       "Current # commands on controller: %d\n"
		       "Max Q depth since init: %d\n"
		       "Max # commands on controller since init: %d\n"
		       "Max SG entries since init: %d\n\n",
		       h->devname,
		       h->product_name,
		       (unsigned long)h->board_id,
		       h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
		       h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
289 290 291
		       h->num_luns,
		       h->cciss_max_sectors,
		       h->Qdepth, h->commands_outstanding,
292 293 294 295
		       h->maxQsinceinit, h->max_outstanding, h->maxSG);

	pos += size;
	len += size;
L
Linus Torvalds 已提交
296
	cciss_proc_tape_report(ctlr, buffer, &pos, &len);
297
	for (i = 0; i <= h->highest_lun; i++) {
L
Linus Torvalds 已提交
298

299
		drv = &h->drv[i];
300
		if (drv->heads == 0)
L
Linus Torvalds 已提交
301 302 303 304 305 306 307 308 309
			continue;

		vol_sz = drv->nr_blocks;
		vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
		vol_sz_frac *= 100;
		sector_div(vol_sz_frac, ENG_GIG_FACTOR);

		if (drv->raid_level > 5)
			drv->raid_level = RAID_UNKNOWN;
310 311 312 313 314 315 316 317 318 319 320 321 322
		size = sprintf(buffer + len, "cciss/c%dd%d:"
			       "\t%4u.%02uGB\tRAID %s\n",
			       ctlr, i, (int)vol_sz, (int)vol_sz_frac,
			       raid_label[drv->raid_level]);
		pos += size;
		len += size;
	}

	*eof = 1;
	*start = buffer + offset;
	len -= offset;
	if (len > length)
		len = length;
L
Linus Torvalds 已提交
323
	h->busy_configuring = 0;
324
	return len;
L
Linus Torvalds 已提交
325 326
}

327 328 329
static int
cciss_proc_write(struct file *file, const char __user *buffer,
		 unsigned long count, void *data)
L
Linus Torvalds 已提交
330 331 332 333 334 335 336 337
{
	unsigned char cmd[80];
	int len;
#ifdef CONFIG_CISS_SCSI_TAPE
	ctlr_info_t *h = (ctlr_info_t *) data;
	int rc;
#endif

338 339 340 341
	if (count > sizeof(cmd) - 1)
		return -EINVAL;
	if (copy_from_user(cmd, buffer, count))
		return -EFAULT;
L
Linus Torvalds 已提交
342 343
	cmd[count] = '\0';
	len = strlen(cmd);	// above 3 lines ensure safety
344
	if (len && cmd[len - 1] == '\n')
L
Linus Torvalds 已提交
345 346
		cmd[--len] = '\0';
#	ifdef CONFIG_CISS_SCSI_TAPE
347 348 349 350 351 352 353 354
	if (strcmp("engage scsi", cmd) == 0) {
		rc = cciss_engage_scsi(h->ctlr);
		if (rc != 0)
			return -rc;
		return count;
	}
	/* might be nice to have "disengage" too, but it's not
	   safely possible. (only 1 module use count, lock issues.) */
L
Linus Torvalds 已提交
355 356 357 358 359 360 361 362 363 364 365 366
#	endif
	return -EINVAL;
}

/*
 * Get us a file in /proc/cciss that says something about each controller.
 * Create /proc/cciss if it doesn't exist yet.
 */
static void __devinit cciss_procinit(int i)
{
	struct proc_dir_entry *pde;

367 368 369
	if (proc_cciss == NULL) {
		proc_cciss = proc_mkdir("cciss", proc_root_driver);
		if (!proc_cciss)
L
Linus Torvalds 已提交
370
			return;
371
	}
L
Linus Torvalds 已提交
372

373 374 375
	pde = create_proc_read_entry(hba[i]->devname,
				     S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
				     proc_cciss, cciss_proc_get_info, hba[i]);
L
Linus Torvalds 已提交
376 377
	pde->write_proc = cciss_proc_write;
}
378
#endif				/* CONFIG_PROC_FS */
L
Linus Torvalds 已提交
379

380 381
/*
 * For operations that cannot sleep, a command block is allocated at init,
L
Linus Torvalds 已提交
382
 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
383 384 385 386 387
 * which ones are free or in use.  For operations that can wait for kmalloc
 * to possible sleep, this routine can be called with get_from_pool set to 0.
 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
 */
static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
L
Linus Torvalds 已提交
388 389
{
	CommandList_struct *c;
390
	int i;
L
Linus Torvalds 已提交
391 392 393
	u64bit temp64;
	dma_addr_t cmd_dma_handle, err_dma_handle;

394 395 396 397 398
	if (!get_from_pool) {
		c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
			sizeof(CommandList_struct), &cmd_dma_handle);
		if (c == NULL)
			return NULL;
L
Linus Torvalds 已提交
399 400
		memset(c, 0, sizeof(CommandList_struct));

401 402
		c->cmdindex = -1;

403 404 405 406 407 408
		c->err_info = (ErrorInfo_struct *)
		    pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
			    &err_dma_handle);

		if (c->err_info == NULL) {
			pci_free_consistent(h->pdev,
L
Linus Torvalds 已提交
409 410 411 412
				sizeof(CommandList_struct), c, cmd_dma_handle);
			return NULL;
		}
		memset(c->err_info, 0, sizeof(ErrorInfo_struct));
413 414 415
	} else {		/* get it out of the controllers pool */

		do {
416 417
			i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
			if (i == h->nr_cmds)
418 419 420 421
				return NULL;
		} while (test_and_set_bit
			 (i & (BITS_PER_LONG - 1),
			  h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
L
Linus Torvalds 已提交
422 423 424
#ifdef CCISS_DEBUG
		printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
#endif
425
		c = h->cmd_pool + i;
L
Linus Torvalds 已提交
426
		memset(c, 0, sizeof(CommandList_struct));
427 428
		cmd_dma_handle = h->cmd_pool_dhandle
		    + i * sizeof(CommandList_struct);
L
Linus Torvalds 已提交
429 430
		c->err_info = h->errinfo_pool + i;
		memset(c->err_info, 0, sizeof(ErrorInfo_struct));
431 432 433
		err_dma_handle = h->errinfo_pool_dhandle
		    + i * sizeof(ErrorInfo_struct);
		h->nr_allocs++;
434 435

		c->cmdindex = i;
436
	}
L
Linus Torvalds 已提交
437 438

	c->busaddr = (__u32) cmd_dma_handle;
439
	temp64.val = (__u64) err_dma_handle;
L
Linus Torvalds 已提交
440 441 442 443
	c->ErrDesc.Addr.lower = temp64.val32.lower;
	c->ErrDesc.Addr.upper = temp64.val32.upper;
	c->ErrDesc.Len = sizeof(ErrorInfo_struct);

444 445
	c->ctlr = h->ctlr;
	return c;
L
Linus Torvalds 已提交
446 447
}

448 449
/*
 * Frees a command block that was previously allocated with cmd_alloc().
L
Linus Torvalds 已提交
450 451 452 453 454 455
 */
static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
{
	int i;
	u64bit temp64;

456
	if (!got_from_pool) {
L
Linus Torvalds 已提交
457 458
		temp64.val32.lower = c->ErrDesc.Addr.lower;
		temp64.val32.upper = c->ErrDesc.Addr.upper;
459 460 461 462 463
		pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
				    c->err_info, (dma_addr_t) temp64.val);
		pci_free_consistent(h->pdev, sizeof(CommandList_struct),
				    c, (dma_addr_t) c->busaddr);
	} else {
L
Linus Torvalds 已提交
464
		i = c - h->cmd_pool;
465 466 467 468
		clear_bit(i & (BITS_PER_LONG - 1),
			  h->cmd_pool_bits + (i / BITS_PER_LONG));
		h->nr_frees++;
	}
L
Linus Torvalds 已提交
469 470 471 472
}

static inline ctlr_info_t *get_host(struct gendisk *disk)
{
473
	return disk->queue->queuedata;
L
Linus Torvalds 已提交
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
}

static inline drive_info_struct *get_drv(struct gendisk *disk)
{
	return disk->private_data;
}

/*
 * Open.  Make sure the device is really there.
 */
static int cciss_open(struct inode *inode, struct file *filep)
{
	ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
	drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);

#ifdef CCISS_DEBUG
	printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
491
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
492

493 494
	if (host->busy_initializing || drv->busy_configuring)
		return -EBUSY;
L
Linus Torvalds 已提交
495 496 497 498 499 500 501 502
	/*
	 * Root is allowed to open raw volume zero even if it's not configured
	 * so array config can still work. Root is also allowed to open any
	 * volume that has a LUN ID, so it can issue IOCTL to reread the
	 * disk information.  I don't think I really like this
	 * but I'm already using way to many device nodes to claim another one
	 * for "raw controller".
	 */
503
	if (drv->heads == 0) {
504
		if (iminor(inode) != 0) {	/* not node 0? */
L
Linus Torvalds 已提交
505 506
			/* if not node 0 make sure it is a partition = 0 */
			if (iminor(inode) & 0x0f) {
507
				return -ENXIO;
L
Linus Torvalds 已提交
508 509 510 511 512 513 514 515 516 517 518 519
				/* if it is, make sure we have a LUN ID */
			} else if (drv->LunID == 0) {
				return -ENXIO;
			}
		}
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;
	}
	drv->usage_count++;
	host->usage_count++;
	return 0;
}
520

L
Linus Torvalds 已提交
521 522 523 524 525 526 527 528 529
/*
 * Close.  Sync first.
 */
static int cciss_release(struct inode *inode, struct file *filep)
{
	ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
	drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);

#ifdef CCISS_DEBUG
530 531 532
	printk(KERN_DEBUG "cciss_release %s\n",
	       inode->i_bdev->bd_disk->disk_name);
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540 541 542 543 544

	drv->usage_count--;
	host->usage_count--;
	return 0;
}

#ifdef CONFIG_COMPAT

static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
{
	int ret;
	lock_kernel();
545
	ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);
L
Linus Torvalds 已提交
546 547 548 549
	unlock_kernel();
	return ret;
}

550 551 552 553
static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
				  unsigned long arg);
static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
				      unsigned long arg);
L
Linus Torvalds 已提交
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
{
	switch (cmd) {
	case CCISS_GETPCIINFO:
	case CCISS_GETINTINFO:
	case CCISS_SETINTINFO:
	case CCISS_GETNODENAME:
	case CCISS_SETNODENAME:
	case CCISS_GETHEARTBEAT:
	case CCISS_GETBUSTYPES:
	case CCISS_GETFIRMVER:
	case CCISS_GETDRIVVER:
	case CCISS_REVALIDVOLS:
	case CCISS_DEREGDISK:
	case CCISS_REGNEWDISK:
	case CCISS_REGNEWD:
	case CCISS_RESCANDISK:
	case CCISS_GETLUNINFO:
		return do_ioctl(f, cmd, arg);

	case CCISS_PASSTHRU32:
		return cciss_ioctl32_passthru(f, cmd, arg);
	case CCISS_BIG_PASSTHRU32:
		return cciss_ioctl32_big_passthru(f, cmd, arg);

	default:
		return -ENOIOCTLCMD;
	}
}

585 586
static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
				  unsigned long arg)
L
Linus Torvalds 已提交
587 588
{
	IOCTL32_Command_struct __user *arg32 =
589
	    (IOCTL32_Command_struct __user *) arg;
L
Linus Torvalds 已提交
590 591 592 593 594 595
	IOCTL_Command_struct arg64;
	IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
	int err;
	u32 cp;

	err = 0;
596 597 598 599 600 601 602 603 604
	err |=
	    copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
			   sizeof(arg64.LUN_info));
	err |=
	    copy_from_user(&arg64.Request, &arg32->Request,
			   sizeof(arg64.Request));
	err |=
	    copy_from_user(&arg64.error_info, &arg32->error_info,
			   sizeof(arg64.error_info));
L
Linus Torvalds 已提交
605 606 607 608 609 610 611 612
	err |= get_user(arg64.buf_size, &arg32->buf_size);
	err |= get_user(cp, &arg32->buf);
	arg64.buf = compat_ptr(cp);
	err |= copy_to_user(p, &arg64, sizeof(arg64));

	if (err)
		return -EFAULT;

613
	err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
L
Linus Torvalds 已提交
614 615
	if (err)
		return err;
616 617 618
	err |=
	    copy_in_user(&arg32->error_info, &p->error_info,
			 sizeof(arg32->error_info));
L
Linus Torvalds 已提交
619 620 621 622 623
	if (err)
		return -EFAULT;
	return err;
}

624 625
static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
				      unsigned long arg)
L
Linus Torvalds 已提交
626 627
{
	BIG_IOCTL32_Command_struct __user *arg32 =
628
	    (BIG_IOCTL32_Command_struct __user *) arg;
L
Linus Torvalds 已提交
629
	BIG_IOCTL_Command_struct arg64;
630 631
	BIG_IOCTL_Command_struct __user *p =
	    compat_alloc_user_space(sizeof(arg64));
L
Linus Torvalds 已提交
632 633 634 635
	int err;
	u32 cp;

	err = 0;
636 637 638 639 640 641 642 643 644
	err |=
	    copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
			   sizeof(arg64.LUN_info));
	err |=
	    copy_from_user(&arg64.Request, &arg32->Request,
			   sizeof(arg64.Request));
	err |=
	    copy_from_user(&arg64.error_info, &arg32->error_info,
			   sizeof(arg64.error_info));
L
Linus Torvalds 已提交
645 646 647 648 649 650 651
	err |= get_user(arg64.buf_size, &arg32->buf_size);
	err |= get_user(arg64.malloc_size, &arg32->malloc_size);
	err |= get_user(cp, &arg32->buf);
	arg64.buf = compat_ptr(cp);
	err |= copy_to_user(p, &arg64, sizeof(arg64));

	if (err)
652
		return -EFAULT;
L
Linus Torvalds 已提交
653

654
	err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
L
Linus Torvalds 已提交
655 656
	if (err)
		return err;
657 658 659
	err |=
	    copy_in_user(&arg32->error_info, &p->error_info,
			 sizeof(arg32->error_info));
L
Linus Torvalds 已提交
660 661 662 663 664
	if (err)
		return -EFAULT;
	return err;
}
#endif
665 666 667 668 669 670 671 672 673 674 675 676 677 678

static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	drive_info_struct *drv = get_drv(bdev->bd_disk);

	if (!drv->cylinders)
		return -ENXIO;

	geo->heads = drv->heads;
	geo->sectors = drv->sectors;
	geo->cylinders = drv->cylinders;
	return 0;
}

L
Linus Torvalds 已提交
679
/*
680
 * ioctl
L
Linus Torvalds 已提交
681
 */
682 683
static int cciss_ioctl(struct inode *inode, struct file *filep,
		       unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
684 685 686 687 688 689 690 691 692 693
{
	struct block_device *bdev = inode->i_bdev;
	struct gendisk *disk = bdev->bd_disk;
	ctlr_info_t *host = get_host(disk);
	drive_info_struct *drv = get_drv(disk);
	int ctlr = host->ctlr;
	void __user *argp = (void __user *)arg;

#ifdef CCISS_DEBUG
	printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
694 695 696
#endif				/* CCISS_DEBUG */

	switch (cmd) {
L
Linus Torvalds 已提交
697
	case CCISS_GETPCIINFO:
698 699 700 701 702 703 704 705 706 707 708 709 710 711
		{
			cciss_pci_info_struct pciinfo;

			if (!arg)
				return -EINVAL;
			pciinfo.domain = pci_domain_nr(host->pdev->bus);
			pciinfo.bus = host->pdev->bus->number;
			pciinfo.dev_fn = host->pdev->devfn;
			pciinfo.board_id = host->board_id;
			if (copy_to_user
			    (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
712
	case CCISS_GETINTINFO:
713 714 715 716 717 718 719 720 721 722 723 724 725
		{
			cciss_coalint_struct intinfo;
			if (!arg)
				return -EINVAL;
			intinfo.delay =
			    readl(&host->cfgtable->HostWrite.CoalIntDelay);
			intinfo.count =
			    readl(&host->cfgtable->HostWrite.CoalIntCount);
			if (copy_to_user
			    (argp, &intinfo, sizeof(cciss_coalint_struct)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
726 727
	case CCISS_SETINTINFO:
		{
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
			cciss_coalint_struct intinfo;
			unsigned long flags;
			int i;

			if (!arg)
				return -EINVAL;
			if (!capable(CAP_SYS_ADMIN))
				return -EPERM;
			if (copy_from_user
			    (&intinfo, argp, sizeof(cciss_coalint_struct)))
				return -EFAULT;
			if ((intinfo.delay == 0) && (intinfo.count == 0))
			{
//                      printk("cciss_ioctl: delay and count cannot be 0\n");
				return -EINVAL;
			}
			spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
			/* Update the field, and then ring the doorbell */
			writel(intinfo.delay,
			       &(host->cfgtable->HostWrite.CoalIntDelay));
			writel(intinfo.count,
			       &(host->cfgtable->HostWrite.CoalIntCount));
			writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);

			for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
				if (!(readl(host->vaddr + SA5_DOORBELL)
				      & CFGTBL_ChangeReq))
					break;
				/* delay and try again */
				udelay(1000);
			}
			spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
			if (i >= MAX_IOCTL_CONFIG_WAIT)
				return -EAGAIN;
			return 0;
L
Linus Torvalds 已提交
763 764
		}
	case CCISS_GETNODENAME:
765 766 767 768 769 770 771 772 773 774 775 776 777
		{
			NodeName_type NodeName;
			int i;

			if (!arg)
				return -EINVAL;
			for (i = 0; i < 16; i++)
				NodeName[i] =
				    readb(&host->cfgtable->ServerName[i]);
			if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
778
	case CCISS_SETNODENAME:
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
		{
			NodeName_type NodeName;
			unsigned long flags;
			int i;

			if (!arg)
				return -EINVAL;
			if (!capable(CAP_SYS_ADMIN))
				return -EPERM;

			if (copy_from_user
			    (NodeName, argp, sizeof(NodeName_type)))
				return -EFAULT;

			spin_lock_irqsave(CCISS_LOCK(ctlr), flags);

			/* Update the field, and then ring the doorbell */
			for (i = 0; i < 16; i++)
				writeb(NodeName[i],
				       &host->cfgtable->ServerName[i]);

			writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);

			for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
				if (!(readl(host->vaddr + SA5_DOORBELL)
				      & CFGTBL_ChangeReq))
					break;
				/* delay and try again */
				udelay(1000);
			}
			spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
			if (i >= MAX_IOCTL_CONFIG_WAIT)
				return -EAGAIN;
			return 0;
		}
L
Linus Torvalds 已提交
814 815

	case CCISS_GETHEARTBEAT:
816 817 818 819 820 821 822 823 824 825 826
		{
			Heartbeat_type heartbeat;

			if (!arg)
				return -EINVAL;
			heartbeat = readl(&host->cfgtable->HeartBeat);
			if (copy_to_user
			    (argp, &heartbeat, sizeof(Heartbeat_type)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
827
	case CCISS_GETBUSTYPES:
828 829 830 831 832 833 834 835 836 837 838
		{
			BusTypes_type BusTypes;

			if (!arg)
				return -EINVAL;
			BusTypes = readl(&host->cfgtable->BusTypes);
			if (copy_to_user
			    (argp, &BusTypes, sizeof(BusTypes_type)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
839
	case CCISS_GETFIRMVER:
840 841
		{
			FirmwareVer_type firmware;
L
Linus Torvalds 已提交
842

843 844 845
			if (!arg)
				return -EINVAL;
			memcpy(firmware, host->firm_ver, 4);
L
Linus Torvalds 已提交
846

847 848 849 850 851 852 853 854
			if (copy_to_user
			    (argp, firmware, sizeof(FirmwareVer_type)))
				return -EFAULT;
			return 0;
		}
	case CCISS_GETDRIVVER:
		{
			DriverVer_type DriverVer = DRIVER_VERSION;
L
Linus Torvalds 已提交
855

856 857
			if (!arg)
				return -EINVAL;
L
Linus Torvalds 已提交
858

859 860 861 862 863
			if (copy_to_user
			    (argp, &DriverVer, sizeof(DriverVer_type)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
864 865

	case CCISS_REVALIDVOLS:
866
		return rebuild_lun_table(host, NULL);
867 868 869 870 871 872 873 874 875 876 877 878

	case CCISS_GETLUNINFO:{
			LogvolInfo_struct luninfo;

			luninfo.LunID = drv->LunID;
			luninfo.num_opens = drv->usage_count;
			luninfo.num_parts = 0;
			if (copy_to_user(argp, &luninfo,
					 sizeof(LogvolInfo_struct)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
879
	case CCISS_DEREGDISK:
880
		return rebuild_lun_table(host, disk);
L
Linus Torvalds 已提交
881 882

	case CCISS_REGNEWD:
883
		return rebuild_lun_table(host, NULL);
L
Linus Torvalds 已提交
884 885 886

	case CCISS_PASSTHRU:
		{
887 888 889 890 891
			IOCTL_Command_struct iocommand;
			CommandList_struct *c;
			char *buff = NULL;
			u64bit temp64;
			unsigned long flags;
892
			DECLARE_COMPLETION_ONSTACK(wait);
L
Linus Torvalds 已提交
893

894 895
			if (!arg)
				return -EINVAL;
L
Linus Torvalds 已提交
896

897 898
			if (!capable(CAP_SYS_RAWIO))
				return -EPERM;
L
Linus Torvalds 已提交
899

900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
			if (copy_from_user
			    (&iocommand, argp, sizeof(IOCTL_Command_struct)))
				return -EFAULT;
			if ((iocommand.buf_size < 1) &&
			    (iocommand.Request.Type.Direction != XFER_NONE)) {
				return -EINVAL;
			}
#if 0				/* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
			/* Check kmalloc limits */
			if (iocommand.buf_size > 128000)
				return -EINVAL;
#endif
			if (iocommand.buf_size > 0) {
				buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
				if (buff == NULL)
					return -EFAULT;
			}
			if (iocommand.Request.Type.Direction == XFER_WRITE) {
				/* Copy the data into the buffer we created */
				if (copy_from_user
				    (buff, iocommand.buf, iocommand.buf_size)) {
					kfree(buff);
					return -EFAULT;
				}
			} else {
				memset(buff, 0, iocommand.buf_size);
			}
			if ((c = cmd_alloc(host, 0)) == NULL) {
				kfree(buff);
				return -ENOMEM;
			}
			// Fill in the command type
			c->cmd_type = CMD_IOCTL_PEND;
			// Fill in Command Header
			c->Header.ReplyQueue = 0;	// unused in simple mode
			if (iocommand.buf_size > 0)	// buffer to fill
			{
				c->Header.SGList = 1;
				c->Header.SGTotal = 1;
			} else	// no buffers to fill
			{
				c->Header.SGList = 0;
				c->Header.SGTotal = 0;
			}
			c->Header.LUN = iocommand.LUN_info;
			c->Header.Tag.lower = c->busaddr;	// use the kernel address the cmd block for tag
L
Linus Torvalds 已提交
946

947 948
			// Fill in Request block
			c->Request = iocommand.Request;
L
Linus Torvalds 已提交
949

950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
			// Fill in the scatter gather information
			if (iocommand.buf_size > 0) {
				temp64.val = pci_map_single(host->pdev, buff,
					iocommand.buf_size,
					PCI_DMA_BIDIRECTIONAL);
				c->SG[0].Addr.lower = temp64.val32.lower;
				c->SG[0].Addr.upper = temp64.val32.upper;
				c->SG[0].Len = iocommand.buf_size;
				c->SG[0].Ext = 0;	// we are not chaining
			}
			c->waiting = &wait;

			/* Put the request on the tail of the request queue */
			spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
			addQ(&host->reqQ, c);
			host->Qdepth++;
			start_io(host);
			spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);

			wait_for_completion(&wait);

			/* unlock the buffers from DMA */
			temp64.val32.lower = c->SG[0].Addr.lower;
			temp64.val32.upper = c->SG[0].Addr.upper;
			pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
					 iocommand.buf_size,
					 PCI_DMA_BIDIRECTIONAL);

			/* Copy the error information out */
			iocommand.error_info = *(c->err_info);
			if (copy_to_user
			    (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
				kfree(buff);
L
Linus Torvalds 已提交
983 984 985
				cmd_free(host, c, 0);
				return -EFAULT;
			}
986 987 988 989 990 991 992 993 994 995 996 997 998

			if (iocommand.Request.Type.Direction == XFER_READ) {
				/* Copy the data out of the buffer we created */
				if (copy_to_user
				    (iocommand.buf, buff, iocommand.buf_size)) {
					kfree(buff);
					cmd_free(host, c, 0);
					return -EFAULT;
				}
			}
			kfree(buff);
			cmd_free(host, c, 0);
			return 0;
L
Linus Torvalds 已提交
999
		}
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	case CCISS_BIG_PASSTHRU:{
			BIG_IOCTL_Command_struct *ioc;
			CommandList_struct *c;
			unsigned char **buff = NULL;
			int *buff_size = NULL;
			u64bit temp64;
			unsigned long flags;
			BYTE sg_used = 0;
			int status = 0;
			int i;
1010
			DECLARE_COMPLETION_ONSTACK(wait);
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
			__u32 left;
			__u32 sz;
			BYTE __user *data_ptr;

			if (!arg)
				return -EINVAL;
			if (!capable(CAP_SYS_RAWIO))
				return -EPERM;
			ioc = (BIG_IOCTL_Command_struct *)
			    kmalloc(sizeof(*ioc), GFP_KERNEL);
			if (!ioc) {
				status = -ENOMEM;
				goto cleanup1;
			}
			if (copy_from_user(ioc, argp, sizeof(*ioc))) {
				status = -EFAULT;
				goto cleanup1;
			}
			if ((ioc->buf_size < 1) &&
			    (ioc->Request.Type.Direction != XFER_NONE)) {
L
Linus Torvalds 已提交
1031 1032
				status = -EINVAL;
				goto cleanup1;
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
			}
			/* Check kmalloc limits  using all SGs */
			if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
				status = -EINVAL;
				goto cleanup1;
			}
			if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
				status = -EINVAL;
				goto cleanup1;
			}
			buff =
			    kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
			if (!buff) {
L
Linus Torvalds 已提交
1046 1047 1048
				status = -ENOMEM;
				goto cleanup1;
			}
1049
			buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
						   GFP_KERNEL);
			if (!buff_size) {
				status = -ENOMEM;
				goto cleanup1;
			}
			left = ioc->buf_size;
			data_ptr = ioc->buf;
			while (left) {
				sz = (left >
				      ioc->malloc_size) ? ioc->
				    malloc_size : left;
				buff_size[sg_used] = sz;
				buff[sg_used] = kmalloc(sz, GFP_KERNEL);
				if (buff[sg_used] == NULL) {
L
Linus Torvalds 已提交
1064
					status = -ENOMEM;
1065 1066
					goto cleanup1;
				}
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
				if (ioc->Request.Type.Direction == XFER_WRITE) {
					if (copy_from_user
					    (buff[sg_used], data_ptr, sz)) {
						status = -ENOMEM;
						goto cleanup1;
					}
				} else {
					memset(buff[sg_used], 0, sz);
				}
				left -= sz;
				data_ptr += sz;
				sg_used++;
			}
			if ((c = cmd_alloc(host, 0)) == NULL) {
				status = -ENOMEM;
				goto cleanup1;
			}
			c->cmd_type = CMD_IOCTL_PEND;
			c->Header.ReplyQueue = 0;

			if (ioc->buf_size > 0) {
				c->Header.SGList = sg_used;
				c->Header.SGTotal = sg_used;
L
Linus Torvalds 已提交
1090
			} else {
1091 1092
				c->Header.SGList = 0;
				c->Header.SGTotal = 0;
L
Linus Torvalds 已提交
1093
			}
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
			c->Header.LUN = ioc->LUN_info;
			c->Header.Tag.lower = c->busaddr;

			c->Request = ioc->Request;
			if (ioc->buf_size > 0) {
				int i;
				for (i = 0; i < sg_used; i++) {
					temp64.val =
					    pci_map_single(host->pdev, buff[i],
						    buff_size[i],
						    PCI_DMA_BIDIRECTIONAL);
					c->SG[i].Addr.lower =
					    temp64.val32.lower;
					c->SG[i].Addr.upper =
					    temp64.val32.upper;
					c->SG[i].Len = buff_size[i];
					c->SG[i].Ext = 0;	/* we are not chaining */
				}
			}
			c->waiting = &wait;
			/* Put the request on the tail of the request queue */
			spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
			addQ(&host->reqQ, c);
			host->Qdepth++;
			start_io(host);
			spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
			wait_for_completion(&wait);
			/* unlock the buffers from DMA */
			for (i = 0; i < sg_used; i++) {
				temp64.val32.lower = c->SG[i].Addr.lower;
				temp64.val32.upper = c->SG[i].Addr.upper;
				pci_unmap_single(host->pdev,
					(dma_addr_t) temp64.val, buff_size[i],
L
Linus Torvalds 已提交
1127 1128
					PCI_DMA_BIDIRECTIONAL);
			}
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
			/* Copy the error information out */
			ioc->error_info = *(c->err_info);
			if (copy_to_user(argp, ioc, sizeof(*ioc))) {
				cmd_free(host, c, 0);
				status = -EFAULT;
				goto cleanup1;
			}
			if (ioc->Request.Type.Direction == XFER_READ) {
				/* Copy the data out of the buffer we created */
				BYTE __user *ptr = ioc->buf;
				for (i = 0; i < sg_used; i++) {
					if (copy_to_user
					    (ptr, buff[i], buff_size[i])) {
						cmd_free(host, c, 0);
						status = -EFAULT;
						goto cleanup1;
					}
					ptr += buff_size[i];
L
Linus Torvalds 已提交
1147 1148
				}
			}
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
			cmd_free(host, c, 0);
			status = 0;
		      cleanup1:
			if (buff) {
				for (i = 0; i < sg_used; i++)
					kfree(buff[i]);
				kfree(buff);
			}
			kfree(buff_size);
			kfree(ioc);
			return status;
L
Linus Torvalds 已提交
1160
		}
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172

	/* scsi_cmd_ioctl handles these, below, though some are not */
	/* very meaningful for cciss.  SG_IO is the main one people want. */

	case SG_GET_VERSION_NUM:
	case SG_SET_TIMEOUT:
	case SG_GET_TIMEOUT:
	case SG_GET_RESERVED_SIZE:
	case SG_SET_RESERVED_SIZE:
	case SG_EMULATED_HOST:
	case SG_IO:
	case SCSI_IOCTL_SEND_COMMAND:
1173
		return scsi_cmd_ioctl(filep, disk->queue, disk, cmd, argp);
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184

	/* scsi_cmd_ioctl would normally handle these, below, but */
	/* they aren't a good fit for cciss, as CD-ROMs are */
	/* not supported, and we don't have any bus/target/lun */
	/* which we present to the kernel. */

	case CDROM_SEND_PACKET:
	case CDROMCLOSETRAY:
	case CDROMEJECT:
	case SCSI_IOCTL_GET_IDLUN:
	case SCSI_IOCTL_GET_BUS_NUMBER:
L
Linus Torvalds 已提交
1185 1186 1187 1188 1189
	default:
		return -ENOTTY;
	}
}

1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
static inline void complete_buffers(struct bio *bio, int status)
{
	while (bio) {
		struct bio *xbh = bio->bi_next;
		int nr_sectors = bio_sectors(bio);

		bio->bi_next = NULL;
		bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
		bio = xbh;
	}
}

1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
static void cciss_check_queues(ctlr_info_t *h)
{
	int start_queue = h->next_to_run;
	int i;

	/* check to see if we have maxed out the number of commands that can
	 * be placed on the queue.  If so then exit.  We do this check here
	 * in case the interrupt we serviced was from an ioctl and did not
	 * free any new commands.
	 */
1212
	if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
		return;

	/* We have room on the queue for more commands.  Now we need to queue
	 * them up.  We will also keep track of the next queue to run so
	 * that every queue gets a chance to be started first.
	 */
	for (i = 0; i < h->highest_lun + 1; i++) {
		int curr_queue = (start_queue + i) % (h->highest_lun + 1);
		/* make sure the disk has been added and the drive is real
		 * because this can be called from the middle of init_one.
		 */
		if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
			continue;
		blk_start_queue(h->gendisk[curr_queue]->queue);

		/* check to see if we have maxed out the number of commands
		 * that can be placed on the queue.
		 */
1231
		if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
			if (curr_queue == start_queue) {
				h->next_to_run =
				    (start_queue + 1) % (h->highest_lun + 1);
				break;
			} else {
				h->next_to_run = curr_queue;
				break;
			}
		} else {
			curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
		}
	}
}

1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
static void cciss_softirq_done(struct request *rq)
{
	CommandList_struct *cmd = rq->completion_data;
	ctlr_info_t *h = hba[cmd->ctlr];
	unsigned long flags;
	u64bit temp64;
	int i, ddir;

	if (cmd->Request.Type.Direction == XFER_READ)
		ddir = PCI_DMA_FROMDEVICE;
	else
		ddir = PCI_DMA_TODEVICE;

	/* command did not need to be retried */
	/* unmap the DMA mapping for all the scatter gather elements */
1261
	for (i = 0; i < cmd->Header.SGList; i++) {
1262 1263 1264 1265 1266
		temp64.val32.lower = cmd->SG[i].Addr.lower;
		temp64.val32.upper = cmd->SG[i].Addr.upper;
		pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
	}

1267
	complete_buffers(rq->bio, (rq->errors == 0));
1268

J
Jens Axboe 已提交
1269 1270 1271 1272 1273 1274
	if (blk_fs_request(rq)) {
		const int rw = rq_data_dir(rq);

		disk_stat_add(rq->rq_disk, sectors[rw], rq->nr_sectors);
	}

1275 1276
#ifdef CCISS_DEBUG
	printk("Done with %p\n", rq);
1277
#endif				/* CCISS_DEBUG */
1278

1279
	add_disk_randomness(rq->rq_disk);
1280
	spin_lock_irqsave(&h->lock, flags);
1281
	end_that_request_last(rq, (rq->errors == 0));
1282
	cmd_free(h, cmd, 1);
1283
	cciss_check_queues(h);
1284 1285 1286
	spin_unlock_irqrestore(&h->lock, flags);
}

1287 1288 1289 1290 1291 1292 1293
/* This function will check the usage_count of the drive to be updated/added.
 * If the usage_count is zero then the drive information will be updated and
 * the disk will be re-registered with the kernel.  If not then it will be
 * left alone for the next reboot.  The exception to this is disk 0 which
 * will always be left registered with the kernel since it is also the
 * controller node.  Any changes to disk 0 will show up on the next
 * reboot.
1294
 */
1295
static void cciss_update_drive_info(int ctlr, int drv_index)
1296
{
1297 1298 1299 1300
	ctlr_info_t *h = hba[ctlr];
	struct gendisk *disk;
	InquiryData_struct *inq_buff = NULL;
	unsigned int block_size;
1301
	sector_t total_size;
1302 1303 1304
	unsigned long flags = 0;
	int ret = 0;

1305 1306
	/* if the disk already exists then deregister it before proceeding */
	if (h->drv[drv_index].raid_level != -1) {
1307 1308 1309 1310
		spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
		h->drv[drv_index].busy_configuring = 1;
		spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
		ret = deregister_disk(h->gendisk[drv_index],
1311
				      &h->drv[drv_index], 0);
1312 1313 1314 1315 1316 1317 1318
		h->drv[drv_index].busy_configuring = 0;
	}

	/* If the disk is in use return */
	if (ret)
		return;

1319
	/* Get information about the disk and modify the driver structure */
1320
	inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1321 1322 1323
	if (inq_buff == NULL)
		goto mem_msg;

1324 1325 1326 1327 1328 1329 1330
 	/* testing to see if 16-byte CDBs are already being used */
 	if (h->cciss_read == CCISS_READ_16) {
 		cciss_read_capacity_16(h->ctlr, drv_index, 1,
 			&total_size, &block_size);
 		goto geo_inq;
 	}

1331
	cciss_read_capacity(ctlr, drv_index, 1,
1332
			    &total_size, &block_size);
1333

1334 1335 1336
  	/* if read_capacity returns all F's this volume is >2TB in size */
  	/* so we switch to 16-byte CDB's for all read/write ops */
  	if (total_size == 0xFFFFFFFFULL) {
1337 1338 1339 1340 1341 1342 1343 1344
		cciss_read_capacity_16(ctlr, drv_index, 1,
		&total_size, &block_size);
		h->cciss_read = CCISS_READ_16;
		h->cciss_write = CCISS_WRITE_16;
	} else {
		h->cciss_read = CCISS_READ_10;
		h->cciss_write = CCISS_WRITE_10;
	}
1345
geo_inq:
1346
	cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1347
			       inq_buff, &h->drv[drv_index]);
1348 1349 1350 1351 1352 1353

	++h->num_luns;
	disk = h->gendisk[drv_index];
	set_capacity(disk, h->drv[drv_index].nr_blocks);

	/* if it's the controller it's already added */
1354
	if (drv_index) {
1355
		disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1356 1357 1358 1359 1360
		sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
		disk->major = h->major;
		disk->first_minor = drv_index << NWD_SHIFT;
		disk->fops = &cciss_fops;
		disk->private_data = &h->drv[drv_index];
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371

		/* Set up queue information */
		disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
		blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);

		/* This is a hardware imposed limit. */
		blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);

		/* This is a limit in the driver and could be eliminated. */
		blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);

1372
		blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1373

1374 1375
		blk_queue_softirq_done(disk->queue, cciss_softirq_done);

1376 1377 1378
		disk->queue->queuedata = hba[ctlr];

		blk_queue_hardsect_size(disk->queue,
1379
					hba[ctlr]->drv[drv_index].block_size);
1380 1381 1382 1383 1384

		h->drv[drv_index].queue = disk->queue;
		add_disk(disk);
	}

1385
      freeret:
1386 1387
	kfree(inq_buff);
	return;
1388
      mem_msg:
1389 1390 1391 1392 1393 1394 1395 1396 1397
	printk(KERN_ERR "cciss: out of memory\n");
	goto freeret;
}

/* This function will find the first index of the controllers drive array
 * that has a -1 for the raid_level and will return that index.  This is
 * where new drives will be added.  If the index to be returned is greater
 * than the highest_lun index for the controller then highest_lun is set
 * to this new index.  If there are no available indexes then -1 is returned.
1398
 */
1399 1400 1401 1402
static int cciss_find_free_drive_index(int ctlr)
{
	int i;

1403 1404
	for (i = 0; i < CISS_MAX_LUN; i++) {
		if (hba[ctlr]->drv[i].raid_level == -1) {
1405 1406 1407 1408 1409 1410 1411 1412 1413
			if (i > hba[ctlr]->highest_lun)
				hba[ctlr]->highest_lun = i;
			return i;
		}
	}
	return -1;
}

/* This function will add and remove logical drives from the Logical
1414
 * drive array of the controller and maintain persistency of ordering
1415 1416 1417 1418 1419 1420 1421
 * so that mount points are preserved until the next reboot.  This allows
 * for the removal of logical drives in the middle of the drive array
 * without a re-ordering of those drives.
 * INPUT
 * h		= The controller to perform the operations on
 * del_disk	= The disk to remove if specified.  If the value given
 *		  is NULL then no disk is removed.
1422
 */
1423
static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
L
Linus Torvalds 已提交
1424
{
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
	int ctlr = h->ctlr;
	int num_luns;
	ReportLunData_struct *ld_buff = NULL;
	drive_info_struct *drv = NULL;
	int return_code;
	int listlength = 0;
	int i;
	int drv_found;
	int drv_index = 0;
	__u32 lunid = 0;
L
Linus Torvalds 已提交
1435
	unsigned long flags;
1436 1437 1438

	/* Set busy_configuring flag for this operation */
	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1439
	if (h->busy_configuring) {
1440 1441 1442 1443 1444 1445 1446 1447 1448
		spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
		return -EBUSY;
	}
	h->busy_configuring = 1;

	/* if del_disk is NULL then we are being called to add a new disk
	 * and update the logical drive table.  If it is not NULL then
	 * we will check if the disk is in use or not.
	 */
1449
	if (del_disk != NULL) {
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
		drv = get_drv(del_disk);
		drv->busy_configuring = 1;
		spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
		return_code = deregister_disk(del_disk, drv, 1);
		drv->busy_configuring = 0;
		h->busy_configuring = 0;
		return return_code;
	} else {
		spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
		if (!capable(CAP_SYS_RAWIO))
			return -EPERM;

		ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
		if (ld_buff == NULL)
			goto mem_msg;

		return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1467 1468 1469 1470
					      sizeof(ReportLunData_struct), 0,
					      0, 0, TYPE_CMD);

		if (return_code == IO_OK) {
1471
			listlength =
A
Al Viro 已提交
1472
				be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
1473
		} else {	/* reading number of logical volumes failed */
1474
			printk(KERN_WARNING "cciss: report logical volume"
1475
			       " command failed\n");
1476 1477 1478 1479 1480
			listlength = 0;
			goto freeret;
		}

		num_luns = listlength / 8;	/* 8 bytes per entry */
1481
		if (num_luns > CISS_MAX_LUN) {
1482 1483
			num_luns = CISS_MAX_LUN;
			printk(KERN_WARNING "cciss: more luns configured"
1484 1485
			       " on controller than can be handled by"
			       " this driver.\n");
1486 1487 1488
		}

		/* Compare controller drive array to drivers drive array.
1489 1490 1491 1492
		 * Check for updates in the drive information and any new drives
		 * on the controller.
		 */
		for (i = 0; i < num_luns; i++) {
1493 1494 1495 1496
			int j;

			drv_found = 0;

1497 1498 1499 1500 1501 1502 1503
			lunid = (0xff &
				 (unsigned int)(ld_buff->LUN[i][3])) << 24;
			lunid |= (0xff &
				  (unsigned int)(ld_buff->LUN[i][2])) << 16;
			lunid |= (0xff &
				  (unsigned int)(ld_buff->LUN[i][1])) << 8;
			lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
1504 1505 1506 1507 1508

			/* Find if the LUN is already in the drive array
			 * of the controller.  If so then update its info
			 * if not is use.  If it does not exist then find
			 * the first free index and add it.
1509 1510 1511
			 */
			for (j = 0; j <= h->highest_lun; j++) {
				if (h->drv[j].LunID == lunid) {
1512 1513 1514 1515 1516 1517
					drv_index = j;
					drv_found = 1;
				}
			}

			/* check if the drive was found already in the array */
1518
			if (!drv_found) {
1519 1520 1521 1522
				drv_index = cciss_find_free_drive_index(ctlr);
				if (drv_index == -1)
					goto freeret;

1523 1524 1525 1526 1527 1528 1529 1530
				/*Check if the gendisk needs to be allocated */
				if (!h->gendisk[drv_index]){
					h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
					if (!h->gendisk[drv_index]){
						printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
						goto mem_msg;
					}
				}
1531 1532 1533
			}
			h->drv[drv_index].LunID = lunid;
			cciss_update_drive_info(ctlr, drv_index);
1534 1535
		}		/* end for */
	}			/* end else */
1536

1537
      freeret:
1538 1539 1540 1541 1542
	kfree(ld_buff);
	h->busy_configuring = 0;
	/* We return -1 here to tell the ACU that we have registered/updated
	 * all of the drives that we can and to keep it from calling us
	 * additional times.
1543
	 */
1544
	return -1;
1545
      mem_msg:
1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
	printk(KERN_ERR "cciss: out of memory\n");
	goto freeret;
}

/* This function will deregister the disk and it's queue from the
 * kernel.  It must be called with the controller lock held and the
 * drv structures busy_configuring flag set.  It's parameters are:
 *
 * disk = This is the disk to be deregistered
 * drv  = This is the drive_info_struct associated with the disk to be
 *        deregistered.  It contains information about the disk used
 *        by the driver.
 * clear_all = This flag determines whether or not the disk information
 *             is going to be completely cleared out and the highest_lun
 *             reset.  Sometimes we want to clear out information about
1561
 *             the disk in preparation for re-adding it.  In this case
1562 1563 1564 1565 1566 1567
 *             the highest_lun should be left unchanged and the LunID
 *             should not be cleared.
*/
static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
			   int clear_all)
{
1568
	int i;
L
Linus Torvalds 已提交
1569 1570 1571 1572 1573 1574
	ctlr_info_t *h = get_host(disk);

	if (!capable(CAP_SYS_RAWIO))
		return -EPERM;

	/* make sure logical volume is NOT is use */
1575 1576 1577 1578 1579
	if (clear_all || (h->gendisk[0] == disk)) {
		if (drv->usage_count > 1)
			return -EBUSY;
	} else if (drv->usage_count > 0)
		return -EBUSY;
L
Linus Torvalds 已提交
1580

1581 1582 1583
	/* invalidate the devices and deregister the disk.  If it is disk
	 * zero do not deregister it but just zero out it's values.  This
	 * allows us to delete disk zero but keep the controller registered.
1584 1585
	 */
	if (h->gendisk[0] != disk) {
1586 1587 1588 1589
		if (disk) {
			request_queue_t *q = disk->queue;
			if (disk->flags & GENHD_FL_UP)
				del_gendisk(disk);
1590
			if (q) {
1591
				blk_cleanup_queue(q);
1592 1593 1594 1595
				/* Set drv->queue to NULL so that we do not try
				 * to call blk_start_queue on this queue in the
				 * interrupt handler
				 */
1596 1597
				drv->queue = NULL;
			}
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
			/* If clear_all is set then we are deleting the logical
			 * drive, not just refreshing its info.  For drives
			 * other than disk 0 we will call put_disk.  We do not
			 * do this for disk 0 as we need it to be able to
			 * configure the controller.
			*/
			if (clear_all){
				/* This isn't pretty, but we need to find the
				 * disk in our array and NULL our the pointer.
				 * This is so that we will call alloc_disk if
				 * this index is used again later.
				*/
				for (i=0; i < CISS_MAX_LUN; i++){
					if(h->gendisk[i] == disk){
						h->gendisk[i] = NULL;
						break;
					}
				}
				put_disk(disk);
			}
1618
		}
1619 1620
	} else {
		set_capacity(disk, 0);
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	}

	--h->num_luns;
	/* zero out the disk size info */
	drv->nr_blocks = 0;
	drv->block_size = 0;
	drv->heads = 0;
	drv->sectors = 0;
	drv->cylinders = 0;
	drv->raid_level = -1;	/* This can be used as a flag variable to
				 * indicate that this element of the drive
				 * array is free.
1633 1634 1635 1636 1637 1638 1639 1640 1641
				 */

	if (clear_all) {
		/* check to see if it was the last disk */
		if (drv == h->drv + h->highest_lun) {
			/* if so, find the new hightest lun */
			int i, newhighest = -1;
			for (i = 0; i < h->highest_lun; i++) {
				/* if the disk has size > 0, it is available */
1642
				if (h->drv[i].heads)
1643 1644 1645
					newhighest = i;
			}
			h->highest_lun = newhighest;
L
Linus Torvalds 已提交
1646
		}
1647

1648
		drv->LunID = 0;
1649
	}
1650
	return 0;
L
Linus Torvalds 已提交
1651
}
1652

1653 1654 1655 1656 1657
static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,	/* 0: address the controller,
															   1: address logical volume log_unit,
															   2: periph device address is scsi3addr */
		    unsigned int log_unit, __u8 page_code,
		    unsigned char *scsi3addr, int cmd_type)
L
Linus Torvalds 已提交
1658
{
1659
	ctlr_info_t *h = hba[ctlr];
L
Linus Torvalds 已提交
1660 1661 1662 1663 1664
	u64bit buff_dma_handle;
	int status = IO_OK;

	c->cmd_type = CMD_IOCTL_PEND;
	c->Header.ReplyQueue = 0;
1665
	if (buff != NULL) {
L
Linus Torvalds 已提交
1666
		c->Header.SGList = 1;
1667
		c->Header.SGTotal = 1;
L
Linus Torvalds 已提交
1668 1669
	} else {
		c->Header.SGList = 0;
1670
		c->Header.SGTotal = 0;
L
Linus Torvalds 已提交
1671 1672 1673 1674 1675
	}
	c->Header.Tag.lower = c->busaddr;

	c->Request.Type.Type = cmd_type;
	if (cmd_type == TYPE_CMD) {
1676 1677
		switch (cmd) {
		case CISS_INQUIRY:
L
Linus Torvalds 已提交
1678
			/* If the logical unit number is 0 then, this is going
1679 1680 1681 1682 1683 1684
			   to controller so It's a physical command
			   mode = 0 target = 0.  So we have nothing to write.
			   otherwise, if use_unit_num == 1,
			   mode = 1(volume set addressing) target = LUNID
			   otherwise, if use_unit_num == 2,
			   mode = 0(periph dev addr) target = scsi3addr */
L
Linus Torvalds 已提交
1685
			if (use_unit_num == 1) {
1686 1687 1688
				c->Header.LUN.LogDev.VolId =
				    h->drv[log_unit].LunID;
				c->Header.LUN.LogDev.Mode = 1;
L
Linus Torvalds 已提交
1689
			} else if (use_unit_num == 2) {
1690 1691
				memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
				       8);
L
Linus Torvalds 已提交
1692 1693 1694
				c->Header.LUN.LogDev.Mode = 0;
			}
			/* are we trying to read a vital product page */
1695
			if (page_code != 0) {
L
Linus Torvalds 已提交
1696 1697 1698 1699
				c->Request.CDB[1] = 0x01;
				c->Request.CDB[2] = page_code;
			}
			c->Request.CDBLen = 6;
1700
			c->Request.Type.Attribute = ATTR_SIMPLE;
L
Linus Torvalds 已提交
1701 1702
			c->Request.Type.Direction = XFER_READ;
			c->Request.Timeout = 0;
1703 1704 1705
			c->Request.CDB[0] = CISS_INQUIRY;
			c->Request.CDB[4] = size & 0xFF;
			break;
L
Linus Torvalds 已提交
1706 1707
		case CISS_REPORT_LOG:
		case CISS_REPORT_PHYS:
1708
			/* Talking to controller so It's a physical command
L
Linus Torvalds 已提交
1709
			   mode = 00 target = 0.  Nothing to write.
1710
			 */
L
Linus Torvalds 已提交
1711 1712 1713 1714 1715
			c->Request.CDBLen = 12;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_READ;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = cmd;
1716
			c->Request.CDB[6] = (size >> 24) & 0xFF;	//MSB
L
Linus Torvalds 已提交
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
			c->Request.CDB[7] = (size >> 16) & 0xFF;
			c->Request.CDB[8] = (size >> 8) & 0xFF;
			c->Request.CDB[9] = size & 0xFF;
			break;

		case CCISS_READ_CAPACITY:
			c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
			c->Header.LUN.LogDev.Mode = 1;
			c->Request.CDBLen = 10;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_READ;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = cmd;
1730
			break;
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
		case CCISS_READ_CAPACITY_16:
			c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
			c->Header.LUN.LogDev.Mode = 1;
			c->Request.CDBLen = 16;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_READ;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = cmd;
			c->Request.CDB[1] = 0x10;
			c->Request.CDB[10] = (size >> 24) & 0xFF;
			c->Request.CDB[11] = (size >> 16) & 0xFF;
			c->Request.CDB[12] = (size >> 8) & 0xFF;
			c->Request.CDB[13] = size & 0xFF;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = cmd;
			break;
L
Linus Torvalds 已提交
1747 1748 1749 1750 1751 1752 1753
		case CCISS_CACHE_FLUSH:
			c->Request.CDBLen = 12;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_WRITE;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = BMIC_WRITE;
			c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1754
			break;
L
Linus Torvalds 已提交
1755 1756
		default:
			printk(KERN_WARNING
1757
			       "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
1758
			return IO_ERROR;
L
Linus Torvalds 已提交
1759 1760 1761
		}
	} else if (cmd_type == TYPE_MSG) {
		switch (cmd) {
1762
		case 0:	/* ABORT message */
1763 1764 1765 1766
			c->Request.CDBLen = 12;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_WRITE;
			c->Request.Timeout = 0;
1767 1768
			c->Request.CDB[0] = cmd;	/* abort */
			c->Request.CDB[1] = 0;	/* abort a command */
1769 1770 1771
			/* buff contains the tag of the command to abort */
			memcpy(&c->Request.CDB[4], buff, 8);
			break;
1772
		case 1:	/* RESET message */
1773 1774 1775 1776 1777
			c->Request.CDBLen = 12;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_WRITE;
			c->Request.Timeout = 0;
			memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1778 1779
			c->Request.CDB[0] = cmd;	/* reset */
			c->Request.CDB[1] = 0x04;	/* reset a LUN */
1780
			break;
L
Linus Torvalds 已提交
1781 1782 1783 1784 1785 1786 1787 1788 1789
		case 3:	/* No-Op message */
			c->Request.CDBLen = 1;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_WRITE;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = cmd;
			break;
		default:
			printk(KERN_WARNING
1790
			       "cciss%d: unknown message type %d\n", ctlr, cmd);
L
Linus Torvalds 已提交
1791 1792 1793 1794
			return IO_ERROR;
		}
	} else {
		printk(KERN_WARNING
1795
		       "cciss%d: unknown command type %d\n", ctlr, cmd_type);
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800
		return IO_ERROR;
	}
	/* Fill in the scatter gather information */
	if (size > 0) {
		buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1801 1802
							     buff, size,
							     PCI_DMA_BIDIRECTIONAL);
L
Linus Torvalds 已提交
1803 1804 1805
		c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
		c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
		c->SG[0].Len = size;
1806
		c->SG[0].Ext = 0;	/* we are not chaining */
L
Linus Torvalds 已提交
1807 1808 1809
	}
	return status;
}
1810 1811 1812 1813 1814 1815 1816

static int sendcmd_withirq(__u8 cmd,
			   int ctlr,
			   void *buff,
			   size_t size,
			   unsigned int use_unit_num,
			   unsigned int log_unit, __u8 page_code, int cmd_type)
L
Linus Torvalds 已提交
1817 1818 1819
{
	ctlr_info_t *h = hba[ctlr];
	CommandList_struct *c;
1820
	u64bit buff_dma_handle;
L
Linus Torvalds 已提交
1821 1822
	unsigned long flags;
	int return_status;
1823
	DECLARE_COMPLETION_ONSTACK(wait);
1824 1825

	if ((c = cmd_alloc(h, 0)) == NULL)
L
Linus Torvalds 已提交
1826 1827
		return -ENOMEM;
	return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1828
				 log_unit, page_code, NULL, cmd_type);
L
Linus Torvalds 已提交
1829 1830 1831 1832
	if (return_status != IO_OK) {
		cmd_free(h, c, 0);
		return return_status;
	}
1833
      resend_cmd2:
L
Linus Torvalds 已提交
1834
	c->waiting = &wait;
1835

L
Linus Torvalds 已提交
1836 1837 1838 1839 1840 1841
	/* Put the request on the tail of the queue and send it */
	spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
	addQ(&h->reqQ, c);
	h->Qdepth++;
	start_io(h);
	spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1842

L
Linus Torvalds 已提交
1843 1844
	wait_for_completion(&wait);

1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
	if (c->err_info->CommandStatus != 0) {	/* an error has occurred */
		switch (c->err_info->CommandStatus) {
		case CMD_TARGET_STATUS:
			printk(KERN_WARNING "cciss: cmd %p has "
			       " completed with errors\n", c);
			if (c->err_info->ScsiStatus) {
				printk(KERN_WARNING "cciss: cmd %p "
				       "has SCSI Status = %x\n",
				       c, c->err_info->ScsiStatus);
			}
L
Linus Torvalds 已提交
1855 1856

			break;
1857 1858
		case CMD_DATA_UNDERRUN:
		case CMD_DATA_OVERRUN:
L
Linus Torvalds 已提交
1859 1860
			/* expected for inquire and report lun commands */
			break;
1861 1862 1863 1864
		case CMD_INVALID:
			printk(KERN_WARNING "cciss: Cmd %p is "
			       "reported invalid\n", c);
			return_status = IO_ERROR;
L
Linus Torvalds 已提交
1865
			break;
1866 1867 1868 1869
		case CMD_PROTOCOL_ERR:
			printk(KERN_WARNING "cciss: cmd %p has "
			       "protocol error \n", c);
			return_status = IO_ERROR;
L
Linus Torvalds 已提交
1870
			break;
1871 1872 1873 1874
		case CMD_HARDWARE_ERR:
			printk(KERN_WARNING "cciss: cmd %p had "
			       " hardware error\n", c);
			return_status = IO_ERROR;
L
Linus Torvalds 已提交
1875
			break;
1876 1877 1878 1879
		case CMD_CONNECTION_LOST:
			printk(KERN_WARNING "cciss: cmd %p had "
			       "connection lost\n", c);
			return_status = IO_ERROR;
L
Linus Torvalds 已提交
1880
			break;
1881 1882 1883 1884
		case CMD_ABORTED:
			printk(KERN_WARNING "cciss: cmd %p was "
			       "aborted\n", c);
			return_status = IO_ERROR;
L
Linus Torvalds 已提交
1885
			break;
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
		case CMD_ABORT_FAILED:
			printk(KERN_WARNING "cciss: cmd %p reports "
			       "abort failed\n", c);
			return_status = IO_ERROR;
			break;
		case CMD_UNSOLICITED_ABORT:
			printk(KERN_WARNING
			       "cciss%d: unsolicited abort %p\n", ctlr, c);
			if (c->retry_count < MAX_CMD_RETRIES) {
				printk(KERN_WARNING
				       "cciss%d: retrying %p\n", ctlr, c);
				c->retry_count++;
				/* erase the old error information */
				memset(c->err_info, 0,
				       sizeof(ErrorInfo_struct));
				return_status = IO_OK;
				INIT_COMPLETION(wait);
				goto resend_cmd2;
			}
			return_status = IO_ERROR;
			break;
		default:
			printk(KERN_WARNING "cciss: cmd %p returned "
			       "unknown status %x\n", c,
			       c->err_info->CommandStatus);
			return_status = IO_ERROR;
L
Linus Torvalds 已提交
1912
		}
1913
	}
L
Linus Torvalds 已提交
1914
	/* unlock the buffers from DMA */
1915 1916
	buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
	buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1917 1918
	pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
			 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
L
Linus Torvalds 已提交
1919
	cmd_free(h, c, 0);
1920
	return return_status;
L
Linus Torvalds 已提交
1921
}
1922

L
Linus Torvalds 已提交
1923
static void cciss_geometry_inquiry(int ctlr, int logvol,
1924
				   int withirq, sector_t total_size,
1925 1926 1927
				   unsigned int block_size,
				   InquiryData_struct *inq_buff,
				   drive_info_struct *drv)
L
Linus Torvalds 已提交
1928 1929
{
	int return_code;
1930 1931
	unsigned long t;

L
Linus Torvalds 已提交
1932 1933 1934
	memset(inq_buff, 0, sizeof(InquiryData_struct));
	if (withirq)
		return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1935 1936
					      inq_buff, sizeof(*inq_buff), 1,
					      logvol, 0xC1, TYPE_CMD);
L
Linus Torvalds 已提交
1937 1938
	else
		return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1939 1940
				      sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
				      TYPE_CMD);
L
Linus Torvalds 已提交
1941
	if (return_code == IO_OK) {
1942
		if (inq_buff->data_byte[8] == 0xFF) {
L
Linus Torvalds 已提交
1943
			printk(KERN_WARNING
1944 1945
			       "cciss: reading geometry failed, volume "
			       "does not support reading geometry\n");
L
Linus Torvalds 已提交
1946
			drv->heads = 255;
1947
			drv->sectors = 32;	// Sectors per track
1948
			drv->cylinders = total_size + 1;
1949
			drv->raid_level = RAID_UNKNOWN;
L
Linus Torvalds 已提交
1950 1951 1952 1953 1954 1955
		} else {
			drv->heads = inq_buff->data_byte[6];
			drv->sectors = inq_buff->data_byte[7];
			drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
			drv->cylinders += inq_buff->data_byte[5];
			drv->raid_level = inq_buff->data_byte[8];
1956 1957
		}
		drv->block_size = block_size;
1958
		drv->nr_blocks = total_size + 1;
1959 1960
		t = drv->heads * drv->sectors;
		if (t > 1) {
1961 1962
			sector_t real_size = total_size + 1;
			unsigned long rem = sector_div(real_size, t);
1963
			if (rem)
1964 1965
				real_size++;
			drv->cylinders = real_size;
L
Linus Torvalds 已提交
1966
		}
1967
	} else {		/* Get geometry failed */
L
Linus Torvalds 已提交
1968 1969
		printk(KERN_WARNING "cciss: reading geometry failed\n");
	}
1970
	printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
1971
	       drv->heads, drv->sectors, drv->cylinders);
L
Linus Torvalds 已提交
1972
}
1973

L
Linus Torvalds 已提交
1974
static void
1975
cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
1976
		    unsigned int *block_size)
L
Linus Torvalds 已提交
1977
{
1978
	ReadCapdata_struct *buf;
L
Linus Torvalds 已提交
1979
	int return_code;
1980 1981 1982 1983 1984 1985
	buf = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
	if (buf == NULL) {
		printk(KERN_WARNING "cciss: out of memory\n");
		return;
	}
	memset(buf, 0, sizeof(ReadCapdata_struct));
L
Linus Torvalds 已提交
1986 1987
	if (withirq)
		return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1988 1989
				ctlr, buf, sizeof(ReadCapdata_struct),
					1, logvol, 0, TYPE_CMD);
L
Linus Torvalds 已提交
1990 1991
	else
		return_code = sendcmd(CCISS_READ_CAPACITY,
1992 1993
				ctlr, buf, sizeof(ReadCapdata_struct),
					1, logvol, 0, NULL, TYPE_CMD);
L
Linus Torvalds 已提交
1994
	if (return_code == IO_OK) {
A
Al Viro 已提交
1995 1996
		*total_size = be32_to_cpu(*(__be32 *) buf->total_size);
		*block_size = be32_to_cpu(*(__be32 *) buf->block_size);
1997
	} else {		/* read capacity command failed */
L
Linus Torvalds 已提交
1998 1999 2000 2001
		printk(KERN_WARNING "cciss: read capacity failed\n");
		*total_size = 0;
		*block_size = BLOCK_SIZE;
	}
2002
	if (*total_size != 0)
2003
		printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2004
		(unsigned long long)*total_size+1, *block_size);
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
	kfree(buf);
	return;
}

static void
cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, 				unsigned int *block_size)
{
	ReadCapdata_struct_16 *buf;
	int return_code;
	buf = kmalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
	if (buf == NULL) {
		printk(KERN_WARNING "cciss: out of memory\n");
		return;
	}
	memset(buf, 0, sizeof(ReadCapdata_struct_16));
	if (withirq) {
		return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
			ctlr, buf, sizeof(ReadCapdata_struct_16),
				1, logvol, 0, TYPE_CMD);
	}
	else {
		return_code = sendcmd(CCISS_READ_CAPACITY_16,
			ctlr, buf, sizeof(ReadCapdata_struct_16),
				1, logvol, 0, NULL, TYPE_CMD);
	}
	if (return_code == IO_OK) {
A
Al Viro 已提交
2031 2032
		*total_size = be64_to_cpu(*(__be64 *) buf->total_size);
		*block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2033 2034 2035 2036 2037
	} else {		/* read capacity command failed */
		printk(KERN_WARNING "cciss: read capacity failed\n");
		*total_size = 0;
		*block_size = BLOCK_SIZE;
	}
2038
	printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2039
	       (unsigned long long)*total_size+1, *block_size);
2040
	kfree(buf);
L
Linus Torvalds 已提交
2041 2042 2043 2044 2045 2046 2047 2048
	return;
}

static int cciss_revalidate(struct gendisk *disk)
{
	ctlr_info_t *h = get_host(disk);
	drive_info_struct *drv = get_drv(disk);
	int logvol;
2049
	int FOUND = 0;
L
Linus Torvalds 已提交
2050
	unsigned int block_size;
2051
	sector_t total_size;
L
Linus Torvalds 已提交
2052 2053
	InquiryData_struct *inq_buff = NULL;

2054 2055 2056
	for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
		if (h->drv[logvol].LunID == drv->LunID) {
			FOUND = 1;
L
Linus Torvalds 已提交
2057 2058 2059 2060
			break;
		}
	}

2061 2062
	if (!FOUND)
		return 1;
L
Linus Torvalds 已提交
2063

2064 2065 2066 2067 2068
	inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
	if (inq_buff == NULL) {
		printk(KERN_WARNING "cciss: out of memory\n");
		return 1;
	}
2069 2070 2071 2072 2073 2074 2075
	if (h->cciss_read == CCISS_READ_10) {
		cciss_read_capacity(h->ctlr, logvol, 1,
					&total_size, &block_size);
	} else {
		cciss_read_capacity_16(h->ctlr, logvol, 1,
					&total_size, &block_size);
	}
2076 2077
	cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
			       inq_buff, drv);
L
Linus Torvalds 已提交
2078

M
Mike Miller 已提交
2079
	blk_queue_hardsect_size(drv->queue, drv->block_size);
L
Linus Torvalds 已提交
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
	set_capacity(disk, drv->nr_blocks);

	kfree(inq_buff);
	return 0;
}

/*
 *   Wait polling for a command to complete.
 *   The memory mapped FIFO is polled for the completion.
 *   Used only at init time, interrupts from the HBA are disabled.
 */
static unsigned long pollcomplete(int ctlr)
{
	unsigned long done;
	int i;

	/* Wait (up to 20 seconds) for a command to complete */

	for (i = 20 * HZ; i > 0; i--) {
		done = hba[ctlr]->access.command_completed(hba[ctlr]);
2100 2101 2102
		if (done == FIFO_EMPTY)
			schedule_timeout_uninterruptible(1);
		else
2103
			return done;
L
Linus Torvalds 已提交
2104 2105 2106 2107
	}
	/* Invalid address to tell caller we ran out of time */
	return 1;
}
2108 2109 2110 2111

static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
{
	/* We get in here if sendcmd() is polling for completions
2112 2113 2114
	   and gets some command back that it wasn't expecting --
	   something other than that which it just sent down.
	   Ordinarily, that shouldn't happen, but it can happen when
2115
	   the scsi tape stuff gets into error handling mode, and
2116
	   starts using sendcmd() to try to abort commands and
2117 2118
	   reset tape drives.  In that case, sendcmd may pick up
	   completions of commands that were sent to logical drives
2119
	   through the block i/o system, or cciss ioctls completing, etc.
2120 2121
	   In that case, we need to save those completions for later
	   processing by the interrupt handler.
2122
	 */
2123 2124

#ifdef CONFIG_CISS_SCSI_TAPE
2125
	struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2126 2127 2128 2129 2130

	/* If it's not the scsi tape stuff doing error handling, (abort */
	/* or reset) then we don't expect anything weird. */
	if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
#endif
2131 2132 2133
		printk(KERN_WARNING "cciss cciss%d: SendCmd "
		       "Invalid command list address returned! (%lx)\n",
		       ctlr, complete);
2134 2135 2136 2137 2138 2139 2140
		/* not much we can do. */
#ifdef CONFIG_CISS_SCSI_TAPE
		return 1;
	}

	/* We've sent down an abort or reset, but something else
	   has completed */
2141
	if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2142 2143
		/* Uh oh.  No room to save it for later... */
		printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2144
		       "reject list overflow, command lost!\n", ctlr);
2145 2146 2147 2148 2149 2150 2151 2152 2153
		return 1;
	}
	/* Save it for later */
	srl->complete[srl->ncompletions] = complete;
	srl->ncompletions++;
#endif
	return 0;
}

L
Linus Torvalds 已提交
2154
/*
2155 2156
 * Send a command to the controller, and wait for it to complete.
 * Only used at init time.
L
Linus Torvalds 已提交
2157
 */
2158 2159 2160 2161 2162
static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,	/* 0: address the controller,
												   1: address logical volume log_unit,
												   2: periph device address is scsi3addr */
		   unsigned int log_unit,
		   __u8 page_code, unsigned char *scsi3addr, int cmd_type)
L
Linus Torvalds 已提交
2163 2164 2165 2166
{
	CommandList_struct *c;
	int i;
	unsigned long complete;
2167
	ctlr_info_t *info_p = hba[ctlr];
L
Linus Torvalds 已提交
2168
	u64bit buff_dma_handle;
2169
	int status, done = 0;
L
Linus Torvalds 已提交
2170 2171 2172

	if ((c = cmd_alloc(info_p, 1)) == NULL) {
		printk(KERN_WARNING "cciss: unable to get memory");
2173
		return IO_ERROR;
L
Linus Torvalds 已提交
2174 2175
	}
	status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2176
			  log_unit, page_code, scsi3addr, cmd_type);
L
Linus Torvalds 已提交
2177 2178 2179 2180
	if (status != IO_OK) {
		cmd_free(info_p, c, 1);
		return status;
	}
2181
      resend_cmd1:
L
Linus Torvalds 已提交
2182
	/*
2183 2184
	 * Disable interrupt
	 */
L
Linus Torvalds 已提交
2185 2186
#ifdef CCISS_DEBUG
	printk(KERN_DEBUG "cciss: turning intr off\n");
2187 2188 2189
#endif				/* CCISS_DEBUG */
	info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);

L
Linus Torvalds 已提交
2190
	/* Make sure there is room in the command FIFO */
2191
	/* Actually it should be completely empty at this time */
2192 2193
	/* unless we are in here doing error handling for the scsi */
	/* tape side of the driver. */
2194
	for (i = 200000; i > 0; i--) {
L
Linus Torvalds 已提交
2195
		/* if fifo isn't full go */
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
		if (!(info_p->access.fifo_full(info_p))) {

			break;
		}
		udelay(10);
		printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
		       " waiting!\n", ctlr);
	}
	/*
	 * Send the cmd
	 */
	info_p->access.submit_command(info_p, c);
2208 2209 2210
	done = 0;
	do {
		complete = pollcomplete(ctlr);
L
Linus Torvalds 已提交
2211 2212

#ifdef CCISS_DEBUG
2213
		printk(KERN_DEBUG "cciss: command completed\n");
2214
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2215

2216
		if (complete == 1) {
2217 2218 2219
			printk(KERN_WARNING
			       "cciss cciss%d: SendCmd Timeout out, "
			       "No command list address returned!\n", ctlr);
2220 2221 2222 2223 2224 2225
			status = IO_ERROR;
			done = 1;
			break;
		}

		/* This will need to change for direct lookup completions */
2226 2227 2228 2229 2230
		if ((complete & CISS_ERROR_BIT)
		    && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
			/* if data overrun or underun on Report command
			   ignore it
			 */
L
Linus Torvalds 已提交
2231 2232 2233
			if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
			     (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
			     (c->Request.CDB[0] == CISS_INQUIRY)) &&
2234 2235 2236 2237
			    ((c->err_info->CommandStatus ==
			      CMD_DATA_OVERRUN) ||
			     (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
			    )) {
L
Linus Torvalds 已提交
2238 2239 2240
				complete = c->busaddr;
			} else {
				if (c->err_info->CommandStatus ==
2241
				    CMD_UNSOLICITED_ABORT) {
L
Linus Torvalds 已提交
2242
					printk(KERN_WARNING "cciss%d: "
2243 2244
					       "unsolicited abort %p\n",
					       ctlr, c);
L
Linus Torvalds 已提交
2245 2246
					if (c->retry_count < MAX_CMD_RETRIES) {
						printk(KERN_WARNING
2247 2248
						       "cciss%d: retrying %p\n",
						       ctlr, c);
L
Linus Torvalds 已提交
2249 2250 2251 2252
						c->retry_count++;
						/* erase the old error */
						/* information */
						memset(c->err_info, 0,
2253 2254
						       sizeof
						       (ErrorInfo_struct));
L
Linus Torvalds 已提交
2255 2256 2257
						goto resend_cmd1;
					} else {
						printk(KERN_WARNING
2258 2259
						       "cciss%d: retried %p too "
						       "many times\n", ctlr, c);
L
Linus Torvalds 已提交
2260 2261 2262
						status = IO_ERROR;
						goto cleanup1;
					}
2263 2264 2265 2266 2267
				} else if (c->err_info->CommandStatus ==
					   CMD_UNABORTABLE) {
					printk(KERN_WARNING
					       "cciss%d: command could not be aborted.\n",
					       ctlr);
2268 2269
					status = IO_ERROR;
					goto cleanup1;
L
Linus Torvalds 已提交
2270 2271
				}
				printk(KERN_WARNING "ciss ciss%d: sendcmd"
2272 2273
				       " Error %x \n", ctlr,
				       c->err_info->CommandStatus);
L
Linus Torvalds 已提交
2274
				printk(KERN_WARNING "ciss ciss%d: sendcmd"
2275 2276 2277 2278 2279 2280 2281 2282 2283
				       " offensive info\n"
				       "  size %x\n   num %x   value %x\n",
				       ctlr,
				       c->err_info->MoreErrInfo.Invalid_Cmd.
				       offense_size,
				       c->err_info->MoreErrInfo.Invalid_Cmd.
				       offense_num,
				       c->err_info->MoreErrInfo.Invalid_Cmd.
				       offense_value);
L
Linus Torvalds 已提交
2284 2285 2286 2287
				status = IO_ERROR;
				goto cleanup1;
			}
		}
2288
		/* This will need changing for direct lookup completions */
2289
		if (complete != c->busaddr) {
2290
			if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2291
				BUG();	/* we are pretty much hosed if we get here. */
2292 2293
			}
			continue;
2294
		} else
2295
			done = 1;
2296 2297 2298
	} while (!done);

      cleanup1:
L
Linus Torvalds 已提交
2299
	/* unlock the data buffer from DMA */
2300 2301
	buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
	buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
L
Linus Torvalds 已提交
2302
	pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2303
			 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2304 2305 2306
#ifdef CONFIG_CISS_SCSI_TAPE
	/* if we saved some commands for later, process them now. */
	if (info_p->scsi_rejects.ncompletions > 0)
2307
		do_cciss_intr(0, info_p);
2308
#endif
L
Linus Torvalds 已提交
2309
	cmd_free(info_p, c, 1);
2310
	return status;
2311 2312
}

L
Linus Torvalds 已提交
2313 2314 2315 2316 2317
/*
 * Map (physical) PCI mem into (virtual) kernel space
 */
static void __iomem *remap_pci_mem(ulong base, ulong size)
{
2318 2319 2320
	ulong page_base = ((ulong) base) & PAGE_MASK;
	ulong page_offs = ((ulong) base) - page_base;
	void __iomem *page_remapped = ioremap(page_base, page_offs + size);
L
Linus Torvalds 已提交
2321

2322
	return page_remapped ? (page_remapped + page_offs) : NULL;
L
Linus Torvalds 已提交
2323 2324
}

2325 2326 2327 2328 2329
/*
 * Takes jobs of the Q and sends them to the hardware, then puts it on
 * the Q to wait for completion.
 */
static void start_io(ctlr_info_t *h)
L
Linus Torvalds 已提交
2330 2331
{
	CommandList_struct *c;
2332 2333

	while ((c = h->reqQ) != NULL) {
L
Linus Torvalds 已提交
2334 2335 2336 2337 2338 2339
		/* can't do anything if fifo is full */
		if ((h->access.fifo_full(h))) {
			printk(KERN_WARNING "cciss: fifo full\n");
			break;
		}

2340
		/* Get the first entry from the Request Q */
L
Linus Torvalds 已提交
2341 2342
		removeQ(&(h->reqQ), c);
		h->Qdepth--;
2343 2344

		/* Tell the controller execute command */
L
Linus Torvalds 已提交
2345
		h->access.submit_command(h, c);
2346 2347 2348

		/* Put job onto the completed Q */
		addQ(&(h->cmpQ), c);
L
Linus Torvalds 已提交
2349 2350
	}
}
2351

L
Linus Torvalds 已提交
2352 2353 2354
/* Assumes that CCISS_LOCK(h->ctlr) is held. */
/* Zeros out the error record and then resends the command back */
/* to the controller */
2355
static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
L
Linus Torvalds 已提交
2356 2357 2358 2359 2360
{
	/* erase the old error information */
	memset(c->err_info, 0, sizeof(ErrorInfo_struct));

	/* add it to software queue and then send it to the controller */
2361
	addQ(&(h->reqQ), c);
L
Linus Torvalds 已提交
2362
	h->Qdepth++;
2363
	if (h->Qdepth > h->maxQsinceinit)
L
Linus Torvalds 已提交
2364 2365 2366 2367
		h->maxQsinceinit = h->Qdepth;

	start_io(h);
}
2368

2369 2370 2371
static inline int evaluate_target_status(CommandList_struct *cmd)
{
	unsigned char sense_key;
2372
	int error_count = 1;
2373 2374 2375 2376 2377 2378

	if (cmd->err_info->ScsiStatus != 0x02) { /* not check condition? */
		if (!blk_pc_request(cmd->rq))
			printk(KERN_WARNING "cciss: cmd %p "
			       "has SCSI Status 0x%x\n",
			       cmd, cmd->err_info->ScsiStatus);
2379
		return error_count;
2380 2381 2382 2383 2384 2385
	}

	/* check the sense key */
	sense_key = 0xf & cmd->err_info->SenseInfo[2];
	/* no status or recovered error */
	if ((sense_key == 0x0) || (sense_key == 0x1))
2386
		error_count = 0;
2387 2388

	if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
2389
		if (error_count != 0)
2390 2391
			printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
			       " sense key = 0x%x\n", cmd, sense_key);
2392
		return error_count;
2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
	}

	/* SG_IO or similar, copy sense data back */
	if (cmd->rq->sense) {
		if (cmd->rq->sense_len > cmd->err_info->SenseLen)
			cmd->rq->sense_len = cmd->err_info->SenseLen;
		memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
			cmd->rq->sense_len);
	} else
		cmd->rq->sense_len = 0;

2404
	return error_count;
2405 2406
}

2407
/* checks the status of the job and calls complete buffers to mark all
2408 2409
 * buffers for the completed job. Note that this function does not need
 * to hold the hba/queue lock.
2410 2411 2412
 */
static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
				    int timeout)
L
Linus Torvalds 已提交
2413 2414
{
	int retry_cmd = 0;
2415 2416 2417
	struct request *rq = cmd->rq;

	rq->errors = 0;
2418

L
Linus Torvalds 已提交
2419
	if (timeout)
2420
		rq->errors = 1;
L
Linus Torvalds 已提交
2421

2422 2423
	if (cmd->err_info->CommandStatus == 0)	/* no error has occurred */
		goto after_error_processing;
2424

2425 2426
	switch (cmd->err_info->CommandStatus) {
	case CMD_TARGET_STATUS:
2427
		rq->errors = evaluate_target_status(cmd);
2428 2429
		break;
	case CMD_DATA_UNDERRUN:
2430 2431 2432 2433 2434 2435
		if (blk_fs_request(cmd->rq)) {
			printk(KERN_WARNING "cciss: cmd %p has"
			       " completed with data underrun "
			       "reported\n", cmd);
			cmd->rq->data_len = cmd->err_info->ResidualCnt;
		}
2436 2437
		break;
	case CMD_DATA_OVERRUN:
2438 2439 2440 2441
		if (blk_fs_request(cmd->rq))
			printk(KERN_WARNING "cciss: cmd %p has"
			       " completed with data overrun "
			       "reported\n", cmd);
2442 2443 2444 2445
		break;
	case CMD_INVALID:
		printk(KERN_WARNING "cciss: cmd %p is "
		       "reported invalid\n", cmd);
2446
		rq->errors = 1;
2447 2448 2449 2450
		break;
	case CMD_PROTOCOL_ERR:
		printk(KERN_WARNING "cciss: cmd %p has "
		       "protocol error \n", cmd);
2451
		rq->errors = 1;
2452 2453 2454 2455
		break;
	case CMD_HARDWARE_ERR:
		printk(KERN_WARNING "cciss: cmd %p had "
		       " hardware error\n", cmd);
2456
		rq->errors = 1;
2457 2458 2459 2460
		break;
	case CMD_CONNECTION_LOST:
		printk(KERN_WARNING "cciss: cmd %p had "
		       "connection lost\n", cmd);
2461
		rq->errors = 1;
2462 2463 2464 2465
		break;
	case CMD_ABORTED:
		printk(KERN_WARNING "cciss: cmd %p was "
		       "aborted\n", cmd);
2466
		rq->errors = 1;
2467 2468 2469 2470
		break;
	case CMD_ABORT_FAILED:
		printk(KERN_WARNING "cciss: cmd %p reports "
		       "abort failed\n", cmd);
2471
		rq->errors = 1;
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484
		break;
	case CMD_UNSOLICITED_ABORT:
		printk(KERN_WARNING "cciss%d: unsolicited "
		       "abort %p\n", h->ctlr, cmd);
		if (cmd->retry_count < MAX_CMD_RETRIES) {
			retry_cmd = 1;
			printk(KERN_WARNING
			       "cciss%d: retrying %p\n", h->ctlr, cmd);
			cmd->retry_count++;
		} else
			printk(KERN_WARNING
			       "cciss%d: %p retried too "
			       "many times\n", h->ctlr, cmd);
2485
		rq->errors = 1;
2486 2487 2488
		break;
	case CMD_TIMEOUT:
		printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2489
		rq->errors = 1;
2490 2491 2492 2493 2494
		break;
	default:
		printk(KERN_WARNING "cciss: cmd %p returned "
		       "unknown status %x\n", cmd,
		       cmd->err_info->CommandStatus);
2495
		rq->errors = 1;
L
Linus Torvalds 已提交
2496
	}
2497 2498 2499

after_error_processing:

L
Linus Torvalds 已提交
2500
	/* We need to return this command */
2501 2502
	if (retry_cmd) {
		resend_cciss_cmd(h, cmd);
L
Linus Torvalds 已提交
2503
		return;
2504
	}
2505 2506
	cmd->rq->data_len = 0;
	cmd->rq->completion_data = cmd;
2507
	blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
2508
	blk_complete_request(cmd->rq);
L
Linus Torvalds 已提交
2509 2510
}

2511 2512
/*
 * Get a request and submit it to the controller.
L
Linus Torvalds 已提交
2513 2514 2515
 */
static void do_cciss_request(request_queue_t *q)
{
2516
	ctlr_info_t *h = q->queuedata;
L
Linus Torvalds 已提交
2517
	CommandList_struct *c;
2518 2519
	sector_t start_blk;
	int seg;
L
Linus Torvalds 已提交
2520 2521 2522 2523 2524 2525 2526 2527
	struct request *creq;
	u64bit temp64;
	struct scatterlist tmp_sg[MAXSGENTRIES];
	drive_info_struct *drv;
	int i, dir;

	/* We call start_io here in case there is a command waiting on the
	 * queue that has not been sent.
2528
	 */
L
Linus Torvalds 已提交
2529 2530 2531
	if (blk_queue_plugged(q))
		goto startio;

2532
      queue:
L
Linus Torvalds 已提交
2533 2534 2535 2536
	creq = elv_next_request(q);
	if (!creq)
		goto startio;

2537
	BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
L
Linus Torvalds 已提交
2538

2539
	if ((c = cmd_alloc(h, 1)) == NULL)
L
Linus Torvalds 已提交
2540 2541 2542 2543 2544 2545 2546 2547
		goto full;

	blkdev_dequeue_request(creq);

	spin_unlock_irq(q->queue_lock);

	c->cmd_type = CMD_RWREQ;
	c->rq = creq;
2548 2549

	/* fill in the request */
L
Linus Torvalds 已提交
2550
	drv = creq->rq_disk->private_data;
2551
	c->Header.ReplyQueue = 0;	// unused in simple mode
2552 2553 2554 2555
	/* got command from pool, so use the command block index instead */
	/* for direct lookups. */
	/* The first 2 bits are reserved for controller error reporting. */
	c->Header.Tag.lower = (c->cmdindex << 3);
2556 2557
	c->Header.Tag.lower |= 0x04;	/* flag for direct lookup. */
	c->Header.LUN.LogDev.VolId = drv->LunID;
L
Linus Torvalds 已提交
2558
	c->Header.LUN.LogDev.Mode = 1;
2559 2560 2561 2562
	c->Request.CDBLen = 10;	// 12 byte commands not in FW yet;
	c->Request.Type.Type = TYPE_CMD;	// It is a command.
	c->Request.Type.Attribute = ATTR_SIMPLE;
	c->Request.Type.Direction =
2563
	    (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
2564 2565
	c->Request.Timeout = 0;	// Don't time out
	c->Request.CDB[0] =
2566
	    (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
L
Linus Torvalds 已提交
2567 2568
	start_blk = creq->sector;
#ifdef CCISS_DEBUG
2569 2570 2571
	printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
	       (int)creq->nr_sectors);
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2572 2573 2574

	seg = blk_rq_map_sg(q, creq, tmp_sg);

2575
	/* get the DMA records for the setup */
L
Linus Torvalds 已提交
2576 2577 2578 2579 2580
	if (c->Request.Type.Direction == XFER_READ)
		dir = PCI_DMA_FROMDEVICE;
	else
		dir = PCI_DMA_TODEVICE;

2581
	for (i = 0; i < seg; i++) {
L
Linus Torvalds 已提交
2582 2583
		c->SG[i].Len = tmp_sg[i].length;
		temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2584 2585
						  tmp_sg[i].offset,
						  tmp_sg[i].length, dir);
L
Linus Torvalds 已提交
2586
		c->SG[i].Addr.lower = temp64.val32.lower;
2587 2588
		c->SG[i].Addr.upper = temp64.val32.upper;
		c->SG[i].Ext = 0;	// we are not chaining
L
Linus Torvalds 已提交
2589
	}
2590 2591 2592
	/* track how many SG entries we are using */
	if (seg > h->maxSG)
		h->maxSG = seg;
L
Linus Torvalds 已提交
2593 2594

#ifdef CCISS_DEBUG
2595 2596 2597
	printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
	       creq->nr_sectors, seg);
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2598 2599

	c->Header.SGList = c->Header.SGTotal = seg;
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630
	if (likely(blk_fs_request(creq))) {
		if(h->cciss_read == CCISS_READ_10) {
			c->Request.CDB[1] = 0;
			c->Request.CDB[2] = (start_blk >> 24) & 0xff;	//MSB
			c->Request.CDB[3] = (start_blk >> 16) & 0xff;
			c->Request.CDB[4] = (start_blk >> 8) & 0xff;
			c->Request.CDB[5] = start_blk & 0xff;
			c->Request.CDB[6] = 0;	// (sect >> 24) & 0xff; MSB
			c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
			c->Request.CDB[8] = creq->nr_sectors & 0xff;
			c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
		} else {
			c->Request.CDBLen = 16;
			c->Request.CDB[1]= 0;
			c->Request.CDB[2]= (start_blk >> 56) & 0xff;	//MSB
			c->Request.CDB[3]= (start_blk >> 48) & 0xff;
			c->Request.CDB[4]= (start_blk >> 40) & 0xff;
			c->Request.CDB[5]= (start_blk >> 32) & 0xff;
			c->Request.CDB[6]= (start_blk >> 24) & 0xff;
			c->Request.CDB[7]= (start_blk >> 16) & 0xff;
			c->Request.CDB[8]= (start_blk >>  8) & 0xff;
			c->Request.CDB[9]= start_blk & 0xff;
			c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
			c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
			c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
			c->Request.CDB[13]= creq->nr_sectors & 0xff;
			c->Request.CDB[14] = c->Request.CDB[15] = 0;
		}
	} else if (blk_pc_request(creq)) {
		c->Request.CDBLen = creq->cmd_len;
		memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
2631
	} else {
2632 2633
		printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
		BUG();
2634
	}
L
Linus Torvalds 已提交
2635 2636 2637

	spin_lock_irq(q->queue_lock);

2638
	addQ(&(h->reqQ), c);
L
Linus Torvalds 已提交
2639
	h->Qdepth++;
2640 2641
	if (h->Qdepth > h->maxQsinceinit)
		h->maxQsinceinit = h->Qdepth;
L
Linus Torvalds 已提交
2642 2643

	goto queue;
2644
full:
L
Linus Torvalds 已提交
2645
	blk_stop_queue(q);
2646
startio:
L
Linus Torvalds 已提交
2647 2648
	/* We will already have the driver lock here so not need
	 * to lock it.
2649
	 */
L
Linus Torvalds 已提交
2650 2651 2652
	start_io(h);
}

2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
static inline unsigned long get_next_completion(ctlr_info_t *h)
{
#ifdef CONFIG_CISS_SCSI_TAPE
	/* Any rejects from sendcmd() lying around? Process them first */
	if (h->scsi_rejects.ncompletions == 0)
		return h->access.command_completed(h);
	else {
		struct sendcmd_reject_list *srl;
		int n;
		srl = &h->scsi_rejects;
		n = --srl->ncompletions;
		/* printk("cciss%d: processing saved reject\n", h->ctlr); */
		printk("p");
		return srl->complete[n];
	}
#else
	return h->access.command_completed(h);
#endif
}

static inline int interrupt_pending(ctlr_info_t *h)
{
#ifdef CONFIG_CISS_SCSI_TAPE
2676
	return (h->access.intr_pending(h)
2677 2678 2679 2680 2681 2682 2683 2684 2685
		|| (h->scsi_rejects.ncompletions > 0));
#else
	return h->access.intr_pending(h);
#endif
}

static inline long interrupt_not_for_us(ctlr_info_t *h)
{
#ifdef CONFIG_CISS_SCSI_TAPE
2686 2687 2688
	return (((h->access.intr_pending(h) == 0) ||
		 (h->interrupts_enabled == 0))
		&& (h->scsi_rejects.ncompletions == 0));
2689
#else
2690
	return (((h->access.intr_pending(h) == 0) ||
2691 2692 2693 2694
		 (h->interrupts_enabled == 0)));
#endif
}

2695
static irqreturn_t do_cciss_intr(int irq, void *dev_id)
L
Linus Torvalds 已提交
2696 2697 2698 2699
{
	ctlr_info_t *h = dev_id;
	CommandList_struct *c;
	unsigned long flags;
2700
	__u32 a, a1, a2;
L
Linus Torvalds 已提交
2701

2702
	if (interrupt_not_for_us(h))
L
Linus Torvalds 已提交
2703 2704 2705 2706 2707 2708
		return IRQ_NONE;
	/*
	 * If there are completed commands in the completion queue,
	 * we had better do something about it.
	 */
	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2709
	while (interrupt_pending(h)) {
2710
		while ((a = get_next_completion(h)) != FIFO_EMPTY) {
L
Linus Torvalds 已提交
2711
			a1 = a;
2712 2713
			if ((a & 0x04)) {
				a2 = (a >> 3);
2714
				if (a2 >= h->nr_cmds) {
2715 2716 2717
					printk(KERN_WARNING
					       "cciss: controller cciss%d failed, stopping.\n",
					       h->ctlr);
2718 2719 2720 2721 2722 2723 2724 2725
					fail_all_cmds(h->ctlr);
					return IRQ_HANDLED;
				}

				c = h->cmd_pool + a2;
				a = c->busaddr;

			} else {
2726
				a &= ~3;
2727
				if ((c = h->cmpQ) == NULL) {
2728 2729 2730 2731 2732 2733 2734 2735 2736 2737
					printk(KERN_WARNING
					       "cciss: Completion of %08x ignored\n",
					       a1);
					continue;
				}
				while (c->busaddr != a) {
					c = c->next;
					if (c == h->cmpQ)
						break;
				}
2738
			}
L
Linus Torvalds 已提交
2739 2740 2741 2742
			/*
			 * If we've found the command, take it off the
			 * completion Q and free it
			 */
2743
			if (c->busaddr == a) {
L
Linus Torvalds 已提交
2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
				removeQ(&h->cmpQ, c);
				if (c->cmd_type == CMD_RWREQ) {
					complete_command(h, c, 0);
				} else if (c->cmd_type == CMD_IOCTL_PEND) {
					complete(c->waiting);
				}
#				ifdef CONFIG_CISS_SCSI_TAPE
				else if (c->cmd_type == CMD_SCSI)
					complete_scsi_command(c, 0, a1);
#				endif
				continue;
			}
		}
	}

	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
	return IRQ_HANDLED;
}
2762 2763

/*
2764
 *  We cannot read the structure directly, for portability we must use
L
Linus Torvalds 已提交
2765
 *   the io functions.
2766
 *   This is for debug only.
L
Linus Torvalds 已提交
2767 2768
 */
#ifdef CCISS_DEBUG
2769
static void print_cfg_table(CfgTable_struct *tb)
L
Linus Torvalds 已提交
2770 2771 2772 2773 2774 2775
{
	int i;
	char temp_name[17];

	printk("Controller Configuration information\n");
	printk("------------------------------------\n");
2776
	for (i = 0; i < 4; i++)
L
Linus Torvalds 已提交
2777
		temp_name[i] = readb(&(tb->Signature[i]));
2778 2779
	temp_name[4] = '\0';
	printk("   Signature = %s\n", temp_name);
L
Linus Torvalds 已提交
2780
	printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
2781 2782 2783 2784 2785 2786
	printk("   Transport methods supported = 0x%x\n",
	       readl(&(tb->TransportSupport)));
	printk("   Transport methods active = 0x%x\n",
	       readl(&(tb->TransportActive)));
	printk("   Requested transport Method = 0x%x\n",
	       readl(&(tb->HostWrite.TransportRequest)));
2787
	printk("   Coalesce Interrupt Delay = 0x%x\n",
2788
	       readl(&(tb->HostWrite.CoalIntDelay)));
2789
	printk("   Coalesce Interrupt Count = 0x%x\n",
2790 2791 2792 2793 2794
	       readl(&(tb->HostWrite.CoalIntCount)));
	printk("   Max outstanding commands = 0x%d\n",
	       readl(&(tb->CmdsOutMax)));
	printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
	for (i = 0; i < 16; i++)
L
Linus Torvalds 已提交
2795 2796 2797
		temp_name[i] = readb(&(tb->ServerName[i]));
	temp_name[16] = '\0';
	printk("   Server Name = %s\n", temp_name);
2798
	printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
L
Linus Torvalds 已提交
2799
}
2800
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2801

2802
static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
L
Linus Torvalds 已提交
2803 2804
{
	int i, offset, mem_type, bar_type;
2805
	if (pci_bar_addr == PCI_BASE_ADDRESS_0)	/* looking for BAR zero? */
L
Linus Torvalds 已提交
2806 2807
		return 0;
	offset = 0;
2808 2809
	for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
		bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
L
Linus Torvalds 已提交
2810 2811 2812 2813
		if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
			offset += 4;
		else {
			mem_type = pci_resource_flags(pdev, i) &
2814
			    PCI_BASE_ADDRESS_MEM_TYPE_MASK;
L
Linus Torvalds 已提交
2815
			switch (mem_type) {
2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
			case PCI_BASE_ADDRESS_MEM_TYPE_32:
			case PCI_BASE_ADDRESS_MEM_TYPE_1M:
				offset += 4;	/* 32 bit */
				break;
			case PCI_BASE_ADDRESS_MEM_TYPE_64:
				offset += 8;
				break;
			default:	/* reserved in PCI 2.2 */
				printk(KERN_WARNING
				       "Base address is invalid\n");
				return -1;
L
Linus Torvalds 已提交
2827 2828 2829
				break;
			}
		}
2830 2831
		if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
			return i + 1;
L
Linus Torvalds 已提交
2832 2833 2834 2835
	}
	return -1;
}

2836 2837 2838 2839
/* If MSI/MSI-X is supported by the kernel we will try to enable it on
 * controllers that are capable. If not, we use IO-APIC mode.
 */

2840 2841
static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
					   struct pci_dev *pdev, __u32 board_id)
2842 2843
{
#ifdef CONFIG_PCI_MSI
2844 2845 2846 2847
	int err;
	struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
	{0, 2}, {0, 3}
	};
2848 2849 2850

	/* Some boards advertise MSI but don't really support it */
	if ((board_id == 0x40700E11) ||
2851 2852
	    (board_id == 0x40800E11) ||
	    (board_id == 0x40820E11) || (board_id == 0x40830E11))
2853 2854
		goto default_int_mode;

2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
	if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
		err = pci_enable_msix(pdev, cciss_msix_entries, 4);
		if (!err) {
			c->intr[0] = cciss_msix_entries[0].vector;
			c->intr[1] = cciss_msix_entries[1].vector;
			c->intr[2] = cciss_msix_entries[2].vector;
			c->intr[3] = cciss_msix_entries[3].vector;
			c->msix_vector = 1;
			return;
		}
		if (err > 0) {
			printk(KERN_WARNING "cciss: only %d MSI-X vectors "
			       "available\n", err);
2868
			goto default_int_mode;
2869 2870 2871
		} else {
			printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
			       err);
2872
			goto default_int_mode;
2873 2874 2875 2876 2877 2878 2879 2880 2881
		}
	}
	if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
		if (!pci_enable_msi(pdev)) {
			c->msi_vector = 1;
		} else {
			printk(KERN_WARNING "cciss: MSI init failed\n");
		}
	}
2882
default_int_mode:
2883
#endif				/* CONFIG_PCI_MSI */
2884
	/* if we get here we're going to use the default interrupt mode */
2885
	c->intr[SIMPLE_MODE_INT] = pdev->irq;
2886 2887 2888
	return;
}

L
Linus Torvalds 已提交
2889 2890 2891 2892 2893 2894 2895
static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
{
	ushort subsystem_vendor_id, subsystem_device_id, command;
	__u32 board_id, scratchpad = 0;
	__u64 cfg_offset;
	__u32 cfg_base_addr;
	__u64 cfg_base_addr_index;
2896
	int i, err;
L
Linus Torvalds 已提交
2897 2898 2899

	/* check to see if controller has been disabled */
	/* BEFORE trying to enable it */
2900 2901 2902 2903
	(void)pci_read_config_word(pdev, PCI_COMMAND, &command);
	if (!(command & 0x02)) {
		printk(KERN_WARNING
		       "cciss: controller appears to be disabled\n");
2904
		return -ENODEV;
L
Linus Torvalds 已提交
2905 2906
	}

2907
	err = pci_enable_device(pdev);
2908
	if (err) {
L
Linus Torvalds 已提交
2909
		printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2910
		return err;
L
Linus Torvalds 已提交
2911 2912
	}

2913 2914 2915
	err = pci_request_regions(pdev, "cciss");
	if (err) {
		printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
2916
		       "aborting\n");
2917
		return err;
2918 2919
	}

L
Linus Torvalds 已提交
2920 2921 2922
	subsystem_vendor_id = pdev->subsystem_vendor;
	subsystem_device_id = pdev->subsystem_device;
	board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2923
		    subsystem_vendor_id);
L
Linus Torvalds 已提交
2924 2925 2926 2927 2928

#ifdef CCISS_DEBUG
	printk("command = %x\n", command);
	printk("irq = %x\n", pdev->irq);
	printk("board_id = %x\n", board_id);
2929
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2930

2931 2932 2933 2934
/* If the kernel supports MSI/MSI-X we will try to enable that functionality,
 * else we use the IO-APIC interrupt assigned to us by system ROM.
 */
	cciss_interrupt_mode(c, pdev, board_id);
L
Linus Torvalds 已提交
2935 2936 2937

	/*
	 * Memory base addr is first addr , the second points to the config
2938
	 *   table
L
Linus Torvalds 已提交
2939 2940
	 */

2941
	c->paddr = pci_resource_start(pdev, 0);	/* addressing mode bits already removed */
L
Linus Torvalds 已提交
2942 2943
#ifdef CCISS_DEBUG
	printk("address 0 = %x\n", c->paddr);
2944
#endif				/* CCISS_DEBUG */
2945
	c->vaddr = remap_pci_mem(c->paddr, 0x250);
L
Linus Torvalds 已提交
2946 2947 2948

	/* Wait for the board to become ready.  (PCI hotplug needs this.)
	 * We poll for up to 120 secs, once per 100ms. */
2949
	for (i = 0; i < 1200; i++) {
L
Linus Torvalds 已提交
2950 2951 2952 2953
		scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
		if (scratchpad == CCISS_FIRMWARE_READY)
			break;
		set_current_state(TASK_INTERRUPTIBLE);
2954
		schedule_timeout(HZ / 10);	/* wait 100ms */
L
Linus Torvalds 已提交
2955 2956 2957
	}
	if (scratchpad != CCISS_FIRMWARE_READY) {
		printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
2958
		err = -ENODEV;
2959
		goto err_out_free_res;
L
Linus Torvalds 已提交
2960 2961 2962 2963 2964 2965 2966
	}

	/* get the address index number */
	cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
	cfg_base_addr &= (__u32) 0x0000ffff;
#ifdef CCISS_DEBUG
	printk("cfg base address = %x\n", cfg_base_addr);
2967 2968
#endif				/* CCISS_DEBUG */
	cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
L
Linus Torvalds 已提交
2969 2970
#ifdef CCISS_DEBUG
	printk("cfg base address index = %x\n", cfg_base_addr_index);
2971
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2972 2973
	if (cfg_base_addr_index == -1) {
		printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2974
		err = -ENODEV;
2975
		goto err_out_free_res;
L
Linus Torvalds 已提交
2976 2977 2978 2979 2980
	}

	cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
#ifdef CCISS_DEBUG
	printk("cfg offset = %x\n", cfg_offset);
2981 2982 2983 2984
#endif				/* CCISS_DEBUG */
	c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
						       cfg_base_addr_index) +
				    cfg_offset, sizeof(CfgTable_struct));
L
Linus Torvalds 已提交
2985 2986 2987
	c->board_id = board_id;

#ifdef CCISS_DEBUG
2988
	print_cfg_table(c->cfgtable);
2989
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
2990

2991
	for (i = 0; i < ARRAY_SIZE(products); i++) {
L
Linus Torvalds 已提交
2992 2993 2994
		if (board_id == products[i].board_id) {
			c->product_name = products[i].product_name;
			c->access = *(products[i].access);
2995
			c->nr_cmds = products[i].nr_cmds;
L
Linus Torvalds 已提交
2996 2997 2998
			break;
		}
	}
2999 3000 3001 3002
	if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
	    (readb(&c->cfgtable->Signature[1]) != 'I') ||
	    (readb(&c->cfgtable->Signature[2]) != 'S') ||
	    (readb(&c->cfgtable->Signature[3]) != 'S')) {
L
Linus Torvalds 已提交
3003
		printk("Does not appear to be a valid CISS config table\n");
3004
		err = -ENODEV;
3005
		goto err_out_free_res;
L
Linus Torvalds 已提交
3006
	}
3007 3008 3009 3010 3011 3012 3013 3014
	/* We didn't find the controller in our list. We know the
	 * signature is valid. If it's an HP device let's try to
	 * bind to the device and fire it up. Otherwise we bail.
	 */
	if (i == ARRAY_SIZE(products)) {
		if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
			c->product_name = products[i-1].product_name;
			c->access = *(products[i-1].access);
3015
			c->nr_cmds = products[i-1].nr_cmds;
3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
			printk(KERN_WARNING "cciss: This is an unknown "
				"Smart Array controller.\n"
				"cciss: Please update to the latest driver "
				"available from www.hp.com.\n");
		} else {
			printk(KERN_WARNING "cciss: Sorry, I don't know how"
				" to access the Smart Array controller %08lx\n"
					, (unsigned long)board_id);
			err = -ENODEV;
			goto err_out_free_res;
		}
	}
L
Linus Torvalds 已提交
3028
#ifdef CONFIG_X86
3029 3030 3031 3032 3033 3034 3035
	{
		/* Need to enable prefetch in the SCSI core for 6400 in x86 */
		__u32 prefetch;
		prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
		prefetch |= 0x100;
		writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
	}
L
Linus Torvalds 已提交
3036 3037
#endif

3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
	/* Disabling DMA prefetch for the P600
	 * An ASIC bug may result in a prefetch beyond
	 * physical memory.
	 */
	if(board_id == 0x3225103C) {
		__u32 dma_prefetch;
		dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
		dma_prefetch |= 0x8000;
		writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
	}

L
Linus Torvalds 已提交
3049 3050
#ifdef CCISS_DEBUG
	printk("Trying to put board into Simple mode\n");
3051
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3052
	c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3053 3054 3055
	/* Update the field, and then ring the doorbell */
	writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
	writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
L
Linus Torvalds 已提交
3056 3057 3058 3059

	/* under certain very rare conditions, this can take awhile.
	 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
	 * as we enter this code.) */
3060
	for (i = 0; i < MAX_CONFIG_WAIT; i++) {
L
Linus Torvalds 已提交
3061 3062 3063 3064 3065
		if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
			break;
		/* delay and try again */
		set_current_state(TASK_INTERRUPTIBLE);
		schedule_timeout(10);
3066
	}
L
Linus Torvalds 已提交
3067 3068

#ifdef CCISS_DEBUG
3069 3070 3071
	printk(KERN_DEBUG "I counter got to %d %x\n", i,
	       readl(c->vaddr + SA5_DOORBELL));
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3072
#ifdef CCISS_DEBUG
3073 3074
	print_cfg_table(c->cfgtable);
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3075

3076
	if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
L
Linus Torvalds 已提交
3077
		printk(KERN_WARNING "cciss: unable to get board into"
3078
		       " simple mode\n");
3079
		err = -ENODEV;
3080
		goto err_out_free_res;
L
Linus Torvalds 已提交
3081 3082 3083
	}
	return 0;

3084
err_out_free_res:
3085 3086 3087 3088
	/*
	 * Deliberately omit pci_disable_device(): it does something nasty to
	 * Smart Array controllers that pci_enable_device does not undo
	 */
3089
	pci_release_regions(pdev);
3090
	return err;
L
Linus Torvalds 已提交
3091 3092
}

3093 3094 3095
/*
 * Gets information about the local volumes attached to the controller.
 */
L
Linus Torvalds 已提交
3096 3097 3098 3099 3100 3101 3102 3103 3104
static void cciss_getgeometry(int cntl_num)
{
	ReportLunData_struct *ld_buff;
	InquiryData_struct *inq_buff;
	int return_code;
	int i;
	int listlength = 0;
	__u32 lunid = 0;
	int block_size;
3105
	sector_t total_size;
L
Linus Torvalds 已提交
3106

3107
	ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3108 3109 3110 3111 3112 3113 3114
	if (ld_buff == NULL) {
		printk(KERN_ERR "cciss: out of memory\n");
		return;
	}
	inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
	if (inq_buff == NULL) {
		printk(KERN_ERR "cciss: out of memory\n");
L
Linus Torvalds 已提交
3115
		kfree(ld_buff);
3116 3117 3118 3119 3120 3121 3122
		return;
	}
	/* Get the firmware version */
	return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
			      sizeof(InquiryData_struct), 0, 0, 0, NULL,
			      TYPE_CMD);
	if (return_code == IO_OK) {
L
Linus Torvalds 已提交
3123 3124 3125 3126
		hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
		hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
		hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
		hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3127 3128
	} else {		/* send command failed */

L
Linus Torvalds 已提交
3129
		printk(KERN_WARNING "cciss: unable to determine firmware"
3130
		       " version of controller\n");
L
Linus Torvalds 已提交
3131
	}
3132 3133 3134 3135
	/* Get the number of logical volumes */
	return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
			      sizeof(ReportLunData_struct), 0, 0, 0, NULL,
			      TYPE_CMD);
L
Linus Torvalds 已提交
3136

3137
	if (return_code == IO_OK) {
L
Linus Torvalds 已提交
3138 3139
#ifdef CCISS_DEBUG
		printk("LUN Data\n--------------------------\n");
3140 3141 3142 3143 3144 3145 3146 3147
#endif				/* CCISS_DEBUG */

		listlength |=
		    (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
		listlength |=
		    (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
		listlength |=
		    (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
L
Linus Torvalds 已提交
3148
		listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3149 3150
	} else {		/* reading number of logical volumes failed */

L
Linus Torvalds 已提交
3151
		printk(KERN_WARNING "cciss: report logical volume"
3152
		       " command failed\n");
L
Linus Torvalds 已提交
3153 3154
		listlength = 0;
	}
3155 3156 3157 3158 3159
	hba[cntl_num]->num_luns = listlength / 8;	// 8 bytes pre entry
	if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
		printk(KERN_ERR
		       "ciss:  only %d number of logical volumes supported\n",
		       CISS_MAX_LUN);
L
Linus Torvalds 已提交
3160 3161 3162
		hba[cntl_num]->num_luns = CISS_MAX_LUN;
	}
#ifdef CCISS_DEBUG
3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
	printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
	       ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
	       ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
	       hba[cntl_num]->num_luns);
#endif				/* CCISS_DEBUG */

	hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
	for (i = 0; i < CISS_MAX_LUN; i++) {
		if (i < hba[cntl_num]->num_luns) {
			lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
			    << 24;
			lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
			    << 16;
			lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
			    << 8;
			lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);

			hba[cntl_num]->drv[i].LunID = lunid;
L
Linus Torvalds 已提交
3181 3182

#ifdef CCISS_DEBUG
3183 3184 3185 3186 3187
			printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
			       ld_buff->LUN[i][0], ld_buff->LUN[i][1],
			       ld_buff->LUN[i][2], ld_buff->LUN[i][3],
			       hba[cntl_num]->drv[i].LunID);
#endif				/* CCISS_DEBUG */
3188 3189 3190 3191

		/* testing to see if 16-byte CDBs are already being used */
		if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
			cciss_read_capacity_16(cntl_num, i, 0,
3192
					    &total_size, &block_size);
3193 3194 3195 3196
			goto geo_inq;
		}
		cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);

3197 3198 3199
		/* If read_capacity returns all F's the logical is >2TB */
		/* so we switch to 16-byte CDBs for all read/write ops */
		if(total_size == 0xFFFFFFFFULL) {
3200 3201 3202 3203 3204 3205 3206 3207 3208
			cciss_read_capacity_16(cntl_num, i, 0,
			&total_size, &block_size);
			hba[cntl_num]->cciss_read = CCISS_READ_16;
			hba[cntl_num]->cciss_write = CCISS_WRITE_16;
		} else {
			hba[cntl_num]->cciss_read = CCISS_READ_10;
			hba[cntl_num]->cciss_write = CCISS_WRITE_10;
		}
geo_inq:
3209
			cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3210 3211
					       block_size, inq_buff,
					       &hba[cntl_num]->drv[i]);
3212 3213 3214 3215
		} else {
			/* initialize raid_level to indicate a free space */
			hba[cntl_num]->drv[i].raid_level = -1;
		}
L
Linus Torvalds 已提交
3216 3217 3218
	}
	kfree(ld_buff);
	kfree(inq_buff);
3219
}
L
Linus Torvalds 已提交
3220 3221 3222 3223 3224

/* Function to find the first free pointer into our hba[] array */
/* Returns -1 if no free entries are left.  */
static int alloc_cciss_hba(void)
{
3225
	int i;
L
Linus Torvalds 已提交
3226

3227
	for (i = 0; i < MAX_CTLR; i++) {
L
Linus Torvalds 已提交
3228 3229
		if (!hba[i]) {
			ctlr_info_t *p;
3230
			p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
L
Linus Torvalds 已提交
3231 3232
			if (!p)
				goto Enomem;
3233 3234 3235
			p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
			if (!p->gendisk[0])
				goto Enomem;
L
Linus Torvalds 已提交
3236 3237 3238 3239 3240
			hba[i] = p;
			return i;
		}
	}
	printk(KERN_WARNING "cciss: This driver supports a maximum"
3241
	       " of %d controllers.\n", MAX_CTLR);
3242 3243
	return -1;
Enomem:
L
Linus Torvalds 已提交
3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
	printk(KERN_ERR "cciss: out of memory.\n");
	return -1;
}

static void free_hba(int i)
{
	ctlr_info_t *p = hba[i];
	int n;

	hba[i] = NULL;
3254
	for (n = 0; n < CISS_MAX_LUN; n++)
L
Linus Torvalds 已提交
3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
		put_disk(p->gendisk[n]);
	kfree(p);
}

/*
 *  This is it.  Find all the controllers and register them.  I really hate
 *  stealing all these major device numbers.
 *  returns the number of block devices registered.
 */
static int __devinit cciss_init_one(struct pci_dev *pdev,
3265
				    const struct pci_device_id *ent)
L
Linus Torvalds 已提交
3266 3267
{
	int i;
3268
	int j = 0;
L
Linus Torvalds 已提交
3269
	int rc;
3270
	int dac;
L
Linus Torvalds 已提交
3271 3272

	i = alloc_cciss_hba();
3273
	if (i < 0)
3274
		return -1;
3275 3276 3277

	hba[i]->busy_initializing = 1;

L
Linus Torvalds 已提交
3278 3279 3280 3281 3282 3283 3284 3285
	if (cciss_pci_init(hba[i], pdev) != 0)
		goto clean1;

	sprintf(hba[i]->devname, "cciss%d", i);
	hba[i]->ctlr = i;
	hba[i]->pdev = pdev;

	/* configure PCI DMA stuff */
3286
	if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3287
		dac = 1;
3288
	else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3289
		dac = 0;
L
Linus Torvalds 已提交
3290
	else {
3291
		printk(KERN_ERR "cciss: no suitable DMA available\n");
L
Linus Torvalds 已提交
3292 3293 3294 3295 3296 3297 3298 3299 3300
		goto clean1;
	}

	/*
	 * register with the major number, or get a dynamic major number
	 * by passing 0 as argument.  This is done for greater than
	 * 8 controller support.
	 */
	if (i < MAX_CTLR_ORIG)
3301
		hba[i]->major = COMPAQ_CISS_MAJOR + i;
L
Linus Torvalds 已提交
3302
	rc = register_blkdev(hba[i]->major, hba[i]->devname);
3303
	if (rc == -EBUSY || rc == -EINVAL) {
L
Linus Torvalds 已提交
3304
		printk(KERN_ERR
3305 3306
		       "cciss:  Unable to get major number %d for %s "
		       "on hba %d\n", hba[i]->major, hba[i]->devname, i);
L
Linus Torvalds 已提交
3307
		goto clean1;
3308
	} else {
L
Linus Torvalds 已提交
3309 3310 3311 3312 3313 3314
		if (i >= MAX_CTLR_ORIG)
			hba[i]->major = rc;
	}

	/* make sure the board interrupts are off */
	hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3315
	if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3316
			IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
L
Linus Torvalds 已提交
3317
		printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3318
		       hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
L
Linus Torvalds 已提交
3319 3320
		goto clean2;
	}
3321 3322

	printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3323 3324 3325 3326
	       hba[i]->devname, pdev->device, pci_name(pdev),
	       hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");

	hba[i]->cmd_pool_bits =
3327
	    kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3328 3329 3330
		      1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
	hba[i]->cmd_pool = (CommandList_struct *)
	    pci_alloc_consistent(hba[i]->pdev,
3331
		    hba[i]->nr_cmds * sizeof(CommandList_struct),
3332 3333 3334
		    &(hba[i]->cmd_pool_dhandle));
	hba[i]->errinfo_pool = (ErrorInfo_struct *)
	    pci_alloc_consistent(hba[i]->pdev,
3335
		    hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3336 3337 3338 3339 3340
		    &(hba[i]->errinfo_pool_dhandle));
	if ((hba[i]->cmd_pool_bits == NULL)
	    || (hba[i]->cmd_pool == NULL)
	    || (hba[i]->errinfo_pool == NULL)) {
		printk(KERN_ERR "cciss: out of memory");
L
Linus Torvalds 已提交
3341 3342
		goto clean4;
	}
3343
#ifdef CONFIG_CISS_SCSI_TAPE
3344 3345
	hba[i]->scsi_rejects.complete =
	    kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3346
		    (hba[i]->nr_cmds + 5), GFP_KERNEL);
3347
	if (hba[i]->scsi_rejects.complete == NULL) {
3348
		printk(KERN_ERR "cciss: out of memory");
3349 3350 3351
		goto clean4;
	}
#endif
L
Linus Torvalds 已提交
3352 3353
	spin_lock_init(&hba[i]->lock);

3354 3355
	/* Initialize the pdev driver private data.
	   have it point to hba[i].  */
L
Linus Torvalds 已提交
3356
	pci_set_drvdata(pdev, hba[i]);
3357 3358 3359
	/* command and error info recs zeroed out before
	   they are used */
	memset(hba[i]->cmd_pool_bits, 0,
3360
	       ((hba[i]->nr_cmds + BITS_PER_LONG -
3361
		 1) / BITS_PER_LONG) * sizeof(unsigned long));
L
Linus Torvalds 已提交
3362

3363 3364 3365
#ifdef CCISS_DEBUG
	printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3366 3367 3368 3369 3370 3371 3372 3373 3374

	cciss_getgeometry(i);

	cciss_scsi_setup(i);

	/* Turn the interrupts on so we can service requests */
	hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);

	cciss_procinit(i);
3375 3376 3377

	hba[i]->cciss_max_sectors = 2048;

3378
	hba[i]->busy_initializing = 0;
L
Linus Torvalds 已提交
3379

3380
	do {
M
Mike Miller 已提交
3381 3382
		drive_info_struct *drv = &(hba[i]->drv[j]);
		struct gendisk *disk = hba[i]->gendisk[j];
3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395
		request_queue_t *q;

		/* Check if the disk was allocated already */
		if (!disk){
			hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
			disk = hba[i]->gendisk[j];
		}

		/* Check that the disk was able to be allocated */
		if (!disk) {
			printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
			goto clean4;
		}
M
Mike Miller 已提交
3396 3397 3398 3399

		q = blk_init_queue(do_cciss_request, &hba[i]->lock);
		if (!q) {
			printk(KERN_ERR
3400 3401
			       "cciss:  unable to allocate queue for disk %d\n",
			       j);
3402
			goto clean4;
M
Mike Miller 已提交
3403 3404 3405 3406
		}
		drv->queue = q;

		q->backing_dev_info.ra_pages = READ_AHEAD;
3407 3408 3409 3410
		blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);

		/* This is a hardware imposed limit. */
		blk_queue_max_hw_segments(q, MAXSGENTRIES);
L
Linus Torvalds 已提交
3411

3412 3413
		/* This is a limit in the driver and could be eliminated. */
		blk_queue_max_phys_segments(q, MAXSGENTRIES);
L
Linus Torvalds 已提交
3414

3415
		blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
L
Linus Torvalds 已提交
3416

3417
		blk_queue_softirq_done(q, cciss_softirq_done);
L
Linus Torvalds 已提交
3418

M
Mike Miller 已提交
3419
		q->queuedata = hba[i];
L
Linus Torvalds 已提交
3420 3421 3422 3423
		sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
		disk->major = hba[i]->major;
		disk->first_minor = j << NWD_SHIFT;
		disk->fops = &cciss_fops;
M
Mike Miller 已提交
3424
		disk->queue = q;
L
Linus Torvalds 已提交
3425
		disk->private_data = drv;
3426
		disk->driverfs_dev = &pdev->dev;
L
Linus Torvalds 已提交
3427 3428
		/* we must register the controller even if no disks exist */
		/* this is for the online array utilities */
3429
		if (!drv->heads && j)
L
Linus Torvalds 已提交
3430
			continue;
M
Mike Miller 已提交
3431
		blk_queue_hardsect_size(q, drv->block_size);
L
Linus Torvalds 已提交
3432 3433
		set_capacity(disk, drv->nr_blocks);
		add_disk(disk);
3434 3435
		j++;
	} while (j <= hba[i]->highest_lun);
M
Mike Miller 已提交
3436

3437
	return 1;
L
Linus Torvalds 已提交
3438

3439
      clean4:
3440
#ifdef CONFIG_CISS_SCSI_TAPE
3441
	kfree(hba[i]->scsi_rejects.complete);
3442
#endif
3443
	kfree(hba[i]->cmd_pool_bits);
3444
	if (hba[i]->cmd_pool)
L
Linus Torvalds 已提交
3445
		pci_free_consistent(hba[i]->pdev,
3446
				    hba[i]->nr_cmds * sizeof(CommandList_struct),
3447 3448
				    hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
	if (hba[i]->errinfo_pool)
L
Linus Torvalds 已提交
3449
		pci_free_consistent(hba[i]->pdev,
3450
				    hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3451 3452
				    hba[i]->errinfo_pool,
				    hba[i]->errinfo_pool_dhandle);
3453
	free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3454
      clean2:
L
Linus Torvalds 已提交
3455
	unregister_blkdev(hba[i]->major, hba[i]->devname);
3456
      clean1:
3457
	hba[i]->busy_initializing = 0;
3458 3459 3460 3461 3462 3463
	/* cleanup any queues that may have been initialized */
	for (j=0; j <= hba[i]->highest_lun; j++){
		drive_info_struct *drv = &(hba[i]->drv[j]);
		if (drv->queue)
			blk_cleanup_queue(drv->queue);
	}
3464 3465 3466 3467
	/*
	 * Deliberately omit pci_disable_device(): it does something nasty to
	 * Smart Array controllers that pci_enable_device does not undo
	 */
3468 3469
	pci_release_regions(pdev);
	pci_set_drvdata(pdev, NULL);
3470
	free_hba(i);
3471
	return -1;
L
Linus Torvalds 已提交
3472 3473
}

3474
static void cciss_shutdown(struct pci_dev *pdev)
L
Linus Torvalds 已提交
3475 3476
{
	ctlr_info_t *tmp_ptr;
3477
	int i;
L
Linus Torvalds 已提交
3478
	char flush_buf[4];
3479
	int return_code;
L
Linus Torvalds 已提交
3480

3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506
	tmp_ptr = pci_get_drvdata(pdev);
	if (tmp_ptr == NULL)
		return;
	i = tmp_ptr->ctlr;
	if (hba[i] == NULL)
		return;

	/* Turn board interrupts off  and send the flush cache command */
	/* sendcmd will turn off interrupt, and send the flush...
	 * To write all data in the battery backed cache to disks */
	memset(flush_buf, 0, 4);
	return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
			      TYPE_CMD);
	if (return_code == IO_OK) {
		printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
	} else {
		printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
	}
	free_irq(hba[i]->intr[2], hba[i]);
}

static void __devexit cciss_remove_one(struct pci_dev *pdev)
{
	ctlr_info_t *tmp_ptr;
	int i, j;

3507 3508
	if (pci_get_drvdata(pdev) == NULL) {
		printk(KERN_ERR "cciss: Unable to remove device \n");
L
Linus Torvalds 已提交
3509 3510 3511 3512
		return;
	}
	tmp_ptr = pci_get_drvdata(pdev);
	i = tmp_ptr->ctlr;
3513
	if (hba[i] == NULL) {
L
Linus Torvalds 已提交
3514
		printk(KERN_ERR "cciss: device appears to "
3515
		       "already be removed \n");
L
Linus Torvalds 已提交
3516 3517
		return;
	}
3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536

	remove_proc_entry(hba[i]->devname, proc_cciss);
	unregister_blkdev(hba[i]->major, hba[i]->devname);

	/* remove it from the disk list */
	for (j = 0; j < CISS_MAX_LUN; j++) {
		struct gendisk *disk = hba[i]->gendisk[j];
		if (disk) {
			request_queue_t *q = disk->queue;

			if (disk->flags & GENHD_FL_UP)
				del_gendisk(disk);
			if (q)
				blk_cleanup_queue(q);
		}
	}

	cciss_unregister_scsi(i);	/* unhook from SCSI subsystem */

3537
	cciss_shutdown(pdev);
3538 3539

#ifdef CONFIG_PCI_MSI
3540 3541 3542 3543 3544
	if (hba[i]->msix_vector)
		pci_disable_msix(hba[i]->pdev);
	else if (hba[i]->msi_vector)
		pci_disable_msi(hba[i]->pdev);
#endif				/* CONFIG_PCI_MSI */
3545

L
Linus Torvalds 已提交
3546 3547
	iounmap(hba[i]->vaddr);

3548
	pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
L
Linus Torvalds 已提交
3549
			    hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3550
	pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3551
			    hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
L
Linus Torvalds 已提交
3552
	kfree(hba[i]->cmd_pool_bits);
3553 3554 3555
#ifdef CONFIG_CISS_SCSI_TAPE
	kfree(hba[i]->scsi_rejects.complete);
#endif
3556 3557 3558 3559
	/*
	 * Deliberately omit pci_disable_device(): it does something nasty to
	 * Smart Array controllers that pci_enable_device does not undo
	 */
3560
	pci_release_regions(pdev);
3561
	pci_set_drvdata(pdev, NULL);
L
Linus Torvalds 已提交
3562
	free_hba(i);
3563
}
L
Linus Torvalds 已提交
3564 3565

static struct pci_driver cciss_pci_driver = {
3566 3567 3568 3569
	.name = "cciss",
	.probe = cciss_init_one,
	.remove = __devexit_p(cciss_remove_one),
	.id_table = cciss_pci_device_id,	/* id_table */
3570
	.shutdown = cciss_shutdown,
L
Linus Torvalds 已提交
3571 3572 3573 3574
};

/*
 *  This is it.  Register the PCI driver information for the cards we control
3575
 *  the OS will call our registered routines when it finds one of our cards.
L
Linus Torvalds 已提交
3576 3577 3578 3579 3580 3581
 */
static int __init cciss_init(void)
{
	printk(KERN_INFO DRIVER_NAME "\n");

	/* Register for our PCI devices */
3582
	return pci_register_driver(&cciss_pci_driver);
L
Linus Torvalds 已提交
3583 3584 3585 3586 3587 3588 3589 3590
}

static void __exit cciss_cleanup(void)
{
	int i;

	pci_unregister_driver(&cciss_pci_driver);
	/* double check that all controller entrys have been removed */
3591 3592
	for (i = 0; i < MAX_CTLR; i++) {
		if (hba[i] != NULL) {
L
Linus Torvalds 已提交
3593
			printk(KERN_WARNING "cciss: had to remove"
3594
			       " controller %d\n", i);
L
Linus Torvalds 已提交
3595 3596 3597 3598 3599 3600
			cciss_remove_one(hba[i]->pdev);
		}
	}
	remove_proc_entry("cciss", proc_root_driver);
}

3601 3602 3603 3604 3605 3606 3607 3608
static void fail_all_cmds(unsigned long ctlr)
{
	/* If we get here, the board is apparently dead. */
	ctlr_info_t *h = hba[ctlr];
	CommandList_struct *c;
	unsigned long flags;

	printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3609
	h->alive = 0;		/* the controller apparently died... */
3610 3611 3612

	spin_lock_irqsave(CCISS_LOCK(ctlr), flags);

3613
	pci_disable_device(h->pdev);	/* Make sure it is really dead. */
3614 3615

	/* move everything off the request queue onto the completed queue */
3616
	while ((c = h->reqQ) != NULL) {
3617 3618
		removeQ(&(h->reqQ), c);
		h->Qdepth--;
3619
		addQ(&(h->cmpQ), c);
3620 3621 3622
	}

	/* Now, fail everything on the completed queue with a HW error */
3623
	while ((c = h->cmpQ) != NULL) {
3624 3625 3626 3627 3628 3629 3630
		removeQ(&h->cmpQ, c);
		c->err_info->CommandStatus = CMD_HARDWARE_ERR;
		if (c->cmd_type == CMD_RWREQ) {
			complete_command(h, c, 0);
		} else if (c->cmd_type == CMD_IOCTL_PEND)
			complete(c->waiting);
#ifdef CONFIG_CISS_SCSI_TAPE
3631 3632
		else if (c->cmd_type == CMD_SCSI)
			complete_scsi_command(c, 0, 0);
3633 3634 3635 3636 3637 3638
#endif
	}
	spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
	return;
}

L
Linus Torvalds 已提交
3639 3640
module_init(cciss_init);
module_exit(cciss_cleanup);