cciss.c 121.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
M
Mike Miller 已提交
2 3
 *    Disk Array driver for HP Smart Array controllers.
 *    (C) Copyright 2000, 2007 Hewlett-Packard Development Company, L.P.
L
Linus Torvalds 已提交
4 5 6
 *
 *    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
M
Mike Miller 已提交
7
 *    the Free Software Foundation; version 2 of the License.
L
Linus Torvalds 已提交
8 9 10
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
M
Mike Miller 已提交
11 12
 *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *    General Public License for more details.
L
Linus Torvalds 已提交
13 14 15
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
M
Mike Miller 已提交
16 17
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 *    02111-1307, USA.
L
Linus Torvalds 已提交
18 19 20 21 22 23 24 25 26 27 28
 *
 *    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>
A
Alexey Dobriyan 已提交
29
#include <linux/smp_lock.h>
L
Linus Torvalds 已提交
30 31 32 33 34 35 36
#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>
37
#include <linux/seq_file.h>
38
#include <linux/init.h>
39
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
40 41 42
#include <linux/hdreg.h>
#include <linux/spinlock.h>
#include <linux/compat.h>
43
#include <linux/mutex.h>
L
Linus Torvalds 已提交
44 45 46
#include <asm/uaccess.h>
#include <asm/io.h>

47
#include <linux/dma-mapping.h>
L
Linus Torvalds 已提交
48 49 50
#include <linux/blkdev.h>
#include <linux/genhd.h>
#include <linux/completion.h>
51
#include <scsi/scsi.h>
52 53 54
#include <scsi/sg.h>
#include <scsi/scsi_ioctl.h>
#include <linux/cdrom.h>
55
#include <linux/scatterlist.h>
56
#include <linux/kthread.h>
L
Linus Torvalds 已提交
57 58

#define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
M
Mike Miller 已提交
59 60
#define DRIVER_NAME "HP CISS Driver (v 3.6.20)"
#define DRIVER_VERSION CCISS_DRIVER_VERSION(3, 6, 20)
L
Linus Torvalds 已提交
61 62 63

/* Embedded module documentation macros - see modules.h */
MODULE_AUTHOR("Hewlett-Packard Company");
M
Mike Miller 已提交
64
MODULE_DESCRIPTION("Driver for HP Smart Array Controllers");
L
Linus Torvalds 已提交
65
MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
M
Mike Miller 已提交
66 67 68
			" SA6i P600 P800 P400 P400i E200 E200i E500 P700m"
			" Smart Array G2 Series SAS/SATA Controllers");
MODULE_VERSION("3.6.20");
L
Linus Torvalds 已提交
69 70 71 72 73 74 75 76
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[] = {
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
	{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},
95
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3237},
96
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x323D},
M
Mike Miller 已提交
97 98 99 100 101
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3241},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3243},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3245},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3247},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3249},
M
Mike Miller 已提交
102 103
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x324A},
	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x324B},
104 105
	{PCI_VENDOR_ID_HP,     PCI_ANY_ID,	PCI_ANY_ID, PCI_ANY_ID,
		PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
L
Linus Torvalds 已提交
106 107
	{0,}
};
108

L
Linus Torvalds 已提交
109 110 111 112
MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);

/*  board_id = Subsystem Device ID & Vendor ID
 *  product = Marketing Name for the board
113
 *  access = Address of the struct of function pointers
L
Linus Torvalds 已提交
114 115
 */
static struct board_type products[] = {
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
	{0x40700E11, "Smart Array 5300", &SA5_access},
	{0x40800E11, "Smart Array 5i", &SA5B_access},
	{0x40820E11, "Smart Array 532", &SA5B_access},
	{0x40830E11, "Smart Array 5312", &SA5B_access},
	{0x409A0E11, "Smart Array 641", &SA5_access},
	{0x409B0E11, "Smart Array 642", &SA5_access},
	{0x409C0E11, "Smart Array 6400", &SA5_access},
	{0x409D0E11, "Smart Array 6400 EM", &SA5_access},
	{0x40910E11, "Smart Array 6i", &SA5_access},
	{0x3225103C, "Smart Array P600", &SA5_access},
	{0x3223103C, "Smart Array P800", &SA5_access},
	{0x3234103C, "Smart Array P400", &SA5_access},
	{0x3235103C, "Smart Array P400i", &SA5_access},
	{0x3211103C, "Smart Array E200i", &SA5_access},
	{0x3212103C, "Smart Array E200", &SA5_access},
	{0x3213103C, "Smart Array E200i", &SA5_access},
	{0x3214103C, "Smart Array E200i", &SA5_access},
	{0x3215103C, "Smart Array E200i", &SA5_access},
	{0x3237103C, "Smart Array E500", &SA5_access},
	{0x323D103C, "Smart Array P700m", &SA5_access},
	{0x3241103C, "Smart Array P212", &SA5_access},
	{0x3243103C, "Smart Array P410", &SA5_access},
	{0x3245103C, "Smart Array P410i", &SA5_access},
	{0x3247103C, "Smart Array P411", &SA5_access},
	{0x3249103C, "Smart Array P812", &SA5_access},
M
Mike Miller 已提交
141 142
	{0x324A103C, "Smart Array P712m", &SA5_access},
	{0x324B103C, "Smart Array P711m", &SA5_access},
143
	{0xFFFF103C, "Unknown Smart Array", &SA5_access},
L
Linus Torvalds 已提交
144 145
};

146
/* How long to wait (in milliseconds) for board to go into simple mode */
147
#define MAX_CONFIG_WAIT 30000
L
Linus Torvalds 已提交
148 149 150 151 152 153 154 155 156 157 158 159
#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 MAX_CTLR	32

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

static ctlr_info_t *hba[MAX_CTLR];

160 161 162 163
static struct task_struct *cciss_scan_thread;
static DEFINE_MUTEX(scan_mutex);
static LIST_HEAD(scan_q);

164
static void do_cciss_request(struct request_queue *q);
165
static irqreturn_t do_cciss_intr(int irq, void *dev_id);
A
Al Viro 已提交
166 167 168
static int cciss_open(struct block_device *bdev, fmode_t mode);
static int cciss_release(struct gendisk *disk, fmode_t mode);
static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
169
		       unsigned int cmd, unsigned long arg);
170
static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
L
Linus Torvalds 已提交
171 172

static int cciss_revalidate(struct gendisk *disk);
M
Mike Miller 已提交
173
static int rebuild_lun_table(ctlr_info_t *h, int first_time);
174
static int deregister_disk(ctlr_info_t *h, int drv_index,
175
			   int clear_all);
L
Linus Torvalds 已提交
176

177 178 179 180 181 182 183
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,
184 185 186 187 188 189 190
				   drive_info_struct *drv);
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,
		   __u8 page_code, unsigned char *scsi3addr, int cmd_type);
static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
191 192
			__u8 page_code, unsigned char scsi3addr[],
			int cmd_type);
193 194 195
static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
	int attempt_retry);
static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c);
L
Linus Torvalds 已提交
196

197
static void fail_all_cmds(unsigned long ctlr);
198 199
static int scan_thread(void *data);
static int check_for_unit_attention(ctlr_info_t *h, CommandList_struct *c);
200

L
Linus Torvalds 已提交
201 202 203
#ifdef CONFIG_PROC_FS
static void cciss_procinit(int i);
#else
204 205 206 207
static void cciss_procinit(int i)
{
}
#endif				/* CONFIG_PROC_FS */
L
Linus Torvalds 已提交
208 209

#ifdef CONFIG_COMPAT
A
Al Viro 已提交
210 211
static int cciss_compat_ioctl(struct block_device *, fmode_t,
			      unsigned, unsigned long);
L
Linus Torvalds 已提交
212 213
#endif

214
static const struct block_device_operations cciss_fops = {
215
	.owner = THIS_MODULE,
A
Al Viro 已提交
216 217 218
	.open = cciss_open,
	.release = cciss_release,
	.locked_ioctl = cciss_ioctl,
219
	.getgeo = cciss_getgeo,
L
Linus Torvalds 已提交
220
#ifdef CONFIG_COMPAT
A
Al Viro 已提交
221
	.compat_ioctl = cciss_compat_ioctl,
L
Linus Torvalds 已提交
222
#endif
223
	.revalidate_disk = cciss_revalidate,
L
Linus Torvalds 已提交
224 225 226 227 228
};

/*
 * Enqueuing and dequeuing functions for cmdlists.
 */
229
static inline void addQ(struct hlist_head *list, CommandList_struct *c)
L
Linus Torvalds 已提交
230
{
231
	hlist_add_head(&c->list, list);
L
Linus Torvalds 已提交
232 233
}

234
static inline void removeQ(CommandList_struct *c)
L
Linus Torvalds 已提交
235
{
236 237 238 239 240 241 242 243 244 245
	/*
	 * After kexec/dump some commands might still
	 * be in flight, which the firmware will try
	 * to complete. Resetting the firmware doesn't work
	 * with old fw revisions, so we have to mark
	 * them off as 'stale' to prevent the driver from
	 * falling over.
	 */
	if (WARN_ON(hlist_unhashed(&c->list))) {
		c->cmd_type = CMD_MSG_STALE;
246
		return;
247
	}
248 249

	hlist_del_init(&c->list);
L
Linus Torvalds 已提交
250 251 252 253
}

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

R
Randy Dunlap 已提交
254 255
#define RAID_UNKNOWN 6

L
Linus Torvalds 已提交
256 257 258 259 260 261 262
#ifdef CONFIG_PROC_FS

/*
 * Report information about this controller.
 */
#define ENG_GIG 1000000000
#define ENG_GIG_FACTOR (ENG_GIG/512)
263
#define ENGAGE_SCSI	"engage scsi"
264 265 266
static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
	"UNKNOWN"
};
L
Linus Torvalds 已提交
267 268 269

static struct proc_dir_entry *proc_cciss;

270
static void cciss_seq_show_header(struct seq_file *seq)
L
Linus Torvalds 已提交
271
{
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	ctlr_info_t *h = seq->private;

	seq_printf(seq, "%s: HP %s Controller\n"
		"Board ID: 0x%08lx\n"
		"Firmware Version: %c%c%c%c\n"
		"IRQ: %d\n"
		"Logical drives: %d\n"
		"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",
		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],
		h->num_luns,
		h->Qdepth, h->commands_outstanding,
		h->maxQsinceinit, h->max_outstanding, h->maxSG);

#ifdef CONFIG_CISS_SCSI_TAPE
	cciss_seq_tape_report(seq, h->ctlr);
#endif /* CONFIG_CISS_SCSI_TAPE */
}
L
Linus Torvalds 已提交
297

298 299 300 301 302
static void *cciss_seq_start(struct seq_file *seq, loff_t *pos)
{
	ctlr_info_t *h = seq->private;
	unsigned ctlr = h->ctlr;
	unsigned long flags;
L
Linus Torvalds 已提交
303 304 305 306 307 308 309

	/* 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);
310
		return ERR_PTR(-EBUSY);
L
Linus Torvalds 已提交
311 312 313 314
	}
	h->busy_configuring = 1;
	spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
	if (*pos == 0)
		cciss_seq_show_header(seq);

	return pos;
}

static int cciss_seq_show(struct seq_file *seq, void *v)
{
	sector_t vol_sz, vol_sz_frac;
	ctlr_info_t *h = seq->private;
	unsigned ctlr = h->ctlr;
	loff_t *pos = v;
	drive_info_struct *drv = &h->drv[*pos];

	if (*pos > h->highest_lun)
		return 0;

	if (drv->heads == 0)
		return 0;

	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;
	seq_printf(seq, "cciss/c%dd%d:"
			"\t%4u.%02uGB\tRAID %s\n",
			ctlr, (int) *pos, (int)vol_sz, (int)vol_sz_frac,
			raid_label[drv->raid_level]);
	return 0;
}

static void *cciss_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	ctlr_info_t *h = seq->private;

	if (*pos > h->highest_lun)
		return NULL;
	*pos += 1;

	return pos;
}

static void cciss_seq_stop(struct seq_file *seq, void *v)
{
	ctlr_info_t *h = seq->private;

	/* Only reset h->busy_configuring if we succeeded in setting
	 * it during cciss_seq_start. */
	if (v == ERR_PTR(-EBUSY))
		return;
368

L
Linus Torvalds 已提交
369 370 371
	h->busy_configuring = 0;
}

J
James Morris 已提交
372
static const struct seq_operations cciss_seq_ops = {
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
	.start = cciss_seq_start,
	.show  = cciss_seq_show,
	.next  = cciss_seq_next,
	.stop  = cciss_seq_stop,
};

static int cciss_seq_open(struct inode *inode, struct file *file)
{
	int ret = seq_open(file, &cciss_seq_ops);
	struct seq_file *seq = file->private_data;

	if (!ret)
		seq->private = PDE(inode)->data;

	return ret;
}

static ssize_t
cciss_proc_write(struct file *file, const char __user *buf,
		 size_t length, loff_t *ppos)
L
Linus Torvalds 已提交
393
{
394 395 396 397 398
	int err;
	char *buffer;

#ifndef CONFIG_CISS_SCSI_TAPE
	return -EINVAL;
L
Linus Torvalds 已提交
399 400
#endif

401
	if (!buf || length > PAGE_SIZE - 1)
402
		return -EINVAL;
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418

	buffer = (char *)__get_free_page(GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	err = -EFAULT;
	if (copy_from_user(buffer, buf, length))
		goto out;
	buffer[length] = '\0';

#ifdef CONFIG_CISS_SCSI_TAPE
	if (strncmp(ENGAGE_SCSI, buffer, sizeof ENGAGE_SCSI - 1) == 0) {
		struct seq_file *seq = file->private_data;
		ctlr_info_t *h = seq->private;
		int rc;

419 420
		rc = cciss_engage_scsi(h->ctlr);
		if (rc != 0)
421 422 423 424 425 426
			err = -rc;
		else
			err = length;
	} else
#endif /* CONFIG_CISS_SCSI_TAPE */
		err = -EINVAL;
427 428
	/* might be nice to have "disengage" too, but it's not
	   safely possible. (only 1 module use count, lock issues.) */
429 430 431 432

out:
	free_page((unsigned long)buffer);
	return err;
L
Linus Torvalds 已提交
433 434
}

435 436 437 438 439 440 441 442 443
static struct file_operations cciss_proc_fops = {
	.owner	 = THIS_MODULE,
	.open    = cciss_seq_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
	.write	 = cciss_proc_write,
};

L
Linus Torvalds 已提交
444 445 446 447
static void __devinit cciss_procinit(int i)
{
	struct proc_dir_entry *pde;

448
	if (proc_cciss == NULL)
A
Alexey Dobriyan 已提交
449
		proc_cciss = proc_mkdir("driver/cciss", NULL);
450 451
	if (!proc_cciss)
		return;
452
	pde = proc_create_data(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP |
453
					S_IROTH, proc_cciss,
454
					&cciss_proc_fops, hba[i]);
L
Linus Torvalds 已提交
455
}
456
#endif				/* CONFIG_PROC_FS */
L
Linus Torvalds 已提交
457

458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 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
#define MAX_PRODUCT_NAME_LEN 19

#define to_hba(n) container_of(n, struct ctlr_info, dev)
#define to_drv(n) container_of(n, drive_info_struct, dev)

static struct device_type cciss_host_type = {
	.name		= "cciss_host",
};

static ssize_t dev_show_unique_id(struct device *dev,
				 struct device_attribute *attr,
				 char *buf)
{
	drive_info_struct *drv = to_drv(dev);
	struct ctlr_info *h = to_hba(drv->dev.parent);
	__u8 sn[16];
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
	if (h->busy_configuring)
		ret = -EBUSY;
	else
		memcpy(sn, drv->serial_no, sizeof(sn));
	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);

	if (ret)
		return ret;
	else
		return snprintf(buf, 16 * 2 + 2,
				"%02X%02X%02X%02X%02X%02X%02X%02X"
				"%02X%02X%02X%02X%02X%02X%02X%02X\n",
				sn[0], sn[1], sn[2], sn[3],
				sn[4], sn[5], sn[6], sn[7],
				sn[8], sn[9], sn[10], sn[11],
				sn[12], sn[13], sn[14], sn[15]);
}
DEVICE_ATTR(unique_id, S_IRUGO, dev_show_unique_id, NULL);

static ssize_t dev_show_vendor(struct device *dev,
			       struct device_attribute *attr,
			       char *buf)
{
	drive_info_struct *drv = to_drv(dev);
	struct ctlr_info *h = to_hba(drv->dev.parent);
	char vendor[VENDOR_LEN + 1];
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
	if (h->busy_configuring)
		ret = -EBUSY;
	else
		memcpy(vendor, drv->vendor, VENDOR_LEN + 1);
	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);

	if (ret)
		return ret;
	else
		return snprintf(buf, sizeof(vendor) + 1, "%s\n", drv->vendor);
}
DEVICE_ATTR(vendor, S_IRUGO, dev_show_vendor, NULL);

static ssize_t dev_show_model(struct device *dev,
			      struct device_attribute *attr,
			      char *buf)
{
	drive_info_struct *drv = to_drv(dev);
	struct ctlr_info *h = to_hba(drv->dev.parent);
	char model[MODEL_LEN + 1];
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
	if (h->busy_configuring)
		ret = -EBUSY;
	else
		memcpy(model, drv->model, MODEL_LEN + 1);
	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);

	if (ret)
		return ret;
	else
		return snprintf(buf, sizeof(model) + 1, "%s\n", drv->model);
}
DEVICE_ATTR(model, S_IRUGO, dev_show_model, NULL);

static ssize_t dev_show_rev(struct device *dev,
			    struct device_attribute *attr,
			    char *buf)
{
	drive_info_struct *drv = to_drv(dev);
	struct ctlr_info *h = to_hba(drv->dev.parent);
	char rev[REV_LEN + 1];
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
	if (h->busy_configuring)
		ret = -EBUSY;
	else
		memcpy(rev, drv->rev, REV_LEN + 1);
	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);

	if (ret)
		return ret;
	else
		return snprintf(buf, sizeof(rev) + 1, "%s\n", drv->rev);
}
DEVICE_ATTR(rev, S_IRUGO, dev_show_rev, NULL);

static struct attribute *cciss_dev_attrs[] = {
	&dev_attr_unique_id.attr,
	&dev_attr_model.attr,
	&dev_attr_vendor.attr,
	&dev_attr_rev.attr,
	NULL
};

static struct attribute_group cciss_dev_attr_group = {
	.attrs = cciss_dev_attrs,
};

581
static const struct attribute_group *cciss_dev_attr_groups[] = {
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
	&cciss_dev_attr_group,
	NULL
};

static struct device_type cciss_dev_type = {
	.name		= "cciss_device",
	.groups		= cciss_dev_attr_groups,
};

static struct bus_type cciss_bus_type = {
	.name		= "cciss",
};


/*
 * Initialize sysfs entry for each controller.  This sets up and registers
 * the 'cciss#' directory for each individual controller under
 * /sys/bus/pci/devices/<dev>/.
 */
static int cciss_create_hba_sysfs_entry(struct ctlr_info *h)
{
	device_initialize(&h->dev);
	h->dev.type = &cciss_host_type;
	h->dev.bus = &cciss_bus_type;
	dev_set_name(&h->dev, "%s", h->devname);
	h->dev.parent = &h->pdev->dev;

	return device_add(&h->dev);
}

/*
 * Remove sysfs entries for an hba.
 */
static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h)
{
	device_del(&h->dev);
}

/*
 * Initialize sysfs for each logical drive.  This sets up and registers
 * the 'c#d#' directory for each individual logical drive under
 * /sys/bus/pci/devices/<dev/ccis#/. We also create a link from
 * /sys/block/cciss!c#d# to this entry.
 */
static int cciss_create_ld_sysfs_entry(struct ctlr_info *h,
				       drive_info_struct *drv,
				       int drv_index)
{
	device_initialize(&drv->dev);
	drv->dev.type = &cciss_dev_type;
	drv->dev.bus = &cciss_bus_type;
	dev_set_name(&drv->dev, "c%dd%d", h->ctlr, drv_index);
	drv->dev.parent = &h->dev;
	return device_add(&drv->dev);
}

/*
 * Remove sysfs entries for a logical drive.
 */
static void cciss_destroy_ld_sysfs_entry(drive_info_struct *drv)
{
	device_del(&drv->dev);
}

646 647
/*
 * For operations that cannot sleep, a command block is allocated at init,
L
Linus Torvalds 已提交
648
 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
649 650 651 652 653
 * 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 已提交
654 655
{
	CommandList_struct *c;
656
	int i;
L
Linus Torvalds 已提交
657 658 659
	u64bit temp64;
	dma_addr_t cmd_dma_handle, err_dma_handle;

660 661 662 663 664
	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 已提交
665 666
		memset(c, 0, sizeof(CommandList_struct));

667 668
		c->cmdindex = -1;

669 670 671 672 673 674
		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 已提交
675 676 677 678
				sizeof(CommandList_struct), c, cmd_dma_handle);
			return NULL;
		}
		memset(c->err_info, 0, sizeof(ErrorInfo_struct));
679 680 681
	} else {		/* get it out of the controllers pool */

		do {
682 683
			i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
			if (i == h->nr_cmds)
684 685 686 687
				return NULL;
		} while (test_and_set_bit
			 (i & (BITS_PER_LONG - 1),
			  h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
L
Linus Torvalds 已提交
688 689 690
#ifdef CCISS_DEBUG
		printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
#endif
691
		c = h->cmd_pool + i;
L
Linus Torvalds 已提交
692
		memset(c, 0, sizeof(CommandList_struct));
693 694
		cmd_dma_handle = h->cmd_pool_dhandle
		    + i * sizeof(CommandList_struct);
L
Linus Torvalds 已提交
695 696
		c->err_info = h->errinfo_pool + i;
		memset(c->err_info, 0, sizeof(ErrorInfo_struct));
697 698 699
		err_dma_handle = h->errinfo_pool_dhandle
		    + i * sizeof(ErrorInfo_struct);
		h->nr_allocs++;
700 701

		c->cmdindex = i;
702
	}
L
Linus Torvalds 已提交
703

704
	INIT_HLIST_NODE(&c->list);
L
Linus Torvalds 已提交
705
	c->busaddr = (__u32) cmd_dma_handle;
706
	temp64.val = (__u64) err_dma_handle;
L
Linus Torvalds 已提交
707 708 709 710
	c->ErrDesc.Addr.lower = temp64.val32.lower;
	c->ErrDesc.Addr.upper = temp64.val32.upper;
	c->ErrDesc.Len = sizeof(ErrorInfo_struct);

711 712
	c->ctlr = h->ctlr;
	return c;
L
Linus Torvalds 已提交
713 714
}

715 716
/*
 * Frees a command block that was previously allocated with cmd_alloc().
L
Linus Torvalds 已提交
717 718 719 720 721 722
 */
static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
{
	int i;
	u64bit temp64;

723
	if (!got_from_pool) {
L
Linus Torvalds 已提交
724 725
		temp64.val32.lower = c->ErrDesc.Addr.lower;
		temp64.val32.upper = c->ErrDesc.Addr.upper;
726 727 728 729 730
		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 已提交
731
		i = c - h->cmd_pool;
732 733 734 735
		clear_bit(i & (BITS_PER_LONG - 1),
			  h->cmd_pool_bits + (i / BITS_PER_LONG));
		h->nr_frees++;
	}
L
Linus Torvalds 已提交
736 737 738 739
}

static inline ctlr_info_t *get_host(struct gendisk *disk)
{
740
	return disk->queue->queuedata;
L
Linus Torvalds 已提交
741 742 743 744 745 746 747 748 749 750
}

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

/*
 * Open.  Make sure the device is really there.
 */
A
Al Viro 已提交
751
static int cciss_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
752
{
A
Al Viro 已提交
753 754
	ctlr_info_t *host = get_host(bdev->bd_disk);
	drive_info_struct *drv = get_drv(bdev->bd_disk);
L
Linus Torvalds 已提交
755 756

#ifdef CCISS_DEBUG
A
Al Viro 已提交
757
	printk(KERN_DEBUG "cciss_open %s\n", bdev->bd_disk->disk_name);
758
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
759

760 761
	if (host->busy_initializing || drv->busy_configuring)
		return -EBUSY;
L
Linus Torvalds 已提交
762 763 764 765 766 767 768 769
	/*
	 * 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".
	 */
770
	if (drv->heads == 0) {
A
Al Viro 已提交
771
		if (MINOR(bdev->bd_dev) != 0) {	/* not node 0? */
L
Linus Torvalds 已提交
772
			/* if not node 0 make sure it is a partition = 0 */
A
Al Viro 已提交
773
			if (MINOR(bdev->bd_dev) & 0x0f) {
774
				return -ENXIO;
L
Linus Torvalds 已提交
775 776 777 778 779 780 781 782 783 784 785 786
				/* 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;
}
787

L
Linus Torvalds 已提交
788 789 790
/*
 * Close.  Sync first.
 */
A
Al Viro 已提交
791
static int cciss_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
792
{
A
Al Viro 已提交
793 794
	ctlr_info_t *host = get_host(disk);
	drive_info_struct *drv = get_drv(disk);
L
Linus Torvalds 已提交
795 796

#ifdef CCISS_DEBUG
A
Al Viro 已提交
797
	printk(KERN_DEBUG "cciss_release %s\n", disk->disk_name);
798
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
799 800 801 802 803 804 805 806

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

#ifdef CONFIG_COMPAT

A
Al Viro 已提交
807 808
static int do_ioctl(struct block_device *bdev, fmode_t mode,
		    unsigned cmd, unsigned long arg)
L
Linus Torvalds 已提交
809 810 811
{
	int ret;
	lock_kernel();
A
Al Viro 已提交
812
	ret = cciss_ioctl(bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
813 814 815 816
	unlock_kernel();
	return ret;
}

A
Al Viro 已提交
817 818 819 820
static int cciss_ioctl32_passthru(struct block_device *bdev, fmode_t mode,
				  unsigned cmd, unsigned long arg);
static int cciss_ioctl32_big_passthru(struct block_device *bdev, fmode_t mode,
				      unsigned cmd, unsigned long arg);
L
Linus Torvalds 已提交
821

A
Al Viro 已提交
822 823
static int cciss_compat_ioctl(struct block_device *bdev, fmode_t mode,
			      unsigned cmd, unsigned long arg)
L
Linus Torvalds 已提交
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
{
	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:
A
Al Viro 已提交
841
		return do_ioctl(bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
842 843

	case CCISS_PASSTHRU32:
A
Al Viro 已提交
844
		return cciss_ioctl32_passthru(bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
845
	case CCISS_BIG_PASSTHRU32:
A
Al Viro 已提交
846
		return cciss_ioctl32_big_passthru(bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
847 848 849 850 851 852

	default:
		return -ENOIOCTLCMD;
	}
}

A
Al Viro 已提交
853 854
static int cciss_ioctl32_passthru(struct block_device *bdev, fmode_t mode,
				  unsigned cmd, unsigned long arg)
L
Linus Torvalds 已提交
855 856
{
	IOCTL32_Command_struct __user *arg32 =
857
	    (IOCTL32_Command_struct __user *) arg;
L
Linus Torvalds 已提交
858 859 860 861 862 863
	IOCTL_Command_struct arg64;
	IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
	int err;
	u32 cp;

	err = 0;
864 865 866 867 868 869 870 871 872
	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 已提交
873 874 875 876 877 878 879 880
	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;

A
Al Viro 已提交
881
	err = do_ioctl(bdev, mode, CCISS_PASSTHRU, (unsigned long)p);
L
Linus Torvalds 已提交
882 883
	if (err)
		return err;
884 885 886
	err |=
	    copy_in_user(&arg32->error_info, &p->error_info,
			 sizeof(arg32->error_info));
L
Linus Torvalds 已提交
887 888 889 890 891
	if (err)
		return -EFAULT;
	return err;
}

A
Al Viro 已提交
892 893
static int cciss_ioctl32_big_passthru(struct block_device *bdev, fmode_t mode,
				      unsigned cmd, unsigned long arg)
L
Linus Torvalds 已提交
894 895
{
	BIG_IOCTL32_Command_struct __user *arg32 =
896
	    (BIG_IOCTL32_Command_struct __user *) arg;
L
Linus Torvalds 已提交
897
	BIG_IOCTL_Command_struct arg64;
898 899
	BIG_IOCTL_Command_struct __user *p =
	    compat_alloc_user_space(sizeof(arg64));
L
Linus Torvalds 已提交
900 901 902 903
	int err;
	u32 cp;

	err = 0;
904 905 906 907 908 909 910 911 912
	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 已提交
913 914 915 916 917 918 919
	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)
920
		return -EFAULT;
L
Linus Torvalds 已提交
921

A
Al Viro 已提交
922
	err = do_ioctl(bdev, mode, CCISS_BIG_PASSTHRU, (unsigned long)p);
L
Linus Torvalds 已提交
923 924
	if (err)
		return err;
925 926 927
	err |=
	    copy_in_user(&arg32->error_info, &p->error_info,
			 sizeof(arg32->error_info));
L
Linus Torvalds 已提交
928 929 930 931 932
	if (err)
		return -EFAULT;
	return err;
}
#endif
933 934 935 936 937 938 939 940 941 942 943 944 945 946

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;
}

947 948 949 950 951 952
static void check_ioctl_unit_attention(ctlr_info_t *host, CommandList_struct *c)
{
	if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
			c->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION)
		(void)check_for_unit_attention(host, c);
}
L
Linus Torvalds 已提交
953
/*
954
 * ioctl
L
Linus Torvalds 已提交
955
 */
A
Al Viro 已提交
956
static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
957
		       unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
958 959 960 961 962 963 964 965 966
{
	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);
967 968 969
#endif				/* CCISS_DEBUG */

	switch (cmd) {
L
Linus Torvalds 已提交
970
	case CCISS_GETPCIINFO:
971 972 973 974 975 976 977 978 979 980 981 982 983 984
		{
			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 已提交
985
	case CCISS_GETINTINFO:
986 987 988 989 990 991 992 993 994 995 996 997 998
		{
			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 已提交
999 1000
	case CCISS_SETINTINFO:
		{
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
			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 已提交
1036 1037
		}
	case CCISS_GETNODENAME:
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
		{
			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 已提交
1051
	case CCISS_SETNODENAME:
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
		{
			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 已提交
1087 1088

	case CCISS_GETHEARTBEAT:
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
		{
			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 已提交
1100
	case CCISS_GETBUSTYPES:
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
		{
			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 已提交
1112
	case CCISS_GETFIRMVER:
1113 1114
		{
			FirmwareVer_type firmware;
L
Linus Torvalds 已提交
1115

1116 1117 1118
			if (!arg)
				return -EINVAL;
			memcpy(firmware, host->firm_ver, 4);
L
Linus Torvalds 已提交
1119

1120 1121 1122 1123 1124 1125 1126 1127
			if (copy_to_user
			    (argp, firmware, sizeof(FirmwareVer_type)))
				return -EFAULT;
			return 0;
		}
	case CCISS_GETDRIVVER:
		{
			DriverVer_type DriverVer = DRIVER_VERSION;
L
Linus Torvalds 已提交
1128

1129 1130
			if (!arg)
				return -EINVAL;
L
Linus Torvalds 已提交
1131

1132 1133 1134 1135 1136
			if (copy_to_user
			    (argp, &DriverVer, sizeof(DriverVer_type)))
				return -EFAULT;
			return 0;
		}
L
Linus Torvalds 已提交
1137

M
Mike Miller 已提交
1138 1139
	case CCISS_DEREGDISK:
	case CCISS_REGNEWD:
L
Linus Torvalds 已提交
1140
	case CCISS_REVALIDVOLS:
M
Mike Miller 已提交
1141
		return rebuild_lun_table(host, 0);
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153

	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 已提交
1154 1155
	case CCISS_PASSTHRU:
		{
1156 1157 1158 1159 1160
			IOCTL_Command_struct iocommand;
			CommandList_struct *c;
			char *buff = NULL;
			u64bit temp64;
			unsigned long flags;
1161
			DECLARE_COMPLETION_ONSTACK(wait);
L
Linus Torvalds 已提交
1162

1163 1164
			if (!arg)
				return -EINVAL;
L
Linus Torvalds 已提交
1165

1166 1167
			if (!capable(CAP_SYS_RAWIO))
				return -EPERM;
L
Linus Torvalds 已提交
1168

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
			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 已提交
1215

1216 1217
			// Fill in Request block
			c->Request = iocommand.Request;
L
Linus Torvalds 已提交
1218

1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
			// 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);

1247 1248
			check_ioctl_unit_attention(host, c);

1249 1250 1251 1252 1253
			/* 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 已提交
1254 1255 1256
				cmd_free(host, c, 0);
				return -EFAULT;
			}
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269

			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 已提交
1270
		}
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
	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;
1281
			DECLARE_COMPLETION_ONSTACK(wait);
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
			__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 已提交
1302 1303
				status = -EINVAL;
				goto cleanup1;
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
			}
			/* 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 已提交
1317 1318 1319
				status = -ENOMEM;
				goto cleanup1;
			}
1320
			buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
						   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 已提交
1335
					status = -ENOMEM;
1336 1337
					goto cleanup1;
				}
1338 1339 1340
				if (ioc->Request.Type.Direction == XFER_WRITE) {
					if (copy_from_user
					    (buff[sg_used], data_ptr, sz)) {
1341
						status = -EFAULT;
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
						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 已提交
1361
			} else {
1362 1363
				c->Header.SGList = 0;
				c->Header.SGTotal = 0;
L
Linus Torvalds 已提交
1364
			}
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
			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 已提交
1398 1399
					PCI_DMA_BIDIRECTIONAL);
			}
1400
			check_ioctl_unit_attention(host, c);
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
			/* 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 已提交
1419 1420
				}
			}
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
			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 已提交
1432
		}
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444

	/* 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:
A
Al Viro 已提交
1445
		return scsi_cmd_ioctl(disk->queue, disk, mode, cmd, argp);
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456

	/* 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 已提交
1457 1458 1459 1460 1461
	default:
		return -ENOTTY;
	}
}

1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
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.
	 */
1472
	if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
		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.
		 */
1491
		if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
			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;
			}
		}
	}
}

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
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 */
1519
	for (i = 0; i < cmd->Header.SGList; i++) {
1520 1521 1522 1523 1524 1525 1526
		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);
	}

#ifdef CCISS_DEBUG
	printk("Done with %p\n", rq);
1527
#endif				/* CCISS_DEBUG */
1528

T
Tejun Heo 已提交
1529
	/* set the residual count for pc requests */
1530
	if (blk_pc_request(rq))
T
Tejun Heo 已提交
1531
		rq->resid_len = cmd->err_info->ResidualCnt;
1532

T
Tejun Heo 已提交
1533
	blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);
1534

1535
	spin_lock_irqsave(&h->lock, flags);
1536
	cmd_free(h, cmd, 1);
1537
	cciss_check_queues(h);
1538 1539 1540
	spin_unlock_irqrestore(&h->lock, flags);
}

1541 1542 1543 1544 1545 1546 1547 1548 1549
static void log_unit_to_scsi3addr(ctlr_info_t *h, unsigned char scsi3addr[],
	uint32_t log_unit)
{
	log_unit = h->drv[log_unit].LunID & 0x03fff;
	memset(&scsi3addr[4], 0, 4);
	memcpy(&scsi3addr[0], &log_unit, 4);
	scsi3addr[3] |= 0x40;
}

1550 1551 1552 1553 1554 1555 1556 1557 1558
/* This function gets the SCSI vendor, model, and revision of a logical drive
 * via the inquiry page 0.  Model, vendor, and rev are set to empty strings if
 * they cannot be read.
 */
static void cciss_get_device_descr(int ctlr, int logvol, int withirq,
				   char *vendor, char *model, char *rev)
{
	int rc;
	InquiryData_struct *inq_buf;
1559
	unsigned char scsi3addr[8];
1560 1561 1562 1563 1564 1565 1566 1567 1568

	*vendor = '\0';
	*model = '\0';
	*rev = '\0';

	inq_buf = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL);
	if (!inq_buf)
		return;

1569
	log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
1570 1571
	if (withirq)
		rc = sendcmd_withirq(CISS_INQUIRY, ctlr, inq_buf,
1572 1573
			     sizeof(InquiryData_struct), 0,
				scsi3addr, TYPE_CMD);
1574 1575
	else
		rc = sendcmd(CISS_INQUIRY, ctlr, inq_buf,
1576 1577
			     sizeof(InquiryData_struct), 0,
				scsi3addr, TYPE_CMD);
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
	if (rc == IO_OK) {
		memcpy(vendor, &inq_buf->data_byte[8], VENDOR_LEN);
		vendor[VENDOR_LEN] = '\0';
		memcpy(model, &inq_buf->data_byte[16], MODEL_LEN);
		model[MODEL_LEN] = '\0';
		memcpy(rev, &inq_buf->data_byte[32], REV_LEN);
		rev[REV_LEN] = '\0';
	}

	kfree(inq_buf);
	return;
}

1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
/* This function gets the serial number of a logical drive via
 * inquiry page 0x83.  Serial no. is 16 bytes.  If the serial
 * number cannot be had, for whatever reason, 16 bytes of 0xff
 * are returned instead.
 */
static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
				unsigned char *serial_no, int buflen)
{
#define PAGE_83_INQ_BYTES 64
	int rc;
	unsigned char *buf;
1602
	unsigned char scsi3addr[8];
1603 1604 1605 1606 1607 1608 1609 1610

	if (buflen > 16)
		buflen = 16;
	memset(serial_no, 0xff, buflen);
	buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
	if (!buf)
		return;
	memset(serial_no, 0, buflen);
1611
	log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
1612 1613
	if (withirq)
		rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
1614
			PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
1615 1616
	else
		rc = sendcmd(CISS_INQUIRY, ctlr, buf,
1617
			PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
1618 1619 1620 1621 1622 1623
	if (rc == IO_OK)
		memcpy(serial_no, &buf[8], buflen);
	kfree(buf);
	return;
}

M
Mike Miller 已提交
1624 1625 1626 1627 1628 1629 1630 1631 1632
static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
				int drv_index)
{
	disk->queue = blk_init_queue(do_cciss_request, &h->lock);
	sprintf(disk->disk_name, "cciss/c%dd%d", h->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];
1633
	disk->driverfs_dev = &h->drv[drv_index].dev;
M
Mike Miller 已提交
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649

	/* Set up queue information */
	blk_queue_bounce_limit(disk->queue, h->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);

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

	blk_queue_softirq_done(disk->queue, cciss_softirq_done);

	disk->queue->queuedata = h;

1650 1651
	blk_queue_logical_block_size(disk->queue,
				     h->drv[drv_index].block_size);
M
Mike Miller 已提交
1652 1653 1654 1655 1656 1657 1658 1659 1660

	/* Make sure all queue data is written out before */
	/* setting h->drv[drv_index].queue, as setting this */
	/* allows the interrupt handler to start the queue */
	wmb();
	h->drv[drv_index].queue = disk->queue;
	add_disk(disk);
}

1661
/* This function will check the usage_count of the drive to be updated/added.
1662 1663 1664 1665 1666 1667 1668 1669
 * If the usage_count is zero and it is a heretofore unknown drive, or,
 * the drive's capacity, geometry, or serial number has changed,
 * then the drive information will be updated and the disk will be
 * re-registered with the kernel.  If these conditions don't hold,
 * 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.
1670
 */
M
Mike Miller 已提交
1671
static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
1672
{
1673 1674 1675 1676
	ctlr_info_t *h = hba[ctlr];
	struct gendisk *disk;
	InquiryData_struct *inq_buff = NULL;
	unsigned int block_size;
1677
	sector_t total_size;
1678 1679
	unsigned long flags = 0;
	int ret = 0;
1680
	drive_info_struct *drvinfo;
M
Mike Miller 已提交
1681
	int was_only_controller_node;
1682 1683 1684 1685 1686 1687 1688

	/* Get information about the disk and modify the driver structure */
	inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
	drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL);
	if (inq_buff == NULL || drvinfo == NULL)
		goto mem_msg;

M
Mike Miller 已提交
1689 1690 1691 1692 1693 1694 1695
	/* See if we're trying to update the "controller node"
	 * this will happen the when the first logical drive gets
	 * created by ACU.
	 */
	was_only_controller_node = (drv_index == 0 &&
				h->drv[0].raid_level == -1);

1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723
	/* 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);

	} else {
		cciss_read_capacity(ctlr, drv_index, 1,
				    &total_size, &block_size);

		/* 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) {
			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;
		}
	}

	cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
			       inq_buff, drvinfo);
	drvinfo->block_size = block_size;
	drvinfo->nr_blocks = total_size + 1;

1724 1725
	cciss_get_device_descr(ctlr, drv_index, 1, drvinfo->vendor,
				drvinfo->model, drvinfo->rev);
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
	cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
			sizeof(drvinfo->serial_no));

	/* Is it the same disk we already know, and nothing's changed? */
	if (h->drv[drv_index].raid_level != -1 &&
		((memcmp(drvinfo->serial_no,
				h->drv[drv_index].serial_no, 16) == 0) &&
		drvinfo->block_size == h->drv[drv_index].block_size &&
		drvinfo->nr_blocks == h->drv[drv_index].nr_blocks &&
		drvinfo->heads == h->drv[drv_index].heads &&
		drvinfo->sectors == h->drv[drv_index].sectors &&
M
Mike Miller 已提交
1737
		drvinfo->cylinders == h->drv[drv_index].cylinders))
1738 1739 1740
			/* The disk is unchanged, nothing to update */
			goto freeret;

M
Mike Miller 已提交
1741 1742 1743 1744 1745 1746
	/* If we get here it's not the same disk, or something's changed,
	 * so we need to * deregister it, and re-register it, if it's not
	 * in use.
	 * If the disk already exists then deregister it before proceeding
	 * (unless it's the first disk (for the controller node).
	 */
1747 1748
	if (h->drv[drv_index].raid_level != -1 && drv_index != 0) {
		printk(KERN_WARNING "disk %d has changed.\n", drv_index);
1749 1750 1751
		spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
		h->drv[drv_index].busy_configuring = 1;
		spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1752

M
Mike Miller 已提交
1753 1754 1755 1756
		/* deregister_disk sets h->drv[drv_index].queue = NULL
		 * which keeps the interrupt handler from starting
		 * the queue.
		 */
1757
		ret = deregister_disk(h, drv_index, 0);
1758 1759 1760 1761 1762
		h->drv[drv_index].busy_configuring = 0;
	}

	/* If the disk is in use return */
	if (ret)
1763 1764
		goto freeret;

M
Mike Miller 已提交
1765 1766 1767
	/* Save the new information from cciss_geometry_inquiry
	 * and serial number inquiry.
	 */
1768 1769 1770 1771 1772 1773 1774
	h->drv[drv_index].block_size = drvinfo->block_size;
	h->drv[drv_index].nr_blocks = drvinfo->nr_blocks;
	h->drv[drv_index].heads = drvinfo->heads;
	h->drv[drv_index].sectors = drvinfo->sectors;
	h->drv[drv_index].cylinders = drvinfo->cylinders;
	h->drv[drv_index].raid_level = drvinfo->raid_level;
	memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
1775 1776 1777
	memcpy(h->drv[drv_index].vendor, drvinfo->vendor, VENDOR_LEN + 1);
	memcpy(h->drv[drv_index].model, drvinfo->model, MODEL_LEN + 1);
	memcpy(h->drv[drv_index].rev, drvinfo->rev, REV_LEN + 1);
1778 1779 1780 1781 1782

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

M
Mike Miller 已提交
1783 1784 1785 1786 1787 1788 1789 1790
	/* If it's not disk 0 (drv_index != 0)
	 * or if it was disk 0, but there was previously
	 * no actual corresponding configured logical drive
	 * (raid_leve == -1) then we want to update the
	 * logical drive's information.
	 */
	if (drv_index || first_time)
		cciss_add_disk(h, disk, drv_index);
1791

M
Mike Miller 已提交
1792
freeret:
1793
	kfree(inq_buff);
1794
	kfree(drvinfo);
1795
	return;
M
Mike Miller 已提交
1796
mem_msg:
1797 1798 1799 1800 1801 1802 1803 1804 1805
	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.
1806 1807
 * "controller_node" is used to know if this is a real logical drive, or just
 * the controller node, which determines if this counts towards highest_lun.
1808
 */
1809
static int cciss_find_free_drive_index(int ctlr, int controller_node)
1810 1811 1812
{
	int i;

1813 1814
	for (i = 0; i < CISS_MAX_LUN; i++) {
		if (hba[ctlr]->drv[i].raid_level == -1) {
1815
			if (i > hba[ctlr]->highest_lun)
1816 1817
				if (!controller_node)
					hba[ctlr]->highest_lun = i;
1818 1819 1820 1821 1822 1823
			return i;
		}
	}
	return -1;
}

M
Mike Miller 已提交
1824 1825 1826 1827 1828 1829 1830 1831 1832
/* cciss_add_gendisk finds a free hba[]->drv structure
 * and allocates a gendisk if needed, and sets the lunid
 * in the drvinfo structure.   It returns the index into
 * the ->drv[] array, or -1 if none are free.
 * is_controller_node indicates whether highest_lun should
 * count this disk, or if it's only being added to provide
 * a means to talk to the controller in case no logical
 * drives have yet been configured.
 */
1833
static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node)
M
Mike Miller 已提交
1834 1835 1836
{
	int drv_index;

1837
	drv_index = cciss_find_free_drive_index(h->ctlr, controller_node);
M
Mike Miller 已提交
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
	if (drv_index == -1)
		return -1;
	/*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%d: could not "
				"allocate a new disk %d\n",
				h->ctlr, drv_index);
			return -1;
		}
	}
	h->drv[drv_index].LunID = lunid;
1852 1853
	if (cciss_create_ld_sysfs_entry(h, &h->drv[drv_index], drv_index))
		goto err_free_disk;
M
Mike Miller 已提交
1854 1855 1856 1857 1858 1859 1860

	/* Don't need to mark this busy because nobody */
	/* else knows about this disk yet to contend */
	/* for access to it. */
	h->drv[drv_index].busy_configuring = 0;
	wmb();
	return drv_index;
1861 1862 1863 1864 1865

err_free_disk:
	put_disk(h->gendisk[drv_index]);
	h->gendisk[drv_index] = NULL;
	return -1;
M
Mike Miller 已提交
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
}

/* This is for the special case of a controller which
 * has no logical drives.  In this case, we still need
 * to register a disk so the controller can be accessed
 * by the Array Config Utility.
 */
static void cciss_add_controller_node(ctlr_info_t *h)
{
	struct gendisk *disk;
	int drv_index;

	if (h->gendisk[0] != NULL) /* already did this? Then bail. */
		return;

1881
	drv_index = cciss_add_gendisk(h, 0, 1);
M
Mike Miller 已提交
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
	if (drv_index == -1) {
		printk(KERN_WARNING "cciss%d: could not "
			"add disk 0.\n", h->ctlr);
		return;
	}
	h->drv[drv_index].block_size = 512;
	h->drv[drv_index].nr_blocks = 0;
	h->drv[drv_index].heads = 0;
	h->drv[drv_index].sectors = 0;
	h->drv[drv_index].cylinders = 0;
	h->drv[drv_index].raid_level = -1;
	memset(h->drv[drv_index].serial_no, 0, 16);
	disk = h->gendisk[drv_index];
	cciss_add_disk(h, disk, drv_index);
}

1898
/* This function will add and remove logical drives from the Logical
1899
 * drive array of the controller and maintain persistency of ordering
1900 1901 1902 1903 1904
 * 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
1905
 */
M
Mike Miller 已提交
1906
static int rebuild_lun_table(ctlr_info_t *h, int first_time)
L
Linus Torvalds 已提交
1907
{
1908 1909 1910 1911 1912 1913 1914 1915 1916
	int ctlr = h->ctlr;
	int num_luns;
	ReportLunData_struct *ld_buff = NULL;
	int return_code;
	int listlength = 0;
	int i;
	int drv_found;
	int drv_index = 0;
	__u32 lunid = 0;
L
Linus Torvalds 已提交
1917
	unsigned long flags;
1918

M
Mike Miller 已提交
1919 1920 1921
	if (!capable(CAP_SYS_RAWIO))
		return -EPERM;

1922 1923
	/* Set busy_configuring flag for this operation */
	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1924
	if (h->busy_configuring) {
1925 1926 1927 1928
		spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
		return -EBUSY;
	}
	h->busy_configuring = 1;
1929
	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1930

1931 1932 1933 1934 1935
	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,
1936 1937
				      sizeof(ReportLunData_struct),
				      0, CTLR_LUNID, TYPE_CMD);
1938

1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
	if (return_code == IO_OK)
		listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
	else {	/* reading number of logical volumes failed */
		printk(KERN_WARNING "cciss: report logical volume"
		       " command failed\n");
		listlength = 0;
		goto freeret;
	}

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

M
Mike Miller 已提交
1956 1957 1958 1959 1960 1961 1962 1963
	if (num_luns == 0)
		cciss_add_controller_node(h);

	/* Compare controller drive array to driver's drive array
	 * to see if any drives are missing on the controller due
	 * to action of Array Config Utility (user deletes drive)
	 * and deregister logical drives which have disappeared.
	 */
1964 1965 1966
	for (i = 0; i <= h->highest_lun; i++) {
		int j;
		drv_found = 0;
1967 1968 1969 1970 1971

		/* skip holes in the array from already deleted drives */
		if (h->drv[i].raid_level == -1)
			continue;

1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
		for (j = 0; j < num_luns; j++) {
			memcpy(&lunid, &ld_buff->LUN[j][0], 4);
			lunid = le32_to_cpu(lunid);
			if (h->drv[i].LunID == lunid) {
				drv_found = 1;
				break;
			}
		}
		if (!drv_found) {
			/* Deregister it from the OS, it's gone. */
			spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
			h->drv[i].busy_configuring = 1;
			spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1985
			return_code = deregister_disk(h, i, 1);
1986
			h->drv[i].busy_configuring = 0;
1987
		}
1988
	}
1989

1990 1991 1992 1993 1994 1995 1996
	/* Compare controller drive array to driver's drive array.
	 * Check for updates in the drive information and any new drives
	 * on the controller due to ACU adding logical drives, or changing
	 * a logical drive's size, etc.  Reregister any new/changed drives
	 */
	for (i = 0; i < num_luns; i++) {
		int j;
1997

1998
		drv_found = 0;
1999

2000 2001
		memcpy(&lunid, &ld_buff->LUN[i][0], 4);
		lunid = le32_to_cpu(lunid);
2002

2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
		/* Find if the LUN is already in the drive array
		 * of the driver.  If so then update its info
		 * if not in use.  If it does not exist then find
		 * the first free index and add it.
		 */
		for (j = 0; j <= h->highest_lun; j++) {
			if (h->drv[j].raid_level != -1 &&
				h->drv[j].LunID == lunid) {
				drv_index = j;
				drv_found = 1;
				break;
2014
			}
2015
		}
2016

2017 2018
		/* check if the drive was found already in the array */
		if (!drv_found) {
2019
			drv_index = cciss_add_gendisk(h, lunid, 0);
2020 2021 2022
			if (drv_index == -1)
				goto freeret;
		}
M
Mike Miller 已提交
2023
		cciss_update_drive_info(ctlr, drv_index, first_time);
2024
	}		/* end for */
2025

M
Mike Miller 已提交
2026
freeret:
2027 2028 2029 2030 2031
	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.
2032
	 */
2033
	return -1;
M
Mike Miller 已提交
2034
mem_msg:
2035
	printk(KERN_ERR "cciss: out of memory\n");
2036
	h->busy_configuring = 0;
2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
	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
2051
 *             the disk in preparation for re-adding it.  In this case
2052 2053 2054
 *             the highest_lun should be left unchanged and the LunID
 *             should not be cleared.
*/
2055
static int deregister_disk(ctlr_info_t *h, int drv_index,
2056 2057
			   int clear_all)
{
2058
	int i;
2059 2060
	struct gendisk *disk;
	drive_info_struct *drv;
L
Linus Torvalds 已提交
2061 2062 2063 2064

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

2065 2066 2067
	drv = &h->drv[drv_index];
	disk = h->gendisk[drv_index];

L
Linus Torvalds 已提交
2068
	/* make sure logical volume is NOT is use */
2069 2070 2071 2072 2073
	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 已提交
2074

2075 2076 2077
	/* 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.
2078 2079
	 */
	if (h->gendisk[0] != disk) {
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095
		struct request_queue *q = disk->queue;
		if (disk->flags & GENHD_FL_UP)
			del_gendisk(disk);
		if (q) {
			blk_cleanup_queue(q);
			/* Set drv->queue to NULL so that we do not try
			 * to call blk_start_queue on this queue in the
			 * interrupt handler
			 */
			drv->queue = NULL;
		}
		/* 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.
2096
		 */
2097 2098 2099 2100 2101
		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.
2102
			 */
2103
			for (i=0; i < CISS_MAX_LUN; i++){
2104
				if (h->gendisk[i] == disk) {
2105 2106
					h->gendisk[i] = NULL;
					break;
2107 2108
				}
			}
2109
			put_disk(disk);
2110
		}
2111 2112
	} else {
		set_capacity(disk, 0);
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
	}

	--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.
2125
				 */
2126
	cciss_destroy_ld_sysfs_entry(drv);
2127 2128 2129 2130 2131 2132

	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;
2133
			for (i = 0; i <= h->highest_lun; i++) {
2134
				/* if the disk has size > 0, it is available */
2135
				if (h->drv[i].heads)
2136 2137 2138
					newhighest = i;
			}
			h->highest_lun = newhighest;
L
Linus Torvalds 已提交
2139
		}
2140

2141
		drv->LunID = 0;
2142
	}
2143
	return 0;
L
Linus Torvalds 已提交
2144
}
2145

2146 2147 2148
static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
		size_t size, __u8 page_code, unsigned char *scsi3addr,
		int cmd_type)
L
Linus Torvalds 已提交
2149
{
2150
	ctlr_info_t *h = hba[ctlr];
L
Linus Torvalds 已提交
2151 2152 2153 2154 2155
	u64bit buff_dma_handle;
	int status = IO_OK;

	c->cmd_type = CMD_IOCTL_PEND;
	c->Header.ReplyQueue = 0;
2156
	if (buff != NULL) {
L
Linus Torvalds 已提交
2157
		c->Header.SGList = 1;
2158
		c->Header.SGTotal = 1;
L
Linus Torvalds 已提交
2159 2160
	} else {
		c->Header.SGList = 0;
2161
		c->Header.SGTotal = 0;
L
Linus Torvalds 已提交
2162 2163
	}
	c->Header.Tag.lower = c->busaddr;
2164
	memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8);
L
Linus Torvalds 已提交
2165 2166 2167

	c->Request.Type.Type = cmd_type;
	if (cmd_type == TYPE_CMD) {
2168 2169
		switch (cmd) {
		case CISS_INQUIRY:
L
Linus Torvalds 已提交
2170
			/* are we trying to read a vital product page */
2171
			if (page_code != 0) {
L
Linus Torvalds 已提交
2172 2173 2174 2175
				c->Request.CDB[1] = 0x01;
				c->Request.CDB[2] = page_code;
			}
			c->Request.CDBLen = 6;
2176
			c->Request.Type.Attribute = ATTR_SIMPLE;
L
Linus Torvalds 已提交
2177 2178
			c->Request.Type.Direction = XFER_READ;
			c->Request.Timeout = 0;
2179 2180 2181
			c->Request.CDB[0] = CISS_INQUIRY;
			c->Request.CDB[4] = size & 0xFF;
			break;
L
Linus Torvalds 已提交
2182 2183
		case CISS_REPORT_LOG:
		case CISS_REPORT_PHYS:
2184
			/* Talking to controller so It's a physical command
L
Linus Torvalds 已提交
2185
			   mode = 00 target = 0.  Nothing to write.
2186
			 */
L
Linus Torvalds 已提交
2187 2188 2189 2190 2191
			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;
2192
			c->Request.CDB[6] = (size >> 24) & 0xFF;	//MSB
L
Linus Torvalds 已提交
2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203
			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->Request.CDBLen = 10;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_READ;
			c->Request.Timeout = 0;
			c->Request.CDB[0] = cmd;
2204
			break;
2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218
		case CCISS_READ_CAPACITY_16:
			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 已提交
2219 2220 2221 2222 2223 2224 2225
		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;
2226
			break;
2227 2228 2229 2230 2231 2232
		case TEST_UNIT_READY:
			c->Request.CDBLen = 6;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_NONE;
			c->Request.Timeout = 0;
			break;
L
Linus Torvalds 已提交
2233 2234
		default:
			printk(KERN_WARNING
2235
			       "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
2236
			return IO_ERROR;
L
Linus Torvalds 已提交
2237 2238 2239
		}
	} else if (cmd_type == TYPE_MSG) {
		switch (cmd) {
2240
		case 0:	/* ABORT message */
2241 2242 2243 2244
			c->Request.CDBLen = 12;
			c->Request.Type.Attribute = ATTR_SIMPLE;
			c->Request.Type.Direction = XFER_WRITE;
			c->Request.Timeout = 0;
2245 2246
			c->Request.CDB[0] = cmd;	/* abort */
			c->Request.CDB[1] = 0;	/* abort a command */
2247 2248 2249
			/* buff contains the tag of the command to abort */
			memcpy(&c->Request.CDB[4], buff, 8);
			break;
2250
		case 1:	/* RESET message */
2251
			c->Request.CDBLen = 16;
2252
			c->Request.Type.Attribute = ATTR_SIMPLE;
2253
			c->Request.Type.Direction = XFER_NONE;
2254 2255
			c->Request.Timeout = 0;
			memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
2256
			c->Request.CDB[0] = cmd;	/* reset */
2257
			c->Request.CDB[1] = 0x03;	/* reset a target */
2258
			break;
L
Linus Torvalds 已提交
2259 2260 2261 2262 2263 2264 2265 2266 2267
		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
2268
			       "cciss%d: unknown message type %d\n", ctlr, cmd);
L
Linus Torvalds 已提交
2269 2270 2271 2272
			return IO_ERROR;
		}
	} else {
		printk(KERN_WARNING
2273
		       "cciss%d: unknown command type %d\n", ctlr, cmd_type);
L
Linus Torvalds 已提交
2274 2275 2276 2277 2278
		return IO_ERROR;
	}
	/* Fill in the scatter gather information */
	if (size > 0) {
		buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
2279 2280
							     buff, size,
							     PCI_DMA_BIDIRECTIONAL);
L
Linus Torvalds 已提交
2281 2282 2283
		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;
2284
		c->SG[0].Ext = 0;	/* we are not chaining */
L
Linus Torvalds 已提交
2285 2286 2287
	}
	return status;
}
2288

2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
static int check_target_status(ctlr_info_t *h, CommandList_struct *c)
{
	switch (c->err_info->ScsiStatus) {
	case SAM_STAT_GOOD:
		return IO_OK;
	case SAM_STAT_CHECK_CONDITION:
		switch (0xf & c->err_info->SenseInfo[2]) {
		case 0: return IO_OK; /* no sense */
		case 1: return IO_OK; /* recovered error */
		default:
			printk(KERN_WARNING "cciss%d: cmd 0x%02x "
				"check condition, sense key = 0x%02x\n",
				h->ctlr, c->Request.CDB[0],
				c->err_info->SenseInfo[2]);
		}
		break;
	default:
		printk(KERN_WARNING "cciss%d: cmd 0x%02x"
			"scsi status = 0x%02x\n", h->ctlr,
			c->Request.CDB[0], c->err_info->ScsiStatus);
		break;
	}
	return IO_ERROR;
}

2314
static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c)
L
Linus Torvalds 已提交
2315
{
2316
	int return_status = IO_OK;
2317

2318 2319
	if (c->err_info->CommandStatus == CMD_SUCCESS)
		return IO_OK;
2320 2321 2322

	switch (c->err_info->CommandStatus) {
	case CMD_TARGET_STATUS:
2323
		return_status = check_target_status(h, c);
2324 2325 2326 2327 2328 2329
		break;
	case CMD_DATA_UNDERRUN:
	case CMD_DATA_OVERRUN:
		/* expected for inquiry and report lun commands */
		break;
	case CMD_INVALID:
2330
		printk(KERN_WARNING "cciss: cmd 0x%02x is "
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
		       "reported invalid\n", c->Request.CDB[0]);
		return_status = IO_ERROR;
		break;
	case CMD_PROTOCOL_ERR:
		printk(KERN_WARNING "cciss: cmd 0x%02x has "
		       "protocol error \n", c->Request.CDB[0]);
		return_status = IO_ERROR;
		break;
	case CMD_HARDWARE_ERR:
		printk(KERN_WARNING "cciss: cmd 0x%02x had "
		       " hardware error\n", c->Request.CDB[0]);
		return_status = IO_ERROR;
		break;
	case CMD_CONNECTION_LOST:
		printk(KERN_WARNING "cciss: cmd 0x%02x had "
		       "connection lost\n", c->Request.CDB[0]);
		return_status = IO_ERROR;
		break;
	case CMD_ABORTED:
		printk(KERN_WARNING "cciss: cmd 0x%02x was "
		       "aborted\n", c->Request.CDB[0]);
		return_status = IO_ERROR;
		break;
	case CMD_ABORT_FAILED:
		printk(KERN_WARNING "cciss: cmd 0x%02x reports "
		       "abort failed\n", c->Request.CDB[0]);
		return_status = IO_ERROR;
		break;
	case CMD_UNSOLICITED_ABORT:
		printk(KERN_WARNING
		       "cciss%d: unsolicited abort 0x%02x\n", h->ctlr,
			c->Request.CDB[0]);
2363
		return_status = IO_NEEDS_RETRY;
2364 2365 2366 2367 2368 2369
		break;
	default:
		printk(KERN_WARNING "cciss: cmd 0x%02x returned "
		       "unknown status %x\n", c->Request.CDB[0],
		       c->err_info->CommandStatus);
		return_status = IO_ERROR;
2370
	}
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
	return return_status;
}

static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
	int attempt_retry)
{
	DECLARE_COMPLETION_ONSTACK(wait);
	u64bit buff_dma_handle;
	unsigned long flags;
	int return_status = IO_OK;

resend_cmd2:
	c->waiting = &wait;
	/* Put the request on the tail of the queue and send it */
	spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
	addQ(&h->reqQ, c);
	h->Qdepth++;
	start_io(h);
	spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);

	wait_for_completion(&wait);

	if (c->err_info->CommandStatus == 0 || !attempt_retry)
		goto command_done;

	return_status = process_sendcmd_error(h, c);

	if (return_status == IO_NEEDS_RETRY &&
		c->retry_count < MAX_CMD_RETRIES) {
		printk(KERN_WARNING "cciss%d: retrying 0x%02x\n", h->ctlr,
			c->Request.CDB[0]);
		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;
	}
2409 2410

command_done:
L
Linus Torvalds 已提交
2411
	/* unlock the buffers from DMA */
2412 2413
	buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
	buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2414 2415
	pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
			 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2416 2417 2418
	return return_status;
}

2419 2420 2421
static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
			   __u8 page_code, unsigned char scsi3addr[],
			int cmd_type)
2422 2423 2424 2425 2426 2427 2428 2429
{
	ctlr_info_t *h = hba[ctlr];
	CommandList_struct *c;
	int return_status;

	c = cmd_alloc(h, 0);
	if (!c)
		return -ENOMEM;
2430 2431
	return_status = fill_cmd(c, cmd, ctlr, buff, size, page_code,
		scsi3addr, cmd_type);
2432
	if (return_status == IO_OK)
2433 2434
		return_status = sendcmd_withirq_core(h, c, 1);

L
Linus Torvalds 已提交
2435
	cmd_free(h, c, 0);
2436
	return return_status;
L
Linus Torvalds 已提交
2437
}
2438

L
Linus Torvalds 已提交
2439
static void cciss_geometry_inquiry(int ctlr, int logvol,
2440
				   int withirq, sector_t total_size,
2441 2442 2443
				   unsigned int block_size,
				   InquiryData_struct *inq_buff,
				   drive_info_struct *drv)
L
Linus Torvalds 已提交
2444 2445
{
	int return_code;
2446
	unsigned long t;
2447
	unsigned char scsi3addr[8];
2448

L
Linus Torvalds 已提交
2449
	memset(inq_buff, 0, sizeof(InquiryData_struct));
2450
	log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
L
Linus Torvalds 已提交
2451 2452
	if (withirq)
		return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
2453 2454
					      inq_buff, sizeof(*inq_buff),
					      0xC1, scsi3addr, TYPE_CMD);
L
Linus Torvalds 已提交
2455 2456
	else
		return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
2457
				      sizeof(*inq_buff), 0xC1, scsi3addr,
2458
				      TYPE_CMD);
L
Linus Torvalds 已提交
2459
	if (return_code == IO_OK) {
2460
		if (inq_buff->data_byte[8] == 0xFF) {
L
Linus Torvalds 已提交
2461
			printk(KERN_WARNING
2462 2463
			       "cciss: reading geometry failed, volume "
			       "does not support reading geometry\n");
L
Linus Torvalds 已提交
2464
			drv->heads = 255;
2465
			drv->sectors = 32;	// Sectors per track
2466
			drv->cylinders = total_size + 1;
2467
			drv->raid_level = RAID_UNKNOWN;
L
Linus Torvalds 已提交
2468 2469 2470 2471 2472 2473
		} 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];
2474 2475
		}
		drv->block_size = block_size;
2476
		drv->nr_blocks = total_size + 1;
2477 2478
		t = drv->heads * drv->sectors;
		if (t > 1) {
2479 2480
			sector_t real_size = total_size + 1;
			unsigned long rem = sector_div(real_size, t);
2481
			if (rem)
2482 2483
				real_size++;
			drv->cylinders = real_size;
L
Linus Torvalds 已提交
2484
		}
2485
	} else {		/* Get geometry failed */
L
Linus Torvalds 已提交
2486 2487
		printk(KERN_WARNING "cciss: reading geometry failed\n");
	}
2488
	printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
2489
	       drv->heads, drv->sectors, drv->cylinders);
L
Linus Torvalds 已提交
2490
}
2491

L
Linus Torvalds 已提交
2492
static void
2493
cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
2494
		    unsigned int *block_size)
L
Linus Torvalds 已提交
2495
{
2496
	ReadCapdata_struct *buf;
L
Linus Torvalds 已提交
2497
	int return_code;
2498
	unsigned char scsi3addr[8];
2499 2500 2501

	buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
	if (!buf) {
2502 2503 2504
		printk(KERN_WARNING "cciss: out of memory\n");
		return;
	}
2505

2506
	log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
L
Linus Torvalds 已提交
2507 2508
	if (withirq)
		return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
2509
				ctlr, buf, sizeof(ReadCapdata_struct),
2510
					0, scsi3addr, TYPE_CMD);
L
Linus Torvalds 已提交
2511 2512
	else
		return_code = sendcmd(CCISS_READ_CAPACITY,
2513
				ctlr, buf, sizeof(ReadCapdata_struct),
2514
					0, scsi3addr, TYPE_CMD);
L
Linus Torvalds 已提交
2515
	if (return_code == IO_OK) {
A
Al Viro 已提交
2516 2517
		*total_size = be32_to_cpu(*(__be32 *) buf->total_size);
		*block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2518
	} else {		/* read capacity command failed */
L
Linus Torvalds 已提交
2519 2520 2521 2522
		printk(KERN_WARNING "cciss: read capacity failed\n");
		*total_size = 0;
		*block_size = BLOCK_SIZE;
	}
2523
	if (*total_size != 0)
2524
		printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2525
		(unsigned long long)*total_size+1, *block_size);
2526 2527 2528 2529 2530 2531 2532 2533
	kfree(buf);
}

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;
2534
	unsigned char scsi3addr[8];
2535 2536 2537

	buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
	if (!buf) {
2538 2539 2540
		printk(KERN_WARNING "cciss: out of memory\n");
		return;
	}
2541

2542
	log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
2543 2544 2545
	if (withirq) {
		return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
			ctlr, buf, sizeof(ReadCapdata_struct_16),
2546
				0, scsi3addr, TYPE_CMD);
2547 2548 2549 2550
	}
	else {
		return_code = sendcmd(CCISS_READ_CAPACITY_16,
			ctlr, buf, sizeof(ReadCapdata_struct_16),
2551
				0, scsi3addr, TYPE_CMD);
2552 2553
	}
	if (return_code == IO_OK) {
A
Al Viro 已提交
2554 2555
		*total_size = be64_to_cpu(*(__be64 *) buf->total_size);
		*block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2556 2557 2558 2559 2560
	} else {		/* read capacity command failed */
		printk(KERN_WARNING "cciss: read capacity failed\n");
		*total_size = 0;
		*block_size = BLOCK_SIZE;
	}
2561
	printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2562
	       (unsigned long long)*total_size+1, *block_size);
2563
	kfree(buf);
L
Linus Torvalds 已提交
2564 2565 2566 2567 2568 2569 2570
}

static int cciss_revalidate(struct gendisk *disk)
{
	ctlr_info_t *h = get_host(disk);
	drive_info_struct *drv = get_drv(disk);
	int logvol;
2571
	int FOUND = 0;
L
Linus Torvalds 已提交
2572
	unsigned int block_size;
2573
	sector_t total_size;
L
Linus Torvalds 已提交
2574 2575
	InquiryData_struct *inq_buff = NULL;

2576 2577 2578
	for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
		if (h->drv[logvol].LunID == drv->LunID) {
			FOUND = 1;
L
Linus Torvalds 已提交
2579 2580 2581 2582
			break;
		}
	}

2583 2584
	if (!FOUND)
		return 1;
L
Linus Torvalds 已提交
2585

2586 2587 2588 2589 2590
	inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
	if (inq_buff == NULL) {
		printk(KERN_WARNING "cciss: out of memory\n");
		return 1;
	}
2591 2592 2593 2594 2595 2596 2597
	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);
	}
2598 2599
	cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
			       inq_buff, drv);
L
Linus Torvalds 已提交
2600

2601
	blk_queue_logical_block_size(drv->queue, drv->block_size);
L
Linus Torvalds 已提交
2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
	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]);
2622 2623 2624
		if (done == FIFO_EMPTY)
			schedule_timeout_uninterruptible(1);
		else
2625
			return done;
L
Linus Torvalds 已提交
2626 2627 2628 2629
	}
	/* Invalid address to tell caller we ran out of time */
	return 1;
}
2630

2631 2632 2633
/* Send command c to controller h and poll for it to complete.
 * Turns interrupts off on the board.  Used at driver init time
 * and during SCSI error recovery.
L
Linus Torvalds 已提交
2634
 */
2635
static int sendcmd_core(ctlr_info_t *h, CommandList_struct *c)
L
Linus Torvalds 已提交
2636 2637 2638
{
	int i;
	unsigned long complete;
2639
	int status = IO_ERROR;
L
Linus Torvalds 已提交
2640 2641
	u64bit buff_dma_handle;

2642 2643 2644 2645
resend_cmd1:

	/* Disable interrupt on the board. */
	h->access.set_intr_mask(h, CCISS_INTR_OFF);
2646

L
Linus Torvalds 已提交
2647
	/* Make sure there is room in the command FIFO */
2648
	/* Actually it should be completely empty at this time */
2649 2650
	/* unless we are in here doing error handling for the scsi */
	/* tape side of the driver. */
2651
	for (i = 200000; i > 0; i--) {
L
Linus Torvalds 已提交
2652
		/* if fifo isn't full go */
2653
		if (!(h->access.fifo_full(h)))
2654 2655 2656
			break;
		udelay(10);
		printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2657
		       " waiting!\n", h->ctlr);
2658
	}
2659
	h->access.submit_command(h, c); /* Send the cmd */
2660
	do {
2661
		complete = pollcomplete(h->ctlr);
L
Linus Torvalds 已提交
2662 2663

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

2667
		if (complete == 1) {
2668 2669
			printk(KERN_WARNING
			       "cciss cciss%d: SendCmd Timeout out, "
2670
			       "No command list address returned!\n", h->ctlr);
2671 2672 2673 2674
			status = IO_ERROR;
			break;
		}

2675
		/* Make sure it's the command we're expecting. */
2676
		if ((complete & ~CISS_ERROR_BIT) != c->busaddr) {
2677 2678
			printk(KERN_WARNING "cciss%d: Unexpected command "
				"completion.\n", h->ctlr);
2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698
			continue;
		}

		/* It is our command.  If no error, we're done. */
		if (!(complete & CISS_ERROR_BIT)) {
			status = IO_OK;
			break;
		}

		/* There is an error... */

		/* if data overrun or underun on Report command ignore it */
		if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
		     (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
		     (c->Request.CDB[0] == CISS_INQUIRY)) &&
			((c->err_info->CommandStatus == CMD_DATA_OVERRUN) ||
			 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN))) {
			complete = c->busaddr;
			status = IO_OK;
			break;
L
Linus Torvalds 已提交
2699
		}
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710

		if (c->err_info->CommandStatus == CMD_UNSOLICITED_ABORT) {
			printk(KERN_WARNING "cciss%d: unsolicited abort %p\n",
				h->ctlr, c);
			if (c->retry_count < MAX_CMD_RETRIES) {
				printk(KERN_WARNING "cciss%d: retrying %p\n",
				   h->ctlr, c);
				c->retry_count++;
				/* erase the old error information */
				memset(c->err_info, 0, sizeof(c->err_info));
				goto resend_cmd1;
2711
			}
2712 2713 2714
			printk(KERN_WARNING "cciss%d: retried %p too many "
				"times\n", h->ctlr, c);
			status = IO_ERROR;
2715
			break;
2716 2717 2718 2719 2720 2721
		}

		if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
			printk(KERN_WARNING "cciss%d: command could not be "
				"aborted.\n", h->ctlr);
			status = IO_ERROR;
2722
			break;
2723 2724 2725
		}

		if (c->err_info->CommandStatus == CMD_TARGET_STATUS) {
2726 2727
			status = check_target_status(h, c);
			break;
2728 2729
		}

2730 2731 2732
		printk(KERN_WARNING "cciss%d: sendcmd error\n", h->ctlr);
		printk(KERN_WARNING "cmd = 0x%02x, CommandStatus = 0x%02x\n",
			c->Request.CDB[0], c->err_info->CommandStatus);
2733
		status = IO_ERROR;
2734
		break;
2735 2736

	} while (1);
2737

L
Linus Torvalds 已提交
2738
	/* unlock the data buffer from DMA */
2739 2740
	buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
	buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2741
	pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
2742
			 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760
	return status;
}

/*
 * Send a command to the controller, and wait for it to complete.
 * Used at init time, and during SCSI error recovery.
 */
static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
	__u8 page_code, unsigned char *scsi3addr, int cmd_type)
{
	CommandList_struct *c;
	int status;

	c = cmd_alloc(hba[ctlr], 1);
	if (!c) {
		printk(KERN_WARNING "cciss: unable to get memory");
		return IO_ERROR;
	}
2761 2762
	status = fill_cmd(c, cmd, ctlr, buff, size, page_code,
		scsi3addr, cmd_type);
2763 2764 2765
	if (status == IO_OK)
		status = sendcmd_core(hba[ctlr], c);
	cmd_free(hba[ctlr], c, 1);
2766
	return status;
2767 2768
}

L
Linus Torvalds 已提交
2769 2770 2771 2772 2773
/*
 * Map (physical) PCI mem into (virtual) kernel space
 */
static void __iomem *remap_pci_mem(ulong base, ulong size)
{
2774 2775 2776
	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 已提交
2777

2778
	return page_remapped ? (page_remapped + page_offs) : NULL;
L
Linus Torvalds 已提交
2779 2780
}

2781 2782 2783 2784 2785
/*
 * 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 已提交
2786 2787
{
	CommandList_struct *c;
2788

2789 2790
	while (!hlist_empty(&h->reqQ)) {
		c = hlist_entry(h->reqQ.first, CommandList_struct, list);
L
Linus Torvalds 已提交
2791 2792 2793 2794 2795 2796
		/* can't do anything if fifo is full */
		if ((h->access.fifo_full(h))) {
			printk(KERN_WARNING "cciss: fifo full\n");
			break;
		}

2797
		/* Get the first entry from the Request Q */
2798
		removeQ(c);
L
Linus Torvalds 已提交
2799
		h->Qdepth--;
2800 2801

		/* Tell the controller execute command */
L
Linus Torvalds 已提交
2802
		h->access.submit_command(h, c);
2803 2804

		/* Put job onto the completed Q */
2805
		addQ(&h->cmpQ, c);
L
Linus Torvalds 已提交
2806 2807
	}
}
2808

L
Linus Torvalds 已提交
2809 2810 2811
/* Assumes that CCISS_LOCK(h->ctlr) is held. */
/* Zeros out the error record and then resends the command back */
/* to the controller */
2812
static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
L
Linus Torvalds 已提交
2813 2814 2815 2816 2817
{
	/* 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 */
2818
	addQ(&h->reqQ, c);
L
Linus Torvalds 已提交
2819
	h->Qdepth++;
2820
	if (h->Qdepth > h->maxQsinceinit)
L
Linus Torvalds 已提交
2821 2822 2823 2824
		h->maxQsinceinit = h->Qdepth;

	start_io(h);
}
2825

2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
static inline unsigned int make_status_bytes(unsigned int scsi_status_byte,
	unsigned int msg_byte, unsigned int host_byte,
	unsigned int driver_byte)
{
	/* inverse of macros in scsi.h */
	return (scsi_status_byte & 0xff) |
		((msg_byte & 0xff) << 8) |
		((host_byte & 0xff) << 16) |
		((driver_byte & 0xff) << 24);
}

2837 2838
static inline int evaluate_target_status(ctlr_info_t *h,
			CommandList_struct *cmd, int *retry_cmd)
2839 2840
{
	unsigned char sense_key;
2841 2842 2843
	unsigned char status_byte, msg_byte, host_byte, driver_byte;
	int error_value;

2844
	*retry_cmd = 0;
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856
	/* If we get in here, it means we got "target status", that is, scsi status */
	status_byte = cmd->err_info->ScsiStatus;
	driver_byte = DRIVER_OK;
	msg_byte = cmd->err_info->CommandStatus; /* correct?  seems too device specific */

	if (blk_pc_request(cmd->rq))
		host_byte = DID_PASSTHROUGH;
	else
		host_byte = DID_OK;

	error_value = make_status_bytes(status_byte, msg_byte,
		host_byte, driver_byte);
2857

2858
	if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
2859 2860 2861 2862
		if (!blk_pc_request(cmd->rq))
			printk(KERN_WARNING "cciss: cmd %p "
			       "has SCSI Status 0x%x\n",
			       cmd, cmd->err_info->ScsiStatus);
2863
		return error_value;
2864 2865 2866 2867 2868
	}

	/* check the sense key */
	sense_key = 0xf & cmd->err_info->SenseInfo[2];
	/* no status or recovered error */
2869 2870
	if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
		error_value = 0;
2871

2872 2873 2874 2875 2876
	if (check_for_unit_attention(h, cmd)) {
		*retry_cmd = !blk_pc_request(cmd->rq);
		return 0;
	}

2877
	if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
2878
		if (error_value != 0)
2879 2880
			printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
			       " sense key = 0x%x\n", cmd, sense_key);
2881
		return error_value;
2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892
	}

	/* 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;

2893
	return error_value;
2894 2895
}

2896
/* checks the status of the job and calls complete buffers to mark all
2897 2898
 * buffers for the completed job. Note that this function does not need
 * to hold the hba/queue lock.
2899 2900 2901
 */
static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
				    int timeout)
L
Linus Torvalds 已提交
2902 2903
{
	int retry_cmd = 0;
2904 2905 2906
	struct request *rq = cmd->rq;

	rq->errors = 0;
2907

L
Linus Torvalds 已提交
2908
	if (timeout)
2909
		rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT);
L
Linus Torvalds 已提交
2910

2911 2912
	if (cmd->err_info->CommandStatus == 0)	/* no error has occurred */
		goto after_error_processing;
2913

2914 2915
	switch (cmd->err_info->CommandStatus) {
	case CMD_TARGET_STATUS:
2916
		rq->errors = evaluate_target_status(h, cmd, &retry_cmd);
2917 2918
		break;
	case CMD_DATA_UNDERRUN:
2919 2920 2921 2922
		if (blk_fs_request(cmd->rq)) {
			printk(KERN_WARNING "cciss: cmd %p has"
			       " completed with data underrun "
			       "reported\n", cmd);
T
Tejun Heo 已提交
2923
			cmd->rq->resid_len = cmd->err_info->ResidualCnt;
2924
		}
2925 2926
		break;
	case CMD_DATA_OVERRUN:
2927 2928 2929 2930
		if (blk_fs_request(cmd->rq))
			printk(KERN_WARNING "cciss: cmd %p has"
			       " completed with data overrun "
			       "reported\n", cmd);
2931 2932 2933 2934
		break;
	case CMD_INVALID:
		printk(KERN_WARNING "cciss: cmd %p is "
		       "reported invalid\n", cmd);
2935 2936 2937
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2938 2939 2940 2941
		break;
	case CMD_PROTOCOL_ERR:
		printk(KERN_WARNING "cciss: cmd %p has "
		       "protocol error \n", cmd);
2942 2943 2944
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2945 2946 2947 2948
		break;
	case CMD_HARDWARE_ERR:
		printk(KERN_WARNING "cciss: cmd %p had "
		       " hardware error\n", cmd);
2949 2950 2951
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2952 2953 2954 2955
		break;
	case CMD_CONNECTION_LOST:
		printk(KERN_WARNING "cciss: cmd %p had "
		       "connection lost\n", cmd);
2956 2957 2958
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2959 2960 2961 2962
		break;
	case CMD_ABORTED:
		printk(KERN_WARNING "cciss: cmd %p was "
		       "aborted\n", cmd);
2963 2964 2965
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2966 2967 2968 2969
		break;
	case CMD_ABORT_FAILED:
		printk(KERN_WARNING "cciss: cmd %p reports "
		       "abort failed\n", cmd);
2970 2971 2972
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985
		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);
2986 2987 2988
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2989 2990 2991
		break;
	case CMD_TIMEOUT:
		printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2992 2993 2994
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2995 2996 2997 2998 2999
		break;
	default:
		printk(KERN_WARNING "cciss: cmd %p returned "
		       "unknown status %x\n", cmd,
		       cmd->err_info->CommandStatus);
3000 3001 3002
		rq->errors = make_status_bytes(SAM_STAT_GOOD,
			cmd->err_info->CommandStatus, DRIVER_OK,
			blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
L
Linus Torvalds 已提交
3003
	}
3004 3005 3006

after_error_processing:

L
Linus Torvalds 已提交
3007
	/* We need to return this command */
3008 3009
	if (retry_cmd) {
		resend_cciss_cmd(h, cmd);
L
Linus Torvalds 已提交
3010
		return;
3011
	}
3012
	cmd->rq->completion_data = cmd;
3013
	blk_complete_request(cmd->rq);
L
Linus Torvalds 已提交
3014 3015
}

3016 3017
/*
 * Get a request and submit it to the controller.
L
Linus Torvalds 已提交
3018
 */
3019
static void do_cciss_request(struct request_queue *q)
L
Linus Torvalds 已提交
3020
{
3021
	ctlr_info_t *h = q->queuedata;
L
Linus Torvalds 已提交
3022
	CommandList_struct *c;
3023 3024
	sector_t start_blk;
	int seg;
L
Linus Torvalds 已提交
3025 3026 3027 3028 3029 3030 3031 3032
	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.
3033
	 */
L
Linus Torvalds 已提交
3034 3035 3036
	if (blk_queue_plugged(q))
		goto startio;

3037
      queue:
3038
	creq = blk_peek_request(q);
L
Linus Torvalds 已提交
3039 3040 3041
	if (!creq)
		goto startio;

3042
	BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
L
Linus Torvalds 已提交
3043

3044
	if ((c = cmd_alloc(h, 1)) == NULL)
L
Linus Torvalds 已提交
3045 3046
		goto full;

3047
	blk_start_request(creq);
L
Linus Torvalds 已提交
3048 3049 3050 3051 3052

	spin_unlock_irq(q->queue_lock);

	c->cmd_type = CMD_RWREQ;
	c->rq = creq;
3053 3054

	/* fill in the request */
L
Linus Torvalds 已提交
3055
	drv = creq->rq_disk->private_data;
3056
	c->Header.ReplyQueue = 0;	// unused in simple mode
3057 3058 3059 3060
	/* 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);
3061 3062
	c->Header.Tag.lower |= 0x04;	/* flag for direct lookup. */
	c->Header.LUN.LogDev.VolId = drv->LunID;
L
Linus Torvalds 已提交
3063
	c->Header.LUN.LogDev.Mode = 1;
3064 3065 3066 3067
	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 =
3068
	    (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
3069 3070
	c->Request.Timeout = 0;	// Don't time out
	c->Request.CDB[0] =
3071
	    (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
3072
	start_blk = blk_rq_pos(creq);
L
Linus Torvalds 已提交
3073
#ifdef CCISS_DEBUG
3074 3075
	printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",
	       (int)blk_rq_pos(creq), (int)blk_rq_sectors(creq));
3076
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3077

J
Jens Axboe 已提交
3078
	sg_init_table(tmp_sg, MAXSGENTRIES);
L
Linus Torvalds 已提交
3079 3080
	seg = blk_rq_map_sg(q, creq, tmp_sg);

3081
	/* get the DMA records for the setup */
L
Linus Torvalds 已提交
3082 3083 3084 3085 3086
	if (c->Request.Type.Direction == XFER_READ)
		dir = PCI_DMA_FROMDEVICE;
	else
		dir = PCI_DMA_TODEVICE;

3087
	for (i = 0; i < seg; i++) {
L
Linus Torvalds 已提交
3088
		c->SG[i].Len = tmp_sg[i].length;
J
Jens Axboe 已提交
3089
		temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]),
3090 3091
						  tmp_sg[i].offset,
						  tmp_sg[i].length, dir);
L
Linus Torvalds 已提交
3092
		c->SG[i].Addr.lower = temp64.val32.lower;
3093 3094
		c->SG[i].Addr.upper = temp64.val32.upper;
		c->SG[i].Ext = 0;	// we are not chaining
L
Linus Torvalds 已提交
3095
	}
3096 3097 3098
	/* track how many SG entries we are using */
	if (seg > h->maxSG)
		h->maxSG = seg;
L
Linus Torvalds 已提交
3099 3100

#ifdef CCISS_DEBUG
3101 3102
	printk(KERN_DEBUG "cciss: Submitting %u sectors in %d segments\n",
	       blk_rq_sectors(creq), seg);
3103
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3104 3105

	c->Header.SGList = c->Header.SGTotal = seg;
3106 3107 3108 3109 3110 3111 3112 3113
	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
3114 3115
			c->Request.CDB[7] = (blk_rq_sectors(creq) >> 8) & 0xff;
			c->Request.CDB[8] = blk_rq_sectors(creq) & 0xff;
3116 3117
			c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
		} else {
3118 3119
			u32 upper32 = upper_32_bits(start_blk);

3120 3121
			c->Request.CDBLen = 16;
			c->Request.CDB[1]= 0;
3122 3123 3124 3125
			c->Request.CDB[2]= (upper32 >> 24) & 0xff;	//MSB
			c->Request.CDB[3]= (upper32 >> 16) & 0xff;
			c->Request.CDB[4]= (upper32 >>  8) & 0xff;
			c->Request.CDB[5]= upper32 & 0xff;
3126 3127 3128 3129
			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;
3130 3131 3132 3133
			c->Request.CDB[10]= (blk_rq_sectors(creq) >> 24) & 0xff;
			c->Request.CDB[11]= (blk_rq_sectors(creq) >> 16) & 0xff;
			c->Request.CDB[12]= (blk_rq_sectors(creq) >>  8) & 0xff;
			c->Request.CDB[13]= blk_rq_sectors(creq) & 0xff;
3134 3135 3136 3137 3138
			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);
3139
	} else {
3140 3141
		printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
		BUG();
3142
	}
L
Linus Torvalds 已提交
3143 3144 3145

	spin_lock_irq(q->queue_lock);

3146
	addQ(&h->reqQ, c);
L
Linus Torvalds 已提交
3147
	h->Qdepth++;
3148 3149
	if (h->Qdepth > h->maxQsinceinit)
		h->maxQsinceinit = h->Qdepth;
L
Linus Torvalds 已提交
3150 3151

	goto queue;
3152
full:
L
Linus Torvalds 已提交
3153
	blk_stop_queue(q);
3154
startio:
L
Linus Torvalds 已提交
3155 3156
	/* We will already have the driver lock here so not need
	 * to lock it.
3157
	 */
L
Linus Torvalds 已提交
3158 3159 3160
	start_io(h);
}

3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172
static inline unsigned long get_next_completion(ctlr_info_t *h)
{
	return h->access.command_completed(h);
}

static inline int interrupt_pending(ctlr_info_t *h)
{
	return h->access.intr_pending(h);
}

static inline long interrupt_not_for_us(ctlr_info_t *h)
{
3173
	return (((h->access.intr_pending(h) == 0) ||
3174 3175 3176
		 (h->interrupts_enabled == 0)));
}

3177
static irqreturn_t do_cciss_intr(int irq, void *dev_id)
L
Linus Torvalds 已提交
3178 3179 3180 3181
{
	ctlr_info_t *h = dev_id;
	CommandList_struct *c;
	unsigned long flags;
3182
	__u32 a, a1, a2;
L
Linus Torvalds 已提交
3183

3184
	if (interrupt_not_for_us(h))
L
Linus Torvalds 已提交
3185 3186 3187 3188 3189 3190
		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);
3191
	while (interrupt_pending(h)) {
3192
		while ((a = get_next_completion(h)) != FIFO_EMPTY) {
L
Linus Torvalds 已提交
3193
			a1 = a;
3194 3195
			if ((a & 0x04)) {
				a2 = (a >> 3);
3196
				if (a2 >= h->nr_cmds) {
3197 3198 3199
					printk(KERN_WARNING
					       "cciss: controller cciss%d failed, stopping.\n",
					       h->ctlr);
3200 3201 3202 3203 3204 3205 3206 3207
					fail_all_cmds(h->ctlr);
					return IRQ_HANDLED;
				}

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

			} else {
3208 3209
				struct hlist_node *tmp;

3210
				a &= ~3;
3211 3212 3213
				c = NULL;
				hlist_for_each_entry(c, tmp, &h->cmpQ, list) {
					if (c->busaddr == a)
3214 3215
						break;
				}
3216
			}
L
Linus Torvalds 已提交
3217 3218 3219 3220
			/*
			 * If we've found the command, take it off the
			 * completion Q and free it
			 */
3221 3222
			if (c && c->busaddr == a) {
				removeQ(c);
L
Linus Torvalds 已提交
3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
				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;
}
3240

3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
/**
 * add_to_scan_list() - add controller to rescan queue
 * @h:		      Pointer to the controller.
 *
 * Adds the controller to the rescan queue if not already on the queue.
 *
 * returns 1 if added to the queue, 0 if skipped (could be on the
 * queue already, or the controller could be initializing or shutting
 * down).
 **/
static int add_to_scan_list(struct ctlr_info *h)
{
	struct ctlr_info *test_h;
	int found = 0;
	int ret = 0;

	if (h->busy_initializing)
		return 0;

	if (!mutex_trylock(&h->busy_shutting_down))
		return 0;

	mutex_lock(&scan_mutex);
	list_for_each_entry(test_h, &scan_q, scan_list) {
		if (test_h == h) {
			found = 1;
			break;
		}
	}
	if (!found && !h->busy_scanning) {
		INIT_COMPLETION(h->scan_wait);
		list_add_tail(&h->scan_list, &scan_q);
		ret = 1;
	}
	mutex_unlock(&scan_mutex);
	mutex_unlock(&h->busy_shutting_down);

	return ret;
}

/**
 * remove_from_scan_list() - remove controller from rescan queue
 * @h:			   Pointer to the controller.
 *
 * Removes the controller from the rescan queue if present. Blocks if
 * the controller is currently conducting a rescan.
 **/
static void remove_from_scan_list(struct ctlr_info *h)
{
	struct ctlr_info *test_h, *tmp_h;
	int scanning = 0;

	mutex_lock(&scan_mutex);
	list_for_each_entry_safe(test_h, tmp_h, &scan_q, scan_list) {
		if (test_h == h) {
			list_del(&h->scan_list);
			complete_all(&h->scan_wait);
			mutex_unlock(&scan_mutex);
			return;
		}
	}
	if (&h->busy_scanning)
		scanning = 0;
	mutex_unlock(&scan_mutex);

	if (scanning)
		wait_for_completion(&h->scan_wait);
}

/**
 * scan_thread() - kernel thread used to rescan controllers
 * @data:	 Ignored.
 *
 * A kernel thread used scan for drive topology changes on
 * controllers. The thread processes only one controller at a time
 * using a queue.  Controllers are added to the queue using
 * add_to_scan_list() and removed from the queue either after done
 * processing or using remove_from_scan_list().
 *
 * returns 0.
 **/
3322 3323
static int scan_thread(void *data)
{
3324
	struct ctlr_info *h;
3325

3326 3327 3328
	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);
		schedule();
3329 3330
		if (kthread_should_stop())
			break;
3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353

		while (1) {
			mutex_lock(&scan_mutex);
			if (list_empty(&scan_q)) {
				mutex_unlock(&scan_mutex);
				break;
			}

			h = list_entry(scan_q.next,
				       struct ctlr_info,
				       scan_list);
			list_del(&h->scan_list);
			h->busy_scanning = 1;
			mutex_unlock(&scan_mutex);

			if (h) {
				rebuild_lun_table(h, 0);
				complete_all(&h->scan_wait);
				mutex_lock(&scan_mutex);
				h->busy_scanning = 0;
				mutex_unlock(&scan_mutex);
			}
		}
3354
	}
3355

3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377
	return 0;
}

static int check_for_unit_attention(ctlr_info_t *h, CommandList_struct *c)
{
	if (c->err_info->SenseInfo[2] != UNIT_ATTENTION)
		return 0;

	switch (c->err_info->SenseInfo[12]) {
	case STATE_CHANGED:
		printk(KERN_WARNING "cciss%d: a state change "
			"detected, command retried\n", h->ctlr);
		return 1;
	break;
	case LUN_FAILED:
		printk(KERN_WARNING "cciss%d: LUN failure "
			"detected, action required\n", h->ctlr);
		return 1;
	break;
	case REPORT_LUNS_CHANGED:
		printk(KERN_WARNING "cciss%d: report LUN data "
			"changed\n", h->ctlr);
3378 3379
		add_to_scan_list(h);
		wake_up_process(cciss_scan_thread);
3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
		return 1;
	break;
	case POWER_OR_RESET:
		printk(KERN_WARNING "cciss%d: a power on "
			"or device reset detected\n", h->ctlr);
		return 1;
	break;
	case UNIT_ATTENTION_CLEARED:
		printk(KERN_WARNING "cciss%d: unit attention "
		    "cleared by another initiator\n", h->ctlr);
		return 1;
	break;
	default:
		printk(KERN_WARNING "cciss%d: unknown "
			"unit attention detected\n", h->ctlr);
				return 1;
	}
}

3399
/*
3400
 *  We cannot read the structure directly, for portability we must use
L
Linus Torvalds 已提交
3401
 *   the io functions.
3402
 *   This is for debug only.
L
Linus Torvalds 已提交
3403 3404
 */
#ifdef CCISS_DEBUG
3405
static void print_cfg_table(CfgTable_struct *tb)
L
Linus Torvalds 已提交
3406 3407 3408 3409 3410 3411
{
	int i;
	char temp_name[17];

	printk("Controller Configuration information\n");
	printk("------------------------------------\n");
3412
	for (i = 0; i < 4; i++)
L
Linus Torvalds 已提交
3413
		temp_name[i] = readb(&(tb->Signature[i]));
3414 3415
	temp_name[4] = '\0';
	printk("   Signature = %s\n", temp_name);
L
Linus Torvalds 已提交
3416
	printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
3417 3418 3419 3420 3421 3422
	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)));
3423
	printk("   Coalesce Interrupt Delay = 0x%x\n",
3424
	       readl(&(tb->HostWrite.CoalIntDelay)));
3425
	printk("   Coalesce Interrupt Count = 0x%x\n",
3426 3427 3428 3429 3430
	       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 已提交
3431 3432 3433
		temp_name[i] = readb(&(tb->ServerName[i]));
	temp_name[16] = '\0';
	printk("   Server Name = %s\n", temp_name);
3434
	printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
L
Linus Torvalds 已提交
3435
}
3436
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3437

3438
static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
L
Linus Torvalds 已提交
3439 3440
{
	int i, offset, mem_type, bar_type;
3441
	if (pci_bar_addr == PCI_BASE_ADDRESS_0)	/* looking for BAR zero? */
L
Linus Torvalds 已提交
3442 3443
		return 0;
	offset = 0;
3444 3445
	for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
		bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
L
Linus Torvalds 已提交
3446 3447 3448 3449
		if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
			offset += 4;
		else {
			mem_type = pci_resource_flags(pdev, i) &
3450
			    PCI_BASE_ADDRESS_MEM_TYPE_MASK;
L
Linus Torvalds 已提交
3451
			switch (mem_type) {
3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462
			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 已提交
3463 3464 3465
				break;
			}
		}
3466 3467
		if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
			return i + 1;
L
Linus Torvalds 已提交
3468 3469 3470 3471
	}
	return -1;
}

3472 3473 3474 3475
/* 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.
 */

3476 3477
static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
					   struct pci_dev *pdev, __u32 board_id)
3478 3479
{
#ifdef CONFIG_PCI_MSI
3480 3481 3482 3483
	int err;
	struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
	{0, 2}, {0, 3}
	};
3484 3485 3486

	/* Some boards advertise MSI but don't really support it */
	if ((board_id == 0x40700E11) ||
3487 3488
	    (board_id == 0x40800E11) ||
	    (board_id == 0x40820E11) || (board_id == 0x40830E11))
3489 3490
		goto default_int_mode;

3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503
	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);
3504
			goto default_int_mode;
3505 3506 3507
		} else {
			printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
			       err);
3508
			goto default_int_mode;
3509 3510 3511 3512 3513 3514 3515 3516 3517
		}
	}
	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");
		}
	}
3518
default_int_mode:
3519
#endif				/* CONFIG_PCI_MSI */
3520
	/* if we get here we're going to use the default interrupt mode */
3521
	c->intr[SIMPLE_MODE_INT] = pdev->irq;
3522 3523 3524
	return;
}

R
Randy Dunlap 已提交
3525
static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
L
Linus Torvalds 已提交
3526 3527 3528 3529 3530 3531
{
	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;
3532
	int i, err;
L
Linus Torvalds 已提交
3533 3534 3535

	/* check to see if controller has been disabled */
	/* BEFORE trying to enable it */
3536 3537 3538 3539
	(void)pci_read_config_word(pdev, PCI_COMMAND, &command);
	if (!(command & 0x02)) {
		printk(KERN_WARNING
		       "cciss: controller appears to be disabled\n");
3540
		return -ENODEV;
L
Linus Torvalds 已提交
3541 3542
	}

3543
	err = pci_enable_device(pdev);
3544
	if (err) {
L
Linus Torvalds 已提交
3545
		printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
3546
		return err;
L
Linus Torvalds 已提交
3547 3548
	}

3549 3550 3551
	err = pci_request_regions(pdev, "cciss");
	if (err) {
		printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
3552
		       "aborting\n");
3553
		return err;
3554 3555
	}

L
Linus Torvalds 已提交
3556 3557 3558
	subsystem_vendor_id = pdev->subsystem_vendor;
	subsystem_device_id = pdev->subsystem_device;
	board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
3559
		    subsystem_vendor_id);
L
Linus Torvalds 已提交
3560 3561 3562 3563 3564

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

3567 3568 3569 3570
/* 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 已提交
3571

3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585
	/* find the memory BAR */
	for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
		if (pci_resource_flags(pdev, i) & IORESOURCE_MEM)
			break;
	}
	if (i == DEVICE_COUNT_RESOURCE) {
		printk(KERN_WARNING "cciss: No memory BAR found\n");
		err = -ENODEV;
		goto err_out_free_res;
	}

	c->paddr = pci_resource_start(pdev, i); /* addressing mode bits
						 * already removed
						 */
L
Linus Torvalds 已提交
3586 3587

#ifdef CCISS_DEBUG
R
Randy Dunlap 已提交
3588
	printk("address 0 = %lx\n", c->paddr);
3589
#endif				/* CCISS_DEBUG */
3590
	c->vaddr = remap_pci_mem(c->paddr, 0x250);
L
Linus Torvalds 已提交
3591 3592 3593

	/* Wait for the board to become ready.  (PCI hotplug needs this.)
	 * We poll for up to 120 secs, once per 100ms. */
3594
	for (i = 0; i < 1200; i++) {
L
Linus Torvalds 已提交
3595 3596 3597 3598
		scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
		if (scratchpad == CCISS_FIRMWARE_READY)
			break;
		set_current_state(TASK_INTERRUPTIBLE);
3599
		schedule_timeout(msecs_to_jiffies(100));	/* wait 100ms */
L
Linus Torvalds 已提交
3600 3601 3602
	}
	if (scratchpad != CCISS_FIRMWARE_READY) {
		printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
3603
		err = -ENODEV;
3604
		goto err_out_free_res;
L
Linus Torvalds 已提交
3605 3606 3607 3608 3609 3610 3611
	}

	/* 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);
3612 3613
#endif				/* CCISS_DEBUG */
	cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
L
Linus Torvalds 已提交
3614
#ifdef CCISS_DEBUG
R
Randy Dunlap 已提交
3615 3616
	printk("cfg base address index = %llx\n",
		(unsigned long long)cfg_base_addr_index);
3617
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3618 3619
	if (cfg_base_addr_index == -1) {
		printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
3620
		err = -ENODEV;
3621
		goto err_out_free_res;
L
Linus Torvalds 已提交
3622 3623 3624 3625
	}

	cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
#ifdef CCISS_DEBUG
R
Randy Dunlap 已提交
3626
	printk("cfg offset = %llx\n", (unsigned long long)cfg_offset);
3627 3628 3629 3630
#endif				/* CCISS_DEBUG */
	c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
						       cfg_base_addr_index) +
				    cfg_offset, sizeof(CfgTable_struct));
L
Linus Torvalds 已提交
3631 3632 3633
	c->board_id = board_id;

#ifdef CCISS_DEBUG
3634
	print_cfg_table(c->cfgtable);
3635
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3636

3637 3638 3639 3640 3641 3642 3643 3644 3645
	/* Some controllers support Zero Memory Raid (ZMR).
	 * When configured in ZMR mode the number of supported
	 * commands drops to 64. So instead of just setting an
	 * arbitrary value we make the driver a little smarter.
	 * We read the config table to tell us how many commands
	 * are supported on the controller then subtract 4 to
	 * leave a little room for ioctl calls.
	 */
	c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3646
	for (i = 0; i < ARRAY_SIZE(products); i++) {
L
Linus Torvalds 已提交
3647 3648 3649
		if (board_id == products[i].board_id) {
			c->product_name = products[i].product_name;
			c->access = *(products[i].access);
3650
			c->nr_cmds = c->max_commands - 4;
L
Linus Torvalds 已提交
3651 3652 3653
			break;
		}
	}
3654 3655 3656 3657
	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 已提交
3658
		printk("Does not appear to be a valid CISS config table\n");
3659
		err = -ENODEV;
3660
		goto err_out_free_res;
L
Linus Torvalds 已提交
3661
	}
3662 3663 3664 3665 3666 3667 3668 3669
	/* 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);
3670
			c->nr_cmds = c->max_commands - 4;
3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682
			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 已提交
3683
#ifdef CONFIG_X86
3684 3685 3686 3687 3688 3689 3690
	{
		/* 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 已提交
3691 3692
#endif

3693 3694 3695 3696
	/* Disabling DMA prefetch and refetch for the P600.
	 * An ASIC bug may result in accesses to invalid memory addresses.
	 * We've disabled prefetch for some time now. Testing with XEN
	 * kernels revealed a bug in the refetch if dom0 resides on a P600.
3697 3698 3699
	 */
	if(board_id == 0x3225103C) {
		__u32 dma_prefetch;
3700
		__u32 dma_refetch;
3701 3702 3703
		dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
		dma_prefetch |= 0x8000;
		writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
3704 3705 3706
		pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch);
		dma_refetch |= 0x1;
		pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch);
3707 3708
	}

L
Linus Torvalds 已提交
3709 3710
#ifdef CCISS_DEBUG
	printk("Trying to put board into Simple mode\n");
3711
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3712
	c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3713 3714 3715
	/* 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 已提交
3716 3717 3718 3719

	/* 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.) */
3720
	for (i = 0; i < MAX_CONFIG_WAIT; i++) {
L
Linus Torvalds 已提交
3721 3722 3723 3724
		if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
			break;
		/* delay and try again */
		set_current_state(TASK_INTERRUPTIBLE);
3725
		schedule_timeout(msecs_to_jiffies(1));
3726
	}
L
Linus Torvalds 已提交
3727 3728

#ifdef CCISS_DEBUG
3729 3730 3731
	printk(KERN_DEBUG "I counter got to %d %x\n", i,
	       readl(c->vaddr + SA5_DOORBELL));
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3732
#ifdef CCISS_DEBUG
3733 3734
	print_cfg_table(c->cfgtable);
#endif				/* CCISS_DEBUG */
L
Linus Torvalds 已提交
3735

3736
	if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
L
Linus Torvalds 已提交
3737
		printk(KERN_WARNING "cciss: unable to get board into"
3738
		       " simple mode\n");
3739
		err = -ENODEV;
3740
		goto err_out_free_res;
L
Linus Torvalds 已提交
3741 3742 3743
	}
	return 0;

3744
err_out_free_res:
3745 3746 3747 3748
	/*
	 * Deliberately omit pci_disable_device(): it does something nasty to
	 * Smart Array controllers that pci_enable_device does not undo
	 */
3749
	pci_release_regions(pdev);
3750
	return err;
L
Linus Torvalds 已提交
3751 3752
}

M
Mike Miller 已提交
3753 3754
/* Function to find the first free pointer into our hba[] array
 * Returns -1 if no free entries are left.
3755
 */
L
Linus Torvalds 已提交
3756 3757
static int alloc_cciss_hba(void)
{
3758
	int i;
L
Linus Torvalds 已提交
3759

3760
	for (i = 0; i < MAX_CTLR; i++) {
L
Linus Torvalds 已提交
3761 3762
		if (!hba[i]) {
			ctlr_info_t *p;
J
Jesper Juhl 已提交
3763

3764
			p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
L
Linus Torvalds 已提交
3765 3766 3767 3768 3769 3770 3771
			if (!p)
				goto Enomem;
			hba[i] = p;
			return i;
		}
	}
	printk(KERN_WARNING "cciss: This driver supports a maximum"
3772
	       " of %d controllers.\n", MAX_CTLR);
3773 3774
	return -1;
Enomem:
L
Linus Torvalds 已提交
3775 3776 3777 3778 3779 3780 3781 3782 3783 3784
	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;
3785
	for (n = 0; n < CISS_MAX_LUN; n++)
L
Linus Torvalds 已提交
3786 3787 3788 3789
		put_disk(p->gendisk[n]);
	kfree(p);
}

3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811
/* Send a message CDB to the firmware. */
static __devinit int cciss_message(struct pci_dev *pdev, unsigned char opcode, unsigned char type)
{
	typedef struct {
		CommandListHeader_struct CommandHeader;
		RequestBlock_struct Request;
		ErrDescriptor_struct ErrorDescriptor;
	} Command;
	static const size_t cmd_sz = sizeof(Command) + sizeof(ErrorInfo_struct);
	Command *cmd;
	dma_addr_t paddr64;
	uint32_t paddr32, tag;
	void __iomem *vaddr;
	int i, err;

	vaddr = ioremap_nocache(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
	if (vaddr == NULL)
		return -ENOMEM;

	/* The Inbound Post Queue only accepts 32-bit physical addresses for the
	   CCISS commands, so they must be allocated from the lower 4GiB of
	   memory. */
3812
	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986
	if (err) {
		iounmap(vaddr);
		return -ENOMEM;
	}

	cmd = pci_alloc_consistent(pdev, cmd_sz, &paddr64);
	if (cmd == NULL) {
		iounmap(vaddr);
		return -ENOMEM;
	}

	/* This must fit, because of the 32-bit consistent DMA mask.  Also,
	   although there's no guarantee, we assume that the address is at
	   least 4-byte aligned (most likely, it's page-aligned). */
	paddr32 = paddr64;

	cmd->CommandHeader.ReplyQueue = 0;
	cmd->CommandHeader.SGList = 0;
	cmd->CommandHeader.SGTotal = 0;
	cmd->CommandHeader.Tag.lower = paddr32;
	cmd->CommandHeader.Tag.upper = 0;
	memset(&cmd->CommandHeader.LUN.LunAddrBytes, 0, 8);

	cmd->Request.CDBLen = 16;
	cmd->Request.Type.Type = TYPE_MSG;
	cmd->Request.Type.Attribute = ATTR_HEADOFQUEUE;
	cmd->Request.Type.Direction = XFER_NONE;
	cmd->Request.Timeout = 0; /* Don't time out */
	cmd->Request.CDB[0] = opcode;
	cmd->Request.CDB[1] = type;
	memset(&cmd->Request.CDB[2], 0, 14); /* the rest of the CDB is reserved */

	cmd->ErrorDescriptor.Addr.lower = paddr32 + sizeof(Command);
	cmd->ErrorDescriptor.Addr.upper = 0;
	cmd->ErrorDescriptor.Len = sizeof(ErrorInfo_struct);

	writel(paddr32, vaddr + SA5_REQUEST_PORT_OFFSET);

	for (i = 0; i < 10; i++) {
		tag = readl(vaddr + SA5_REPLY_PORT_OFFSET);
		if ((tag & ~3) == paddr32)
			break;
		schedule_timeout_uninterruptible(HZ);
	}

	iounmap(vaddr);

	/* we leak the DMA buffer here ... no choice since the controller could
	   still complete the command. */
	if (i == 10) {
		printk(KERN_ERR "cciss: controller message %02x:%02x timed out\n",
			opcode, type);
		return -ETIMEDOUT;
	}

	pci_free_consistent(pdev, cmd_sz, cmd, paddr64);

	if (tag & 2) {
		printk(KERN_ERR "cciss: controller message %02x:%02x failed\n",
			opcode, type);
		return -EIO;
	}

	printk(KERN_INFO "cciss: controller message %02x:%02x succeeded\n",
		opcode, type);
	return 0;
}

#define cciss_soft_reset_controller(p) cciss_message(p, 1, 0)
#define cciss_noop(p) cciss_message(p, 3, 0)

static __devinit int cciss_reset_msi(struct pci_dev *pdev)
{
/* the #defines are stolen from drivers/pci/msi.h. */
#define msi_control_reg(base)		(base + PCI_MSI_FLAGS)
#define PCI_MSIX_FLAGS_ENABLE		(1 << 15)

	int pos;
	u16 control = 0;

	pos = pci_find_capability(pdev, PCI_CAP_ID_MSI);
	if (pos) {
		pci_read_config_word(pdev, msi_control_reg(pos), &control);
		if (control & PCI_MSI_FLAGS_ENABLE) {
			printk(KERN_INFO "cciss: resetting MSI\n");
			pci_write_config_word(pdev, msi_control_reg(pos), control & ~PCI_MSI_FLAGS_ENABLE);
		}
	}

	pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
	if (pos) {
		pci_read_config_word(pdev, msi_control_reg(pos), &control);
		if (control & PCI_MSIX_FLAGS_ENABLE) {
			printk(KERN_INFO "cciss: resetting MSI-X\n");
			pci_write_config_word(pdev, msi_control_reg(pos), control & ~PCI_MSIX_FLAGS_ENABLE);
		}
	}

	return 0;
}

/* This does a hard reset of the controller using PCI power management
 * states. */
static __devinit int cciss_hard_reset_controller(struct pci_dev *pdev)
{
	u16 pmcsr, saved_config_space[32];
	int i, pos;

	printk(KERN_INFO "cciss: using PCI PM to reset controller\n");

	/* This is very nearly the same thing as

	   pci_save_state(pci_dev);
	   pci_set_power_state(pci_dev, PCI_D3hot);
	   pci_set_power_state(pci_dev, PCI_D0);
	   pci_restore_state(pci_dev);

	   but we can't use these nice canned kernel routines on
	   kexec, because they also check the MSI/MSI-X state in PCI
	   configuration space and do the wrong thing when it is
	   set/cleared.  Also, the pci_save/restore_state functions
	   violate the ordering requirements for restoring the
	   configuration space from the CCISS document (see the
	   comment below).  So we roll our own .... */

	for (i = 0; i < 32; i++)
		pci_read_config_word(pdev, 2*i, &saved_config_space[i]);

	pos = pci_find_capability(pdev, PCI_CAP_ID_PM);
	if (pos == 0) {
		printk(KERN_ERR "cciss_reset_controller: PCI PM not supported\n");
		return -ENODEV;
	}

	/* Quoting from the Open CISS Specification: "The Power
	 * Management Control/Status Register (CSR) controls the power
	 * state of the device.  The normal operating state is D0,
	 * CSR=00h.  The software off state is D3, CSR=03h.  To reset
	 * the controller, place the interface device in D3 then to
	 * D0, this causes a secondary PCI reset which will reset the
	 * controller." */

	/* enter the D3hot power management state */
	pci_read_config_word(pdev, pos + PCI_PM_CTRL, &pmcsr);
	pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
	pmcsr |= PCI_D3hot;
	pci_write_config_word(pdev, pos + PCI_PM_CTRL, pmcsr);

	schedule_timeout_uninterruptible(HZ >> 1);

	/* enter the D0 power management state */
	pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
	pmcsr |= PCI_D0;
	pci_write_config_word(pdev, pos + PCI_PM_CTRL, pmcsr);

	schedule_timeout_uninterruptible(HZ >> 1);

	/* Restore the PCI configuration space.  The Open CISS
	 * Specification says, "Restore the PCI Configuration
	 * Registers, offsets 00h through 60h. It is important to
	 * restore the command register, 16-bits at offset 04h,
	 * last. Do not restore the configuration status register,
	 * 16-bits at offset 06h."  Note that the offset is 2*i. */
	for (i = 0; i < 32; i++) {
		if (i == 2 || i == 3)
			continue;
		pci_write_config_word(pdev, 2*i, saved_config_space[i]);
	}
	wmb();
	pci_write_config_word(pdev, 4, saved_config_space[2]);

	return 0;
}

L
Linus Torvalds 已提交
3987 3988 3989 3990 3991 3992
/*
 *  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,
3993
				    const struct pci_device_id *ent)
L
Linus Torvalds 已提交
3994 3995
{
	int i;
3996
	int j = 0;
L
Linus Torvalds 已提交
3997
	int rc;
3998
	int dac, return_code;
3999
	InquiryData_struct *inq_buff;
L
Linus Torvalds 已提交
4000

4001 4002 4003 4004 4005
	if (reset_devices) {
		/* Reset the controller with a PCI power-cycle */
		if (cciss_hard_reset_controller(pdev) || cciss_reset_msi(pdev))
			return -ENODEV;

4006 4007 4008
		/* Now try to get the controller to respond to a no-op. Some
		   devices (notably the HP Smart Array 5i Controller) need
		   up to 30 seconds to respond. */
4009
		for (i=0; i<30; i++) {
4010 4011
			if (cciss_noop(pdev) == 0)
				break;
4012 4013 4014 4015 4016 4017

			schedule_timeout_uninterruptible(HZ);
		}
		if (i == 30) {
			printk(KERN_ERR "cciss: controller seems dead\n");
			return -EBUSY;
4018 4019 4020
		}
	}

L
Linus Torvalds 已提交
4021
	i = alloc_cciss_hba();
4022
	if (i < 0)
4023
		return -1;
4024 4025

	hba[i]->busy_initializing = 1;
4026 4027
	INIT_HLIST_HEAD(&hba[i]->cmpQ);
	INIT_HLIST_HEAD(&hba[i]->reqQ);
4028
	mutex_init(&hba[i]->busy_shutting_down);
4029

L
Linus Torvalds 已提交
4030
	if (cciss_pci_init(hba[i], pdev) != 0)
4031
		goto clean0;
L
Linus Torvalds 已提交
4032 4033 4034 4035 4036

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

4037 4038
	init_completion(&hba[i]->scan_wait);

4039 4040 4041
	if (cciss_create_hba_sysfs_entry(hba[i]))
		goto clean0;

L
Linus Torvalds 已提交
4042
	/* configure PCI DMA stuff */
4043
	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
4044
		dac = 1;
4045
	else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))
4046
		dac = 0;
L
Linus Torvalds 已提交
4047
	else {
4048
		printk(KERN_ERR "cciss: no suitable DMA available\n");
L
Linus Torvalds 已提交
4049 4050 4051 4052 4053 4054 4055 4056 4057
		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)
4058
		hba[i]->major = COMPAQ_CISS_MAJOR + i;
L
Linus Torvalds 已提交
4059
	rc = register_blkdev(hba[i]->major, hba[i]->devname);
4060
	if (rc == -EBUSY || rc == -EINVAL) {
L
Linus Torvalds 已提交
4061
		printk(KERN_ERR
4062 4063
		       "cciss:  Unable to get major number %d for %s "
		       "on hba %d\n", hba[i]->major, hba[i]->devname, i);
L
Linus Torvalds 已提交
4064
		goto clean1;
4065
	} else {
L
Linus Torvalds 已提交
4066 4067 4068 4069 4070 4071
		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);
4072
	if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
4073
			IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
L
Linus Torvalds 已提交
4074
		printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
4075
		       hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
L
Linus Torvalds 已提交
4076 4077
		goto clean2;
	}
4078 4079

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

	hba[i]->cmd_pool_bits =
J
Julia Lawall 已提交
4084 4085
	    kmalloc(DIV_ROUND_UP(hba[i]->nr_cmds, BITS_PER_LONG)
			* sizeof(unsigned long), GFP_KERNEL);
4086 4087
	hba[i]->cmd_pool = (CommandList_struct *)
	    pci_alloc_consistent(hba[i]->pdev,
4088
		    hba[i]->nr_cmds * sizeof(CommandList_struct),
4089 4090 4091
		    &(hba[i]->cmd_pool_dhandle));
	hba[i]->errinfo_pool = (ErrorInfo_struct *)
	    pci_alloc_consistent(hba[i]->pdev,
4092
		    hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
4093 4094 4095 4096 4097
		    &(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 已提交
4098 4099 4100 4101
		goto clean4;
	}
	spin_lock_init(&hba[i]->lock);

4102 4103
	/* Initialize the pdev driver private data.
	   have it point to hba[i].  */
L
Linus Torvalds 已提交
4104
	pci_set_drvdata(pdev, hba[i]);
4105 4106 4107
	/* command and error info recs zeroed out before
	   they are used */
	memset(hba[i]->cmd_pool_bits, 0,
J
Julia Lawall 已提交
4108 4109
	       DIV_ROUND_UP(hba[i]->nr_cmds, BITS_PER_LONG)
			* sizeof(unsigned long));
L
Linus Torvalds 已提交
4110

M
Mike Miller 已提交
4111 4112 4113 4114 4115 4116 4117
	hba[i]->num_luns = 0;
	hba[i]->highest_lun = -1;
	for (j = 0; j < CISS_MAX_LUN; j++) {
		hba[i]->drv[j].raid_level = -1;
		hba[i]->drv[j].queue = NULL;
		hba[i]->gendisk[j] = NULL;
	}
L
Linus Torvalds 已提交
4118 4119 4120 4121 4122 4123

	cciss_scsi_setup(i);

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

4124 4125 4126 4127 4128 4129 4130 4131
	/* Get the firmware version */
	inq_buff = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL);
	if (inq_buff == NULL) {
		printk(KERN_ERR "cciss: out of memory\n");
		goto clean4;
	}

	return_code = sendcmd_withirq(CISS_INQUIRY, i, inq_buff,
4132
		sizeof(InquiryData_struct), 0, CTLR_LUNID, TYPE_CMD);
4133 4134 4135 4136 4137 4138 4139 4140 4141
	if (return_code == IO_OK) {
		hba[i]->firm_ver[0] = inq_buff->data_byte[32];
		hba[i]->firm_ver[1] = inq_buff->data_byte[33];
		hba[i]->firm_ver[2] = inq_buff->data_byte[34];
		hba[i]->firm_ver[3] = inq_buff->data_byte[35];
	} else {	 /* send command failed */
		printk(KERN_WARNING "cciss: unable to determine firmware"
			" version of controller\n");
	}
4142
	kfree(inq_buff);
4143

L
Linus Torvalds 已提交
4144
	cciss_procinit(i);
4145 4146 4147

	hba[i]->cciss_max_sectors = 2048;

M
Mike Miller 已提交
4148
	rebuild_lun_table(hba[i], 1);
4149
	hba[i]->busy_initializing = 0;
4150
	return 1;
L
Linus Torvalds 已提交
4151

M
Mike Miller 已提交
4152
clean4:
4153
	kfree(hba[i]->cmd_pool_bits);
4154
	if (hba[i]->cmd_pool)
L
Linus Torvalds 已提交
4155
		pci_free_consistent(hba[i]->pdev,
4156
				    hba[i]->nr_cmds * sizeof(CommandList_struct),
4157 4158
				    hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
	if (hba[i]->errinfo_pool)
L
Linus Torvalds 已提交
4159
		pci_free_consistent(hba[i]->pdev,
4160
				    hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
4161 4162
				    hba[i]->errinfo_pool,
				    hba[i]->errinfo_pool_dhandle);
4163
	free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
M
Mike Miller 已提交
4164
clean2:
L
Linus Torvalds 已提交
4165
	unregister_blkdev(hba[i]->major, hba[i]->devname);
M
Mike Miller 已提交
4166
clean1:
4167 4168
	cciss_destroy_hba_sysfs_entry(hba[i]);
clean0:
4169
	hba[i]->busy_initializing = 0;
4170 4171 4172 4173 4174 4175
	/* 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);
	}
4176 4177 4178 4179
	/*
	 * Deliberately omit pci_disable_device(): it does something nasty to
	 * Smart Array controllers that pci_enable_device does not undo
	 */
4180 4181
	pci_release_regions(pdev);
	pci_set_drvdata(pdev, NULL);
4182
	free_hba(i);
4183
	return -1;
L
Linus Torvalds 已提交
4184 4185
}

4186
static void cciss_shutdown(struct pci_dev *pdev)
L
Linus Torvalds 已提交
4187 4188
{
	ctlr_info_t *tmp_ptr;
4189
	int i;
L
Linus Torvalds 已提交
4190
	char flush_buf[4];
4191
	int return_code;
L
Linus Torvalds 已提交
4192

4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203
	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);
4204 4205
	return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0,
		CTLR_LUNID, TYPE_CMD);
4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218
	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;

4219 4220
	if (pci_get_drvdata(pdev) == NULL) {
		printk(KERN_ERR "cciss: Unable to remove device \n");
L
Linus Torvalds 已提交
4221 4222
		return;
	}
4223

L
Linus Torvalds 已提交
4224 4225
	tmp_ptr = pci_get_drvdata(pdev);
	i = tmp_ptr->ctlr;
4226
	if (hba[i] == NULL) {
L
Linus Torvalds 已提交
4227
		printk(KERN_ERR "cciss: device appears to "
4228
		       "already be removed \n");
L
Linus Torvalds 已提交
4229 4230
		return;
	}
4231

4232
	mutex_lock(&hba[i]->busy_shutting_down);
4233

4234
	remove_from_scan_list(hba[i]);
4235 4236 4237 4238 4239 4240 4241
	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) {
4242
			struct request_queue *q = disk->queue;
4243 4244 4245 4246 4247 4248

			if (disk->flags & GENHD_FL_UP)
				del_gendisk(disk);
			if (q)
				blk_cleanup_queue(q);
		}
4249 4250 4251
		if (hba[i]->drv[j].raid_level != -1)
			cciss_destroy_ld_sysfs_entry(&hba[i]->drv[j]);

4252 4253
	}

4254
#ifdef CONFIG_CISS_SCSI_TAPE
4255
	cciss_unregister_scsi(i);	/* unhook from SCSI subsystem */
4256
#endif
4257

4258
	cciss_shutdown(pdev);
4259 4260

#ifdef CONFIG_PCI_MSI
4261 4262 4263 4264 4265
	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 */
4266

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

4269
	pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
L
Linus Torvalds 已提交
4270
			    hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
4271
	pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
4272
			    hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
L
Linus Torvalds 已提交
4273
	kfree(hba[i]->cmd_pool_bits);
4274 4275 4276 4277
	/*
	 * Deliberately omit pci_disable_device(): it does something nasty to
	 * Smart Array controllers that pci_enable_device does not undo
	 */
4278
	pci_release_regions(pdev);
4279
	pci_set_drvdata(pdev, NULL);
4280
	cciss_destroy_hba_sysfs_entry(hba[i]);
4281
	mutex_unlock(&hba[i]->busy_shutting_down);
L
Linus Torvalds 已提交
4282
	free_hba(i);
4283
}
L
Linus Torvalds 已提交
4284 4285

static struct pci_driver cciss_pci_driver = {
4286 4287 4288 4289
	.name = "cciss",
	.probe = cciss_init_one,
	.remove = __devexit_p(cciss_remove_one),
	.id_table = cciss_pci_device_id,	/* id_table */
4290
	.shutdown = cciss_shutdown,
L
Linus Torvalds 已提交
4291 4292 4293 4294
};

/*
 *  This is it.  Register the PCI driver information for the cards we control
4295
 *  the OS will call our registered routines when it finds one of our cards.
L
Linus Torvalds 已提交
4296 4297 4298
 */
static int __init cciss_init(void)
{
4299 4300
	int err;

4301 4302 4303 4304 4305 4306 4307
	/*
	 * The hardware requires that commands are aligned on a 64-bit
	 * boundary. Given that we use pci_alloc_consistent() to allocate an
	 * array of them, the size must be a multiple of 8 bytes.
	 */
	BUILD_BUG_ON(sizeof(CommandList_struct) % 8);

L
Linus Torvalds 已提交
4308 4309
	printk(KERN_INFO DRIVER_NAME "\n");

4310 4311 4312 4313
	err = bus_register(&cciss_bus_type);
	if (err)
		return err;

4314 4315 4316 4317 4318 4319 4320
	/* Start the scan thread */
	cciss_scan_thread = kthread_run(scan_thread, NULL, "cciss_scan");
	if (IS_ERR(cciss_scan_thread)) {
		err = PTR_ERR(cciss_scan_thread);
		goto err_bus_unregister;
	}

L
Linus Torvalds 已提交
4321
	/* Register for our PCI devices */
4322 4323
	err = pci_register_driver(&cciss_pci_driver);
	if (err)
4324
		goto err_thread_stop;
4325 4326 4327

	return 0;

4328 4329 4330
err_thread_stop:
	kthread_stop(cciss_scan_thread);
err_bus_unregister:
4331
	bus_unregister(&cciss_bus_type);
4332

4333
	return err;
L
Linus Torvalds 已提交
4334 4335 4336 4337 4338 4339 4340 4341
}

static void __exit cciss_cleanup(void)
{
	int i;

	pci_unregister_driver(&cciss_pci_driver);
	/* double check that all controller entrys have been removed */
4342 4343
	for (i = 0; i < MAX_CTLR; i++) {
		if (hba[i] != NULL) {
L
Linus Torvalds 已提交
4344
			printk(KERN_WARNING "cciss: had to remove"
4345
			       " controller %d\n", i);
L
Linus Torvalds 已提交
4346 4347 4348
			cciss_remove_one(hba[i]->pdev);
		}
	}
4349
	kthread_stop(cciss_scan_thread);
A
Alexey Dobriyan 已提交
4350
	remove_proc_entry("driver/cciss", NULL);
4351
	bus_unregister(&cciss_bus_type);
L
Linus Torvalds 已提交
4352 4353
}

4354 4355 4356 4357 4358 4359 4360 4361
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);
4362
	h->alive = 0;		/* the controller apparently died... */
4363 4364 4365

	spin_lock_irqsave(CCISS_LOCK(ctlr), flags);

4366
	pci_disable_device(h->pdev);	/* Make sure it is really dead. */
4367 4368

	/* move everything off the request queue onto the completed queue */
4369 4370 4371
	while (!hlist_empty(&h->reqQ)) {
		c = hlist_entry(h->reqQ.first, CommandList_struct, list);
		removeQ(c);
4372
		h->Qdepth--;
4373
		addQ(&h->cmpQ, c);
4374 4375 4376
	}

	/* Now, fail everything on the completed queue with a HW error */
4377 4378 4379
	while (!hlist_empty(&h->cmpQ)) {
		c = hlist_entry(h->cmpQ.first, CommandList_struct, list);
		removeQ(c);
4380 4381
		if (c->cmd_type != CMD_MSG_STALE)
			c->err_info->CommandStatus = CMD_HARDWARE_ERR;
4382 4383 4384 4385 4386
		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
4387 4388
		else if (c->cmd_type == CMD_SCSI)
			complete_scsi_command(c, 0, 0);
4389 4390 4391 4392 4393 4394
#endif
	}
	spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
	return;
}

L
Linus Torvalds 已提交
4395 4396
module_init(cciss_init);
module_exit(cciss_cleanup);