1/*
   2 *    Disk Array driver for HP Smart Array controllers, SCSI Tape module.
   3 *    (C) Copyright 2001, 2007 Hewlett-Packard Development Company, L.P.
   4 *
   5 *    This program is free software; you can redistribute it and/or modify
   6 *    it under the terms of the GNU General Public License as published by
   7 *    the Free Software Foundation; version 2 of the License.
   8 *
   9 *    This program is distributed in the hope that it will be useful,
  10 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12 *    General Public License for more details.
  13 *
  14 *    You should have received a copy of the GNU General Public License
  15 *    along with this program; if not, write to the Free Software
  16 *    Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA
  17 *    02111-1307, USA.
  18 *
  19 *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
  20 *    
  21 *    Author: Stephen M. Cameron
  22 */
  23#ifdef CONFIG_CISS_SCSI_TAPE
  24
  25/* Here we have code to present the driver as a scsi driver 
  26   as it is simultaneously presented as a block driver.  The 
  27   reason for doing this is to allow access to SCSI tape drives
  28   through the array controller.  Note in particular, neither 
  29   physical nor logical disks are presented through the scsi layer. */
  30
  31#include <linux/timer.h>
  32#include <linux/completion.h>
  33#include <linux/slab.h>
  34#include <linux/string.h>
  35
  36#include <linux/atomic.h>
  37
  38#include <scsi/scsi_cmnd.h>
  39#include <scsi/scsi_device.h>
  40#include <scsi/scsi_host.h> 
  41
  42#include "cciss_scsi.h"
  43
  44#define CCISS_ABORT_MSG 0x00
  45#define CCISS_RESET_MSG 0x01
  46
  47static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff,
  48	size_t size,
  49	__u8 page_code, unsigned char *scsi3addr,
  50	int cmd_type);
  51
  52static CommandList_struct *cmd_alloc(ctlr_info_t *h);
  53static CommandList_struct *cmd_special_alloc(ctlr_info_t *h);
  54static void cmd_free(ctlr_info_t *h, CommandList_struct *c);
  55static void cmd_special_free(ctlr_info_t *h, CommandList_struct *c);
  56
  57static int cciss_scsi_proc_info(
  58		struct Scsi_Host *sh,
  59		char *buffer, /* data buffer */
  60		char **start, 	   /* where data in buffer starts */
  61		off_t offset,	   /* offset from start of imaginary file */
  62		int length, 	   /* length of data in buffer */
  63		int func);	   /* 0 == read, 1 == write */
  64
  65static int cciss_scsi_queue_command (struct Scsi_Host *h,
  66				     struct scsi_cmnd *cmd);
  67static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
  68static int cciss_eh_abort_handler(struct scsi_cmnd *);
  69
  70static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
  71	{ .name = "cciss0", .ndevices = 0 },
  72	{ .name = "cciss1", .ndevices = 0 },
  73	{ .name = "cciss2", .ndevices = 0 },
  74	{ .name = "cciss3", .ndevices = 0 },
  75	{ .name = "cciss4", .ndevices = 0 },
  76	{ .name = "cciss5", .ndevices = 0 },
  77	{ .name = "cciss6", .ndevices = 0 },
  78	{ .name = "cciss7", .ndevices = 0 },
  79};
  80
  81static struct scsi_host_template cciss_driver_template = {
  82	.module			= THIS_MODULE,
  83	.name			= "cciss",
  84	.proc_name		= "cciss",
  85	.proc_info		= cciss_scsi_proc_info,
 
  86	.queuecommand		= cciss_scsi_queue_command,
  87	.this_id		= 7,
  88	.cmd_per_lun		= 1,
  89	.use_clustering		= DISABLE_CLUSTERING,
  90	/* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
  91	.eh_device_reset_handler= cciss_eh_device_reset_handler,
  92	.eh_abort_handler	= cciss_eh_abort_handler,
  93};
  94
  95#pragma pack(1)
  96
  97#define SCSI_PAD_32 8
  98#define SCSI_PAD_64 8
  99
 100struct cciss_scsi_cmd_stack_elem_t {
 101	CommandList_struct cmd;
 102	ErrorInfo_struct Err;
 103	__u32 busaddr;
 104	int cmdindex;
 105	u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
 106};
 107
 108#pragma pack()
 109
 110#pragma pack(1)
 111struct cciss_scsi_cmd_stack_t {
 112	struct cciss_scsi_cmd_stack_elem_t *pool;
 113	struct cciss_scsi_cmd_stack_elem_t **elem;
 114	dma_addr_t cmd_pool_handle;
 115	int top;
 116	int nelems;
 117};
 118#pragma pack()
 119
 120struct cciss_scsi_adapter_data_t {
 121	struct Scsi_Host *scsi_host;
 122	struct cciss_scsi_cmd_stack_t cmd_stack;
 123	SGDescriptor_struct **cmd_sg_list;
 124	int registered;
 125	spinlock_t lock; // to protect ccissscsi[ctlr]; 
 126};
 127
 128#define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
 129	&h->scsi_ctlr->lock, flags);
 130#define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
 131	&h->scsi_ctlr->lock, flags);
 132
 133static CommandList_struct *
 134scsi_cmd_alloc(ctlr_info_t *h)
 135{
 136	/* assume only one process in here at a time, locking done by caller. */
 137	/* use h->lock */
 138	/* might be better to rewrite how we allocate scsi commands in a way that */
 139	/* needs no locking at all. */
 140
 141	/* take the top memory chunk off the stack and return it, if any. */
 142	struct cciss_scsi_cmd_stack_elem_t *c;
 143	struct cciss_scsi_adapter_data_t *sa;
 144	struct cciss_scsi_cmd_stack_t *stk;
 145	u64bit temp64;
 146
 147	sa = h->scsi_ctlr;
 148	stk = &sa->cmd_stack; 
 149
 150	if (stk->top < 0) 
 151		return NULL;
 152	c = stk->elem[stk->top]; 	
 153	/* memset(c, 0, sizeof(*c)); */
 154	memset(&c->cmd, 0, sizeof(c->cmd));
 155	memset(&c->Err, 0, sizeof(c->Err));
 156	/* set physical addr of cmd and addr of scsi parameters */
 157	c->cmd.busaddr = c->busaddr; 
 158	c->cmd.cmdindex = c->cmdindex;
 159	/* (__u32) (stk->cmd_pool_handle + 
 160		(sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
 161
 162	temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
 163	/* (__u64) (stk->cmd_pool_handle + 
 164		(sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
 165		 sizeof(CommandList_struct)); */
 166	stk->top--;
 167	c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
 168	c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
 169	c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
 170	
 171	c->cmd.ctlr = h->ctlr;
 172	c->cmd.err_info = &c->Err;
 173
 174	return (CommandList_struct *) c;
 175}
 176
 177static void 
 178scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c)
 179{
 180	/* assume only one process in here at a time, locking done by caller. */
 181	/* use h->lock */
 182	/* drop the free memory chunk on top of the stack. */
 183
 184	struct cciss_scsi_adapter_data_t *sa;
 185	struct cciss_scsi_cmd_stack_t *stk;
 186
 187	sa = h->scsi_ctlr;
 188	stk = &sa->cmd_stack; 
 189	stk->top++;
 190	if (stk->top >= stk->nelems) {
 191		dev_err(&h->pdev->dev,
 192			"scsi_cmd_free called too many times.\n");
 193		BUG();
 194	}
 195	stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c;
 196}
 197
 198static int
 199scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa)
 200{
 201	int i;
 202	struct cciss_scsi_cmd_stack_t *stk;
 203	size_t size;
 204
 205	stk = &sa->cmd_stack;
 206	stk->nelems = cciss_tape_cmds + 2;
 207	sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
 208		h->chainsize, stk->nelems);
 209	if (!sa->cmd_sg_list && h->chainsize > 0)
 210		return -ENOMEM;
 211
 212	size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
 213
 214	/* Check alignment, see cciss_cmd.h near CommandList_struct def. */
 215	BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
 216	/* pci_alloc_consistent guarantees 32-bit DMA address will be used */
 217	stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
 218		pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle);
 219
 220	if (stk->pool == NULL) {
 221		cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
 222		sa->cmd_sg_list = NULL;
 223		return -ENOMEM;
 224	}
 225	stk->elem = kmalloc(sizeof(stk->elem[0]) * stk->nelems, GFP_KERNEL);
 226	if (!stk->elem) {
 227		pci_free_consistent(h->pdev, size, stk->pool,
 228		stk->cmd_pool_handle);
 229		return -1;
 230	}
 231	for (i = 0; i < stk->nelems; i++) {
 232		stk->elem[i] = &stk->pool[i];
 233		stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle + 
 234			(sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
 235		stk->elem[i]->cmdindex = i;
 236	}
 237	stk->top = stk->nelems-1;
 238	return 0;
 239}
 240
 241static void
 242scsi_cmd_stack_free(ctlr_info_t *h)
 243{
 244	struct cciss_scsi_adapter_data_t *sa;
 245	struct cciss_scsi_cmd_stack_t *stk;
 246	size_t size;
 247
 248	sa = h->scsi_ctlr;
 249	stk = &sa->cmd_stack; 
 250	if (stk->top != stk->nelems-1) {
 251		dev_warn(&h->pdev->dev,
 252			"bug: %d scsi commands are still outstanding.\n",
 253			stk->nelems - stk->top);
 254	}
 255	size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
 256
 257	pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle);
 258	stk->pool = NULL;
 259	cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
 260	kfree(stk->elem);
 261	stk->elem = NULL;
 262}
 263
 264#if 0
 265static int xmargin=8;
 266static int amargin=60;
 267
 268static void
 269print_bytes (unsigned char *c, int len, int hex, int ascii)
 270{
 271
 272	int i;
 273	unsigned char *x;
 274
 275	if (hex)
 276	{
 277		x = c;
 278		for (i=0;i<len;i++)
 279		{
 280			if ((i % xmargin) == 0 && i>0) printk("\n");
 281			if ((i % xmargin) == 0) printk("0x%04x:", i);
 282			printk(" %02x", *x);
 283			x++;
 284		}
 285		printk("\n");
 286	}
 287	if (ascii)
 288	{
 289		x = c;
 290		for (i=0;i<len;i++)
 291		{
 292			if ((i % amargin) == 0 && i>0) printk("\n");
 293			if ((i % amargin) == 0) printk("0x%04x:", i);
 294			if (*x > 26 && *x < 128) printk("%c", *x);
 295			else printk(".");
 296			x++;
 297		}
 298		printk("\n");
 299	}
 300}
 301
 302static void
 303print_cmd(CommandList_struct *cp)
 304{
 305	printk("queue:%d\n", cp->Header.ReplyQueue);
 306	printk("sglist:%d\n", cp->Header.SGList);
 307	printk("sgtot:%d\n", cp->Header.SGTotal);
 308	printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper, 
 309			cp->Header.Tag.lower);
 310	printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
 311		cp->Header.LUN.LunAddrBytes[0],
 312		cp->Header.LUN.LunAddrBytes[1],
 313		cp->Header.LUN.LunAddrBytes[2],
 314		cp->Header.LUN.LunAddrBytes[3],
 315		cp->Header.LUN.LunAddrBytes[4],
 316		cp->Header.LUN.LunAddrBytes[5],
 317		cp->Header.LUN.LunAddrBytes[6],
 318		cp->Header.LUN.LunAddrBytes[7]);
 319	printk("CDBLen:%d\n", cp->Request.CDBLen);
 320	printk("Type:%d\n",cp->Request.Type.Type);
 321	printk("Attr:%d\n",cp->Request.Type.Attribute);
 322	printk(" Dir:%d\n",cp->Request.Type.Direction);
 323	printk("Timeout:%d\n",cp->Request.Timeout);
 324	printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
 325		" %02x %02x %02x %02x %02x %02x %02x %02x\n",
 326		cp->Request.CDB[0], cp->Request.CDB[1],
 327		cp->Request.CDB[2], cp->Request.CDB[3],
 328		cp->Request.CDB[4], cp->Request.CDB[5],
 329		cp->Request.CDB[6], cp->Request.CDB[7],
 330		cp->Request.CDB[8], cp->Request.CDB[9],
 331		cp->Request.CDB[10], cp->Request.CDB[11],
 332		cp->Request.CDB[12], cp->Request.CDB[13],
 333		cp->Request.CDB[14], cp->Request.CDB[15]),
 334	printk("edesc.Addr: 0x%08x/0%08x, Len  = %d\n", 
 335		cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower, 
 336			cp->ErrDesc.Len);
 337	printk("sgs..........Errorinfo:\n");
 338	printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
 339	printk("senselen:%d\n", cp->err_info->SenseLen);
 340	printk("cmd status:%d\n", cp->err_info->CommandStatus);
 341	printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
 342	printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
 343	printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
 344	printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
 345			
 346}
 347
 348#endif
 349
 350static int 
 351find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun)
 352{
 353	/* finds an unused bus, target, lun for a new device */
 354	/* assumes h->scsi_ctlr->lock is held */
 355	int i, found=0;
 356	unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
 357
 358	memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
 359
 360	target_taken[SELF_SCSI_ID] = 1;	
 361	for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++)
 362		target_taken[ccissscsi[h->ctlr].dev[i].target] = 1;
 363	
 364	for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) {
 365		if (!target_taken[i]) {
 366			*bus = 0; *target=i; *lun = 0; found=1;
 367			break;
 368		}
 369	}
 370	return (!found);	
 371}
 372struct scsi2map {
 373	char scsi3addr[8];
 374	int bus, target, lun;
 375};
 376
 377static int 
 378cciss_scsi_add_entry(ctlr_info_t *h, int hostno,
 379		struct cciss_scsi_dev_t *device,
 380		struct scsi2map *added, int *nadded)
 381{
 382	/* assumes h->scsi_ctlr->lock is held */
 383	int n = ccissscsi[h->ctlr].ndevices;
 384	struct cciss_scsi_dev_t *sd;
 385	int i, bus, target, lun;
 386	unsigned char addr1[8], addr2[8];
 387
 388	if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
 389		dev_warn(&h->pdev->dev, "Too many devices, "
 390			"some will be inaccessible.\n");
 391		return -1;
 392	}
 393
 394	bus = target = -1;
 395	lun = 0;
 396	/* Is this device a non-zero lun of a multi-lun device */
 397	/* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
 398	if (device->scsi3addr[4] != 0) {
 399		/* Search through our list and find the device which */
 400		/* has the same 8 byte LUN address, excepting byte 4. */
 401		/* Assign the same bus and target for this new LUN. */
 402		/* Use the logical unit number from the firmware. */
 403		memcpy(addr1, device->scsi3addr, 8);
 404		addr1[4] = 0;
 405		for (i = 0; i < n; i++) {
 406			sd = &ccissscsi[h->ctlr].dev[i];
 407			memcpy(addr2, sd->scsi3addr, 8);
 408			addr2[4] = 0;
 409			/* differ only in byte 4? */
 410			if (memcmp(addr1, addr2, 8) == 0) {
 411				bus = sd->bus;
 412				target = sd->target;
 413				lun = device->scsi3addr[4];
 414				break;
 415			}
 416		}
 417	}
 418
 419	sd = &ccissscsi[h->ctlr].dev[n];
 420	if (lun == 0) {
 421		if (find_bus_target_lun(h,
 422			&sd->bus, &sd->target, &sd->lun) != 0)
 423			return -1;
 424	} else {
 425		sd->bus = bus;
 426		sd->target = target;
 427		sd->lun = lun;
 428	}
 429	added[*nadded].bus = sd->bus;
 430	added[*nadded].target = sd->target;
 431	added[*nadded].lun = sd->lun;
 432	(*nadded)++;
 433
 434	memcpy(sd->scsi3addr, device->scsi3addr, 8);
 435	memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
 436	memcpy(sd->revision, device->revision, sizeof(sd->revision));
 437	memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
 438	sd->devtype = device->devtype;
 439
 440	ccissscsi[h->ctlr].ndevices++;
 441
 442	/* initially, (before registering with scsi layer) we don't 
 443	   know our hostno and we don't want to print anything first 
 444	   time anyway (the scsi layer's inquiries will show that info) */
 445	if (hostno != -1)
 446		dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n",
 447			scsi_device_type(sd->devtype), hostno,
 448			sd->bus, sd->target, sd->lun);
 449	return 0;
 450}
 451
 452static void
 453cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry,
 454	struct scsi2map *removed, int *nremoved)
 455{
 456	/* assumes h->ctlr]->scsi_ctlr->lock is held */
 457	int i;
 458	struct cciss_scsi_dev_t sd;
 459
 460	if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
 461	sd = ccissscsi[h->ctlr].dev[entry];
 462	removed[*nremoved].bus    = sd.bus;
 463	removed[*nremoved].target = sd.target;
 464	removed[*nremoved].lun    = sd.lun;
 465	(*nremoved)++;
 466	for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++)
 467		ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1];
 468	ccissscsi[h->ctlr].ndevices--;
 469	dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n",
 470		scsi_device_type(sd.devtype), hostno,
 471			sd.bus, sd.target, sd.lun);
 472}
 473
 474
 475#define SCSI3ADDR_EQ(a,b) ( \
 476	(a)[7] == (b)[7] && \
 477	(a)[6] == (b)[6] && \
 478	(a)[5] == (b)[5] && \
 479	(a)[4] == (b)[4] && \
 480	(a)[3] == (b)[3] && \
 481	(a)[2] == (b)[2] && \
 482	(a)[1] == (b)[1] && \
 483	(a)[0] == (b)[0])
 484
 485static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr)
 486{
 487	/* called when scsi_add_device fails in order to re-adjust */
 488	/* ccissscsi[] to match the mid layer's view. */
 489	unsigned long flags;
 490	int i, j;
 491	CPQ_TAPE_LOCK(h, flags);
 492	for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
 493		if (memcmp(scsi3addr,
 494				ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) {
 495			for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++)
 496				ccissscsi[h->ctlr].dev[j] =
 497					ccissscsi[h->ctlr].dev[j+1];
 498			ccissscsi[h->ctlr].ndevices--;
 499			break;
 500		}
 501	}
 502	CPQ_TAPE_UNLOCK(h, flags);
 503}
 504
 505static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
 506	struct cciss_scsi_dev_t *dev2)
 507{
 508	return dev1->devtype == dev2->devtype &&
 509		memcmp(dev1->scsi3addr, dev2->scsi3addr,
 510			sizeof(dev1->scsi3addr)) == 0 &&
 511		memcmp(dev1->device_id, dev2->device_id,
 512			sizeof(dev1->device_id)) == 0 &&
 513		memcmp(dev1->vendor, dev2->vendor,
 514			sizeof(dev1->vendor)) == 0 &&
 515		memcmp(dev1->model, dev2->model,
 516			sizeof(dev1->model)) == 0 &&
 517		memcmp(dev1->revision, dev2->revision,
 518			sizeof(dev1->revision)) == 0;
 519}
 520
 521static int
 522adjust_cciss_scsi_table(ctlr_info_t *h, int hostno,
 523	struct cciss_scsi_dev_t sd[], int nsds)
 524{
 525	/* sd contains scsi3 addresses and devtypes, but
 526	   bus target and lun are not filled in.  This funciton
 527	   takes what's in sd to be the current and adjusts
 528	   ccissscsi[] to be in line with what's in sd. */ 
 529
 530	int i,j, found, changes=0;
 531	struct cciss_scsi_dev_t *csd;
 532	unsigned long flags;
 533	struct scsi2map *added, *removed;
 534	int nadded, nremoved;
 535	struct Scsi_Host *sh = NULL;
 536
 537	added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
 538			GFP_KERNEL);
 539	removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
 540			GFP_KERNEL);
 541
 542	if (!added || !removed) {
 543		dev_warn(&h->pdev->dev,
 544			"Out of memory in adjust_cciss_scsi_table\n");
 545		goto free_and_out;
 546	}
 547
 548	CPQ_TAPE_LOCK(h, flags);
 549
 550	if (hostno != -1)  /* if it's not the first time... */
 551		sh = h->scsi_ctlr->scsi_host;
 552
 553	/* find any devices in ccissscsi[] that are not in 
 554	   sd[] and remove them from ccissscsi[] */
 555
 556	i = 0;
 557	nremoved = 0;
 558	nadded = 0;
 559	while (i < ccissscsi[h->ctlr].ndevices) {
 560		csd = &ccissscsi[h->ctlr].dev[i];
 561		found=0;
 562		for (j=0;j<nsds;j++) {
 563			if (SCSI3ADDR_EQ(sd[j].scsi3addr,
 564				csd->scsi3addr)) {
 565				if (device_is_the_same(&sd[j], csd))
 566					found=2;
 567				else
 568					found=1;
 569				break;
 570			}
 571		}
 572
 573		if (found == 0) { /* device no longer present. */ 
 574			changes++;
 575			cciss_scsi_remove_entry(h, hostno, i,
 576				removed, &nremoved);
 577			/* remove ^^^, hence i not incremented */
 578		} else if (found == 1) { /* device is different in some way */
 579			changes++;
 580			dev_info(&h->pdev->dev,
 581				"device c%db%dt%dl%d has changed.\n",
 582				hostno, csd->bus, csd->target, csd->lun);
 583			cciss_scsi_remove_entry(h, hostno, i,
 584				removed, &nremoved);
 585			/* remove ^^^, hence i not incremented */
 586			if (cciss_scsi_add_entry(h, hostno, &sd[j],
 587				added, &nadded) != 0)
 588				/* we just removed one, so add can't fail. */
 589					BUG();
 590			csd->devtype = sd[j].devtype;
 591			memcpy(csd->device_id, sd[j].device_id,
 592				sizeof(csd->device_id));
 593			memcpy(csd->vendor, sd[j].vendor,
 594				sizeof(csd->vendor));
 595			memcpy(csd->model, sd[j].model,
 596				sizeof(csd->model));
 597			memcpy(csd->revision, sd[j].revision,
 598				sizeof(csd->revision));
 599		} else 		/* device is same as it ever was, */
 600			i++;	/* so just move along. */
 601	}
 602
 603	/* Now, make sure every device listed in sd[] is also
 604 	   listed in ccissscsi[], adding them if they aren't found */
 605
 606	for (i=0;i<nsds;i++) {
 607		found=0;
 608		for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) {
 609			csd = &ccissscsi[h->ctlr].dev[j];
 610			if (SCSI3ADDR_EQ(sd[i].scsi3addr,
 611				csd->scsi3addr)) {
 612				if (device_is_the_same(&sd[i], csd))
 613					found=2;	/* found device */
 614				else
 615					found=1; 	/* found a bug. */
 616				break;
 617			}
 618		}
 619		if (!found) {
 620			changes++;
 621			if (cciss_scsi_add_entry(h, hostno, &sd[i],
 622				added, &nadded) != 0)
 623				break;
 624		} else if (found == 1) {
 625			/* should never happen... */
 626			changes++;
 627			dev_warn(&h->pdev->dev,
 628				"device unexpectedly changed\n");
 629			/* but if it does happen, we just ignore that device */
 630		}
 631	}
 632	CPQ_TAPE_UNLOCK(h, flags);
 633
 634	/* Don't notify scsi mid layer of any changes the first time through */
 635	/* (or if there are no changes) scsi_scan_host will do it later the */
 636	/* first time through. */
 637	if (hostno == -1 || !changes)
 638		goto free_and_out;
 639
 640	/* Notify scsi mid layer of any removed devices */
 641	for (i = 0; i < nremoved; i++) {
 642		struct scsi_device *sdev =
 643			scsi_device_lookup(sh, removed[i].bus,
 644				removed[i].target, removed[i].lun);
 645		if (sdev != NULL) {
 646			scsi_remove_device(sdev);
 647			scsi_device_put(sdev);
 648		} else {
 649			/* We don't expect to get here. */
 650			/* future cmds to this device will get selection */
 651			/* timeout as if the device was gone. */
 652			dev_warn(&h->pdev->dev, "didn't find "
 653				"c%db%dt%dl%d\n for removal.",
 654				hostno, removed[i].bus,
 655				removed[i].target, removed[i].lun);
 656		}
 657	}
 658
 659	/* Notify scsi mid layer of any added devices */
 660	for (i = 0; i < nadded; i++) {
 661		int rc;
 662		rc = scsi_add_device(sh, added[i].bus,
 663			added[i].target, added[i].lun);
 664		if (rc == 0)
 665			continue;
 666		dev_warn(&h->pdev->dev, "scsi_add_device "
 667			"c%db%dt%dl%d failed, device not added.\n",
 668			hostno, added[i].bus, added[i].target, added[i].lun);
 669		/* now we have to remove it from ccissscsi, */
 670		/* since it didn't get added to scsi mid layer */
 671		fixup_botched_add(h, added[i].scsi3addr);
 672	}
 673
 674free_and_out:
 675	kfree(added);
 676	kfree(removed);
 677	return 0;
 678}
 679
 680static int
 681lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr)
 682{
 683	int i;
 684	struct cciss_scsi_dev_t *sd;
 685	unsigned long flags;
 686
 687	CPQ_TAPE_LOCK(h, flags);
 688	for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
 689		sd = &ccissscsi[h->ctlr].dev[i];
 690		if (sd->bus == bus &&
 691		    sd->target == target &&
 692		    sd->lun == lun) {
 693			memcpy(scsi3addr, &sd->scsi3addr[0], 8);
 694			CPQ_TAPE_UNLOCK(h, flags);
 695			return 0;
 696		}
 697	}
 698	CPQ_TAPE_UNLOCK(h, flags);
 699	return -1;
 700}
 701
 702static void 
 703cciss_scsi_setup(ctlr_info_t *h)
 704{
 705	struct cciss_scsi_adapter_data_t * shba;
 706
 707	ccissscsi[h->ctlr].ndevices = 0;
 708	shba = (struct cciss_scsi_adapter_data_t *)
 709		kmalloc(sizeof(*shba), GFP_KERNEL);	
 710	if (shba == NULL)
 711		return;
 712	shba->scsi_host = NULL;
 713	spin_lock_init(&shba->lock);
 714	shba->registered = 0;
 715	if (scsi_cmd_stack_setup(h, shba) != 0) {
 716		kfree(shba);
 717		shba = NULL;
 718	}
 719	h->scsi_ctlr = shba;
 720	return;
 721}
 722
 723static void complete_scsi_command(CommandList_struct *c, int timeout,
 724	__u32 tag)
 725{
 726	struct scsi_cmnd *cmd;
 727	ctlr_info_t *h;
 728	ErrorInfo_struct *ei;
 729
 730	ei = c->err_info;
 731
 732	/* First, see if it was a message rather than a command */
 733	if (c->Request.Type.Type == TYPE_MSG)  {
 734		c->cmd_type = CMD_MSG_DONE;
 735		return;
 736	}
 737
 738	cmd = (struct scsi_cmnd *) c->scsi_cmd;
 739	h = hba[c->ctlr];
 740
 741	scsi_dma_unmap(cmd);
 742	if (c->Header.SGTotal > h->max_cmd_sgentries)
 743		cciss_unmap_sg_chain_block(h, c);
 744
 745	cmd->result = (DID_OK << 16); 		/* host byte */
 746	cmd->result |= (COMMAND_COMPLETE << 8);	/* msg byte */
 747	/* cmd->result |= (GOOD < 1); */		/* status byte */
 748
 749	cmd->result |= (ei->ScsiStatus);
 750	/* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus);  */
 751
 752	/* copy the sense data whether we need to or not. */
 753
 754	memcpy(cmd->sense_buffer, ei->SenseInfo, 
 755		ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
 756			SCSI_SENSE_BUFFERSIZE : 
 757			ei->SenseLen);
 758	scsi_set_resid(cmd, ei->ResidualCnt);
 759
 760	if(ei->CommandStatus != 0) 
 761	{ /* an error has occurred */ 
 762		switch(ei->CommandStatus)
 763		{
 764			case CMD_TARGET_STATUS:
 765				/* Pass it up to the upper layers... */
 766				if( ei->ScsiStatus)
 767                		{
 768#if 0
 769                    			printk(KERN_WARNING "cciss: cmd %p "
 770						"has SCSI Status = %x\n",
 771						c, ei->ScsiStatus);
 772#endif
 773					cmd->result |= (ei->ScsiStatus << 1);
 774                		}
 775				else {  /* scsi status is zero??? How??? */
 776					
 777	/* Ordinarily, this case should never happen, but there is a bug
 778	   in some released firmware revisions that allows it to happen
 779	   if, for example, a 4100 backplane loses power and the tape
 780	   drive is in it.  We assume that it's a fatal error of some
 781	   kind because we can't show that it wasn't. We will make it
 782	   look like selection timeout since that is the most common
 783	   reason for this to occur, and it's severe enough. */
 784
 785					cmd->result = DID_NO_CONNECT << 16;
 786				}
 787			break;
 788			case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 789			break;
 790			case CMD_DATA_OVERRUN:
 791				dev_warn(&h->pdev->dev, "%p has"
 792					" completed with data overrun "
 793					"reported\n", c);
 794			break;
 795			case CMD_INVALID: {
 796				/* print_bytes(c, sizeof(*c), 1, 0);
 797				print_cmd(c); */
 798     /* We get CMD_INVALID if you address a non-existent tape drive instead
 799	of a selection timeout (no response).  You will see this if you yank 
 800	out a tape drive, then try to access it. This is kind of a shame
 801	because it means that any other CMD_INVALID (e.g. driver bug) will
 802	get interpreted as a missing target. */
 803				cmd->result = DID_NO_CONNECT << 16;
 804				}
 805			break;
 806			case CMD_PROTOCOL_ERR:
 
 807				dev_warn(&h->pdev->dev,
 808					"%p has protocol error\n", c);
 809                        break;
 810			case CMD_HARDWARE_ERR:
 811				cmd->result = DID_ERROR << 16;
 812				dev_warn(&h->pdev->dev,
 813					"%p had hardware error\n", c);
 814                        break;
 815			case CMD_CONNECTION_LOST:
 816				cmd->result = DID_ERROR << 16;
 817				dev_warn(&h->pdev->dev,
 818					"%p had connection lost\n", c);
 819			break;
 820			case CMD_ABORTED:
 821				cmd->result = DID_ABORT << 16;
 822				dev_warn(&h->pdev->dev, "%p was aborted\n", c);
 823			break;
 824			case CMD_ABORT_FAILED:
 825				cmd->result = DID_ERROR << 16;
 826				dev_warn(&h->pdev->dev,
 827					"%p reports abort failed\n", c);
 828			break;
 829			case CMD_UNSOLICITED_ABORT:
 830				cmd->result = DID_ABORT << 16;
 831				dev_warn(&h->pdev->dev, "%p aborted due to an "
 832					"unsolicited abort\n", c);
 833			break;
 834			case CMD_TIMEOUT:
 835				cmd->result = DID_TIME_OUT << 16;
 836				dev_warn(&h->pdev->dev, "%p timedout\n", c);
 837			break;
 838			case CMD_UNABORTABLE:
 839				cmd->result = DID_ERROR << 16;
 840				dev_warn(&h->pdev->dev, "c %p command "
 841					"unabortable\n", c);
 842			break;
 843			default:
 844				cmd->result = DID_ERROR << 16;
 845				dev_warn(&h->pdev->dev,
 846					"%p returned unknown status %x\n", c,
 847						ei->CommandStatus); 
 848		}
 849	}
 850	cmd->scsi_done(cmd);
 851	scsi_cmd_free(h, c);
 852}
 853
 854static int
 855cciss_scsi_detect(ctlr_info_t *h)
 856{
 857	struct Scsi_Host *sh;
 858	int error;
 859
 860	sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
 861	if (sh == NULL)
 862		goto fail;
 863	sh->io_port = 0;	// good enough?  FIXME, 
 864	sh->n_io_port = 0;	// I don't think we use these two...
 865	sh->this_id = SELF_SCSI_ID;  
 866	sh->can_queue = cciss_tape_cmds;
 867	sh->sg_tablesize = h->maxsgentries;
 868	sh->max_cmd_len = MAX_COMMAND_SIZE;
 
 869
 870	((struct cciss_scsi_adapter_data_t *) 
 871		h->scsi_ctlr)->scsi_host = sh;
 872	sh->hostdata[0] = (unsigned long) h;
 873	sh->irq = h->intr[SIMPLE_MODE_INT];
 874	sh->unique_id = sh->irq;
 875	error = scsi_add_host(sh, &h->pdev->dev);
 876	if (error)
 877		goto fail_host_put;
 878	scsi_scan_host(sh);
 879	return 1;
 880
 881 fail_host_put:
 882	scsi_host_put(sh);
 883 fail:
 884	return 0;
 885}
 886
 887static void
 888cciss_unmap_one(struct pci_dev *pdev,
 889		CommandList_struct *c,
 890		size_t buflen,
 891		int data_direction)
 892{
 893	u64bit addr64;
 894
 895	addr64.val32.lower = c->SG[0].Addr.lower;
 896	addr64.val32.upper = c->SG[0].Addr.upper;
 897	pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
 898}
 899
 900static void
 901cciss_map_one(struct pci_dev *pdev,
 902		CommandList_struct *c,
 903		unsigned char *buf,
 904		size_t buflen,
 905		int data_direction)
 906{
 907	__u64 addr64;
 908
 909	addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
 910	c->SG[0].Addr.lower =
 911	  (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
 912	c->SG[0].Addr.upper =
 913	  (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
 914	c->SG[0].Len = buflen;
 915	c->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
 916	c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
 917}
 918
 919static int
 920cciss_scsi_do_simple_cmd(ctlr_info_t *h,
 921			CommandList_struct *c,
 922			unsigned char *scsi3addr, 
 923			unsigned char *cdb,
 924			unsigned char cdblen,
 925			unsigned char *buf, int bufsize,
 926			int direction)
 927{
 928	DECLARE_COMPLETION_ONSTACK(wait);
 929
 930	c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
 931	c->scsi_cmd = NULL;
 932	c->Header.ReplyQueue = 0;  /* unused in simple mode */
 933	memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
 934	c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
 935	// Fill in the request block...
 936
 937	/* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", 
 938		scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
 939		scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
 940
 941	memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
 942	memcpy(c->Request.CDB, cdb, cdblen);
 943	c->Request.Timeout = 0;
 944	c->Request.CDBLen = cdblen;
 945	c->Request.Type.Type = TYPE_CMD;
 946	c->Request.Type.Attribute = ATTR_SIMPLE;
 947	c->Request.Type.Direction = direction;
 948
 949	/* Fill in the SG list and do dma mapping */
 950	cciss_map_one(h->pdev, c, (unsigned char *) buf,
 951			bufsize, DMA_FROM_DEVICE); 
 952
 953	c->waiting = &wait;
 954	enqueue_cmd_and_start_io(h, c);
 955	wait_for_completion(&wait);
 956
 957	/* undo the dma mapping */
 958	cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
 959	return(0);
 960}
 961
 962static void 
 963cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
 964{
 965	ErrorInfo_struct *ei;
 966
 967	ei = c->err_info;
 968	switch(ei->CommandStatus)
 969	{
 970		case CMD_TARGET_STATUS:
 971			dev_warn(&h->pdev->dev,
 972				"cmd %p has completed with errors\n", c);
 973			dev_warn(&h->pdev->dev,
 974				"cmd %p has SCSI Status = %x\n",
 975				c, ei->ScsiStatus);
 976			if (ei->ScsiStatus == 0)
 977				dev_warn(&h->pdev->dev,
 978				"SCSI status is abnormally zero.  "
 979				"(probably indicates selection timeout "
 980				"reported incorrectly due to a known "
 981				"firmware bug, circa July, 2001.)\n");
 982		break;
 983		case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 984			dev_info(&h->pdev->dev, "UNDERRUN\n");
 985		break;
 986		case CMD_DATA_OVERRUN:
 987			dev_warn(&h->pdev->dev, "%p has"
 988				" completed with data overrun "
 989				"reported\n", c);
 990		break;
 991		case CMD_INVALID: {
 992			/* controller unfortunately reports SCSI passthru's */
 993			/* to non-existent targets as invalid commands. */
 994			dev_warn(&h->pdev->dev,
 995				"%p is reported invalid (probably means "
 996				"target device no longer present)\n", c);
 997			/* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
 998			print_cmd(c);  */
 999			}
1000		break;
1001		case CMD_PROTOCOL_ERR:
1002			dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
1003		break;
1004		case CMD_HARDWARE_ERR:
1005			/* cmd->result = DID_ERROR << 16; */
1006			dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
1007		break;
1008		case CMD_CONNECTION_LOST:
1009			dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
1010		break;
1011		case CMD_ABORTED:
1012			dev_warn(&h->pdev->dev, "%p was aborted\n", c);
1013		break;
1014		case CMD_ABORT_FAILED:
1015			dev_warn(&h->pdev->dev,
1016				"%p reports abort failed\n", c);
1017		break;
1018		case CMD_UNSOLICITED_ABORT:
1019			dev_warn(&h->pdev->dev,
1020				"%p aborted due to an unsolicited abort\n", c);
1021		break;
1022		case CMD_TIMEOUT:
1023			dev_warn(&h->pdev->dev, "%p timedout\n", c);
1024		break;
1025		case CMD_UNABORTABLE:
1026			dev_warn(&h->pdev->dev,
1027				"%p unabortable\n", c);
1028		break;
1029		default:
1030			dev_warn(&h->pdev->dev,
1031				"%p returned unknown status %x\n",
1032				c, ei->CommandStatus);
1033	}
1034}
1035
1036static int
1037cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
1038	unsigned char page, unsigned char *buf,
1039	unsigned char bufsize)
1040{
1041	int rc;
1042	CommandList_struct *c;
1043	char cdb[6];
1044	ErrorInfo_struct *ei;
1045	unsigned long flags;
1046
1047	spin_lock_irqsave(&h->lock, flags);
1048	c = scsi_cmd_alloc(h);
1049	spin_unlock_irqrestore(&h->lock, flags);
1050
1051	if (c == NULL) {			/* trouble... */
1052		printk("cmd_alloc returned NULL!\n");
1053		return -1;
1054	}
1055
1056	ei = c->err_info;
1057
1058	cdb[0] = CISS_INQUIRY;
1059	cdb[1] = (page != 0);
1060	cdb[2] = page;
1061	cdb[3] = 0;
1062	cdb[4] = bufsize;
1063	cdb[5] = 0;
1064	rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
1065				6, buf, bufsize, XFER_READ);
1066
1067	if (rc != 0) return rc; /* something went wrong */
1068
1069	if (ei->CommandStatus != 0 && 
1070	    ei->CommandStatus != CMD_DATA_UNDERRUN) {
1071		cciss_scsi_interpret_error(h, c);
1072		rc = -1;
1073	}
1074	spin_lock_irqsave(&h->lock, flags);
1075	scsi_cmd_free(h, c);
1076	spin_unlock_irqrestore(&h->lock, flags);
1077	return rc;	
1078}
1079
1080/* Get the device id from inquiry page 0x83 */
1081static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
1082	unsigned char *device_id, int buflen)
1083{
1084	int rc;
1085	unsigned char *buf;
1086
1087	if (buflen > 16)
1088		buflen = 16;
1089	buf = kzalloc(64, GFP_KERNEL);
1090	if (!buf)
1091		return -1;
1092	rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
1093	if (rc == 0)
1094		memcpy(device_id, &buf[8], buflen);
1095	kfree(buf);
1096	return rc != 0;
1097}
1098
1099static int
1100cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
1101		ReportLunData_struct *buf, int bufsize)
1102{
1103	int rc;
1104	CommandList_struct *c;
1105	unsigned char cdb[12];
1106	unsigned char scsi3addr[8]; 
1107	ErrorInfo_struct *ei;
1108	unsigned long flags;
1109
1110	spin_lock_irqsave(&h->lock, flags);
1111	c = scsi_cmd_alloc(h);
1112	spin_unlock_irqrestore(&h->lock, flags);
1113	if (c == NULL) {			/* trouble... */
1114		printk("cmd_alloc returned NULL!\n");
1115		return -1;
1116	}
1117
1118	memset(&scsi3addr[0], 0, 8); /* address the controller */
1119	cdb[0] = CISS_REPORT_PHYS;
1120	cdb[1] = 0;
1121	cdb[2] = 0;
1122	cdb[3] = 0;
1123	cdb[4] = 0;
1124	cdb[5] = 0;
1125	cdb[6] = (bufsize >> 24) & 0xFF;  //MSB
1126	cdb[7] = (bufsize >> 16) & 0xFF;
1127	cdb[8] = (bufsize >> 8) & 0xFF;
1128	cdb[9] = bufsize & 0xFF;
1129	cdb[10] = 0;
1130	cdb[11] = 0;
1131
1132	rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
1133				cdb, 12, 
1134				(unsigned char *) buf, 
1135				bufsize, XFER_READ);
1136
1137	if (rc != 0) return rc; /* something went wrong */
1138
1139	ei = c->err_info;
1140	if (ei->CommandStatus != 0 && 
1141	    ei->CommandStatus != CMD_DATA_UNDERRUN) {
1142		cciss_scsi_interpret_error(h, c);
1143		rc = -1;
1144	}
1145	spin_lock_irqsave(&h->lock, flags);
1146	scsi_cmd_free(h, c);
1147	spin_unlock_irqrestore(&h->lock, flags);
1148	return rc;	
1149}
1150
1151static void
1152cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
1153{
1154	/* the idea here is we could get notified from /proc
1155	   that some devices have changed, so we do a report 
1156	   physical luns cmd, and adjust our list of devices 
1157	   accordingly.  (We can't rely on the scsi-mid layer just
1158	   doing inquiries, because the "busses" that the scsi 
1159	   mid-layer probes are totally fabricated by this driver,
1160	   so new devices wouldn't show up.
1161
1162	   the scsi3addr's of devices won't change so long as the 
1163	   adapter is not reset.  That means we can rescan and 
1164	   tell which devices we already know about, vs. new 
1165	   devices, vs.  disappearing devices.
1166
1167	   Also, if you yank out a tape drive, then put in a disk
1168	   in it's place, (say, a configured volume from another 
1169	   array controller for instance)  _don't_ poke this driver 
1170           (so it thinks it's still a tape, but _do_ poke the scsi 
1171           mid layer, so it does an inquiry... the scsi mid layer 
1172           will see the physical disk.  This would be bad.  Need to
1173	   think about how to prevent that.  One idea would be to 
1174	   snoop all scsi responses and if an inquiry repsonse comes
1175	   back that reports a disk, chuck it an return selection
1176	   timeout instead and adjust our table...  Not sure i like
1177	   that though.  
1178
1179	 */
1180#define OBDR_TAPE_INQ_SIZE 49
1181#define OBDR_TAPE_SIG "$DR-10"
1182	ReportLunData_struct *ld_buff;
1183	unsigned char *inq_buff;
1184	unsigned char scsi3addr[8];
1185	__u32 num_luns=0;
1186	unsigned char *ch;
1187	struct cciss_scsi_dev_t *currentsd, *this_device;
1188	int ncurrent=0;
1189	int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1190	int i;
1191
1192	ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1193	inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1194	currentsd = kzalloc(sizeof(*currentsd) *
1195			(CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1196	if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1197		printk(KERN_ERR "cciss: out of memory\n");
1198		goto out;
1199	}
1200	this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1201	if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
1202		ch = &ld_buff->LUNListLength[0];
1203		num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1204		if (num_luns > CISS_MAX_PHYS_LUN) {
1205			printk(KERN_WARNING 
1206				"cciss: Maximum physical LUNs (%d) exceeded.  "
1207				"%d LUNs ignored.\n", CISS_MAX_PHYS_LUN, 
1208				num_luns - CISS_MAX_PHYS_LUN);
1209			num_luns = CISS_MAX_PHYS_LUN;
1210		}
1211	}
1212	else {
1213		printk(KERN_ERR  "cciss: Report physical LUNs failed.\n");
1214		goto out;
1215	}
1216
1217
1218	/* adjust our table of devices */	
1219	for (i = 0; i < num_luns; i++) {
1220		/* for each physical lun, do an inquiry */
1221		if (ld_buff->LUN[i][3] & 0xC0) continue;
1222		memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1223		memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1224
1225		if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
1226			(unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1227			/* Inquiry failed (msg printed already) */
1228			continue; /* so we will skip this device. */
1229
1230		this_device->devtype = (inq_buff[0] & 0x1f);
1231		this_device->bus = -1;
1232		this_device->target = -1;
1233		this_device->lun = -1;
1234		memcpy(this_device->scsi3addr, scsi3addr, 8);
1235		memcpy(this_device->vendor, &inq_buff[8],
1236			sizeof(this_device->vendor));
1237		memcpy(this_device->model, &inq_buff[16],
1238			sizeof(this_device->model));
1239		memcpy(this_device->revision, &inq_buff[32],
1240			sizeof(this_device->revision));
1241		memset(this_device->device_id, 0,
1242			sizeof(this_device->device_id));
1243		cciss_scsi_get_device_id(h, scsi3addr,
1244			this_device->device_id, sizeof(this_device->device_id));
1245
1246		switch (this_device->devtype)
1247		{
1248		  case 0x05: /* CD-ROM */ {
1249
1250			/* We don't *really* support actual CD-ROM devices,
1251			 * just this "One Button Disaster Recovery" tape drive
1252			 * which temporarily pretends to be a CD-ROM drive.
1253			 * So we check that the device is really an OBDR tape
1254			 * device by checking for "$DR-10" in bytes 43-48 of
1255			 * the inquiry data.
1256			 */
1257				char obdr_sig[7];
1258
1259				strncpy(obdr_sig, &inq_buff[43], 6);
1260				obdr_sig[6] = '\0';
1261				if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1262					/* Not OBDR device, ignore it. */
1263					break;
1264			}
1265			/* fall through . . . */
1266		  case 0x01: /* sequential access, (tape) */
1267		  case 0x08: /* medium changer */
1268			if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1269				printk(KERN_INFO "cciss%d: %s ignored, "
1270					"too many devices.\n", h->ctlr,
1271					scsi_device_type(this_device->devtype));
1272				break;
1273			}
1274			currentsd[ncurrent] = *this_device;
1275			ncurrent++;
1276			break;
1277		  default: 
1278			break;
1279		}
1280	}
1281
1282	adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
1283out:
1284	kfree(inq_buff);
1285	kfree(ld_buff);
1286	kfree(currentsd);
1287	return;
1288}
1289
1290static int
1291is_keyword(char *ptr, int len, char *verb)  // Thanks to ncr53c8xx.c
1292{
1293	int verb_len = strlen(verb);
1294	if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1295		return verb_len;
1296	else
1297		return 0;
1298}
1299
1300static int
1301cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
1302{
1303	int arg_len;
1304
1305	if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1306		cciss_update_non_disk_devices(h, hostno);
1307	else
1308		return -EINVAL;
1309	return length;
1310}
1311
1312
1313static int
1314cciss_scsi_proc_info(struct Scsi_Host *sh,
1315		char *buffer, /* data buffer */
1316		char **start, 	   /* where data in buffer starts */
1317		off_t offset,	   /* offset from start of imaginary file */
1318		int length, 	   /* length of data in buffer */
1319		int func)	   /* 0 == read, 1 == write */
1320{
 
 
 
1321
1322	int buflen, datalen;
1323	ctlr_info_t *h;
 
 
 
 
 
 
 
1324	int i;
1325
1326	h = (ctlr_info_t *) sh->hostdata[0];
1327	if (h == NULL)  /* This really shouldn't ever happen. */
1328		return -EINVAL;
1329
1330	if (func == 0) {	/* User is reading from /proc/scsi/ciss*?/?*  */
1331		buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1332				h->ctlr, sh->host_no);
1333
1334		/* this information is needed by apps to know which cciss
1335		   device corresponds to which scsi host number without
1336		   having to open a scsi target device node.  The device
1337		   information is not a duplicate of /proc/scsi/scsi because
1338		   the two may be out of sync due to scsi hotplug, rather
1339		   this info is for an app to be able to use to know how to
1340		   get them back in sync. */
1341
1342		for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1343			struct cciss_scsi_dev_t *sd =
1344				&ccissscsi[h->ctlr].dev[i];
1345			buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1346				"0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1347				sh->host_no, sd->bus, sd->target, sd->lun,
1348				sd->devtype,
1349				sd->scsi3addr[0], sd->scsi3addr[1],
1350				sd->scsi3addr[2], sd->scsi3addr[3],
1351				sd->scsi3addr[4], sd->scsi3addr[5],
1352				sd->scsi3addr[6], sd->scsi3addr[7]);
1353		}
1354		datalen = buflen - offset;
1355		if (datalen < 0) { 	/* they're reading past EOF. */
1356			datalen = 0;
1357			*start = buffer+buflen;	
1358		} else
1359			*start = buffer + offset;
1360		return(datalen);
1361	} else 	/* User is writing to /proc/scsi/cciss*?/?*  ... */
1362		return cciss_scsi_user_command(h, sh->host_no,
1363			buffer, length);	
1364} 
1365
1366/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci 
1367   dma mapping  and fills in the scatter gather entries of the 
1368   cciss command, c. */
1369
1370static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
1371	struct scsi_cmnd *cmd)
1372{
1373	unsigned int len;
1374	struct scatterlist *sg;
1375	__u64 addr64;
1376	int request_nsgs, i, chained, sg_index;
1377	struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1378	SGDescriptor_struct *curr_sg;
1379
1380	BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1381
1382	chained = 0;
1383	sg_index = 0;
1384	curr_sg = c->SG;
1385	request_nsgs = scsi_dma_map(cmd);
1386	if (request_nsgs) {
1387		scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1388			if (sg_index + 1 == h->max_cmd_sgentries &&
1389				!chained && request_nsgs - i > 1) {
1390				chained = 1;
1391				sg_index = 0;
1392				curr_sg = sa->cmd_sg_list[c->cmdindex];
1393			}
1394			addr64 = (__u64) sg_dma_address(sg);
1395			len  = sg_dma_len(sg);
1396			curr_sg[sg_index].Addr.lower =
1397				(__u32) (addr64 & 0x0FFFFFFFFULL);
1398			curr_sg[sg_index].Addr.upper =
1399				(__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1400			curr_sg[sg_index].Len = len;
1401			curr_sg[sg_index].Ext = 0;
1402			++sg_index;
1403		}
1404		if (chained)
1405			cciss_map_sg_chain_block(h, c,
1406				sa->cmd_sg_list[c->cmdindex],
1407				(request_nsgs - (h->max_cmd_sgentries - 1)) *
1408					sizeof(SGDescriptor_struct));
1409	}
1410	/* track how many SG entries we are using */
1411	if (request_nsgs > h->maxSG)
1412		h->maxSG = request_nsgs;
1413	c->Header.SGTotal = (__u8) request_nsgs + chained;
1414	if (request_nsgs > h->max_cmd_sgentries)
1415		c->Header.SGList = h->max_cmd_sgentries;
1416	else
1417		c->Header.SGList = c->Header.SGTotal;
1418	return;
1419}
1420
1421
1422static int
1423cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1424{
1425	ctlr_info_t *h;
1426	int rc;
1427	unsigned char scsi3addr[8];
1428	CommandList_struct *c;
1429	unsigned long flags;
1430
1431	// Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1432	// We violate cmd->host privacy here.  (Is there another way?)
1433	h = (ctlr_info_t *) cmd->device->host->hostdata[0];
1434
1435	rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
1436			cmd->device->lun, scsi3addr);
1437	if (rc != 0) {
1438		/* the scsi nexus does not match any that we presented... */
1439		/* pretend to mid layer that we got selection timeout */
1440		cmd->result = DID_NO_CONNECT << 16;
1441		done(cmd);
1442		/* we might want to think about registering controller itself
1443		   as a processor device on the bus so sg binds to it. */
1444		return 0;
1445	}
1446
1447	/* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1448           see what the device thinks of it. */
1449
1450	spin_lock_irqsave(&h->lock, flags);
1451	c = scsi_cmd_alloc(h);
1452	spin_unlock_irqrestore(&h->lock, flags);
1453	if (c == NULL) {			/* trouble... */
1454		dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
1455		/* FIXME: next 3 lines are -> BAD! <- */
1456		cmd->result = DID_NO_CONNECT << 16;
1457		done(cmd);
1458		return 0;
1459	}
1460
1461	// Fill in the command list header
1462
1463	cmd->scsi_done = done;    // save this for use by completion code 
1464
1465	/* save c in case we have to abort it */
1466	cmd->host_scribble = (unsigned char *) c;
1467
1468	c->cmd_type = CMD_SCSI;
1469	c->scsi_cmd = cmd;
1470	c->Header.ReplyQueue = 0;  /* unused in simple mode */
1471	memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1472	c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
1473	
1474	// Fill in the request block...
1475
1476	c->Request.Timeout = 0;
1477	memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1478	BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1479	c->Request.CDBLen = cmd->cmd_len;
1480	memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1481	c->Request.Type.Type = TYPE_CMD;
1482	c->Request.Type.Attribute = ATTR_SIMPLE;
1483	switch(cmd->sc_data_direction)
1484	{
1485	  case DMA_TO_DEVICE:
1486		c->Request.Type.Direction = XFER_WRITE;
1487		break;
1488	  case DMA_FROM_DEVICE:
1489		c->Request.Type.Direction = XFER_READ;
1490		break;
1491	  case DMA_NONE:
1492		c->Request.Type.Direction = XFER_NONE;
1493		break;
1494	  case DMA_BIDIRECTIONAL:
1495		// This can happen if a buggy application does a scsi passthru
1496		// and sets both inlen and outlen to non-zero. ( see
1497		// ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1498
1499		c->Request.Type.Direction = XFER_RSVD;
1500		// This is technically wrong, and cciss controllers should
1501		// reject it with CMD_INVALID, which is the most correct 
1502		// response, but non-fibre backends appear to let it 
1503		// slide by, and give the same results as if this field
1504		// were set correctly.  Either way is acceptable for
1505		// our purposes here.
1506
1507		break;
1508
1509	  default: 
1510		dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
1511			cmd->sc_data_direction);
1512		BUG();
1513		break;
1514	}
1515	cciss_scatter_gather(h, c, cmd);
1516	enqueue_cmd_and_start_io(h, c);
1517	/* the cmd'll come back via intr handler in complete_scsi_command()  */
1518	return 0;
1519}
1520
1521static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1522
1523static void cciss_unregister_scsi(ctlr_info_t *h)
1524{
1525	struct cciss_scsi_adapter_data_t *sa;
1526	struct cciss_scsi_cmd_stack_t *stk;
1527	unsigned long flags;
1528
1529	/* we are being forcibly unloaded, and may not refuse. */
1530
1531	spin_lock_irqsave(&h->lock, flags);
1532	sa = h->scsi_ctlr;
1533	stk = &sa->cmd_stack; 
1534
1535	/* if we weren't ever actually registered, don't unregister */ 
1536	if (sa->registered) {
1537		spin_unlock_irqrestore(&h->lock, flags);
1538		scsi_remove_host(sa->scsi_host);
1539		scsi_host_put(sa->scsi_host);
1540		spin_lock_irqsave(&h->lock, flags);
1541	}
1542
1543	/* set scsi_host to NULL so our detect routine will 
1544	   find us on register */
1545	sa->scsi_host = NULL;
1546	spin_unlock_irqrestore(&h->lock, flags);
1547	scsi_cmd_stack_free(h);
1548	kfree(sa);
1549}
1550
1551static int cciss_engage_scsi(ctlr_info_t *h)
1552{
1553	struct cciss_scsi_adapter_data_t *sa;
1554	struct cciss_scsi_cmd_stack_t *stk;
1555	unsigned long flags;
1556
1557	spin_lock_irqsave(&h->lock, flags);
1558	sa = h->scsi_ctlr;
1559	stk = &sa->cmd_stack; 
1560
1561	if (sa->registered) {
1562		dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
1563		spin_unlock_irqrestore(&h->lock, flags);
1564		return -ENXIO;
1565	}
1566	sa->registered = 1;
1567	spin_unlock_irqrestore(&h->lock, flags);
1568	cciss_update_non_disk_devices(h, -1);
1569	cciss_scsi_detect(h);
1570	return 0;
1571}
1572
1573static void
1574cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
1575{
1576	unsigned long flags;
1577
1578	CPQ_TAPE_LOCK(h, flags);
1579	seq_printf(seq,
1580		"Sequential access devices: %d\n\n",
1581			ccissscsi[h->ctlr].ndevices);
1582	CPQ_TAPE_UNLOCK(h, flags);
1583}
1584
1585static int wait_for_device_to_become_ready(ctlr_info_t *h,
1586	unsigned char lunaddr[])
1587{
1588	int rc;
1589	int count = 0;
1590	int waittime = HZ;
1591	CommandList_struct *c;
1592
1593	c = cmd_alloc(h);
1594	if (!c) {
1595		dev_warn(&h->pdev->dev, "out of memory in "
1596			"wait_for_device_to_become_ready.\n");
1597		return IO_ERROR;
1598	}
1599
1600	/* Send test unit ready until device ready, or give up. */
1601	while (count < 20) {
1602
1603		/* Wait for a bit.  do this first, because if we send
1604		 * the TUR right away, the reset will just abort it.
1605		 */
1606		schedule_timeout_uninterruptible(waittime);
1607		count++;
1608
1609		/* Increase wait time with each try, up to a point. */
1610		if (waittime < (HZ * 30))
1611			waittime = waittime * 2;
1612
1613		/* Send the Test Unit Ready */
1614		rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
1615			lunaddr, TYPE_CMD);
1616		if (rc == 0)
1617			rc = sendcmd_withirq_core(h, c, 0);
1618
1619		(void) process_sendcmd_error(h, c);
1620
1621		if (rc != 0)
1622			goto retry_tur;
1623
1624		if (c->err_info->CommandStatus == CMD_SUCCESS)
1625			break;
1626
1627		if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1628			c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1629			if (c->err_info->SenseInfo[2] == NO_SENSE)
1630				break;
1631			if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1632				unsigned char asc;
1633				asc = c->err_info->SenseInfo[12];
1634				check_for_unit_attention(h, c);
1635				if (asc == POWER_OR_RESET)
1636					break;
1637			}
1638		}
1639retry_tur:
1640		dev_warn(&h->pdev->dev, "Waiting %d secs "
1641			"for device to become ready.\n",
1642			waittime / HZ);
1643		rc = 1; /* device not ready. */
1644	}
1645
1646	if (rc)
1647		dev_warn(&h->pdev->dev, "giving up on device.\n");
1648	else
1649		dev_warn(&h->pdev->dev, "device is ready.\n");
1650
1651	cmd_free(h, c);
1652	return rc;
1653}
1654
1655/* Need at least one of these error handlers to keep ../scsi/hosts.c from 
1656 * complaining.  Doing a host- or bus-reset can't do anything good here. 
1657 * Despite what it might say in scsi_error.c, there may well be commands
1658 * on the controller, as the cciss driver registers twice, once as a block
1659 * device for the logical drives, and once as a scsi device, for any tape
1660 * drives.  So we know there are no commands out on the tape drives, but we
1661 * don't know there are no commands on the controller, and it is likely 
1662 * that there probably are, as the cciss block device is most commonly used
1663 * as a boot device (embedded controller on HP/Compaq systems.)
1664*/
1665
1666static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1667{
1668	int rc;
1669	CommandList_struct *cmd_in_trouble;
1670	unsigned char lunaddr[8];
1671	ctlr_info_t *h;
1672
1673	/* find the controller to which the command to be aborted was sent */
1674	h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1675	if (h == NULL) /* paranoia */
1676		return FAILED;
1677	dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
1678	/* find the command that's giving us trouble */
1679	cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1680	if (cmd_in_trouble == NULL) /* paranoia */
1681		return FAILED;
1682	memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1683	/* send a reset to the SCSI LUN which the command was sent to */
1684	rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
1685		TYPE_MSG);
1686	if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
1687		return SUCCESS;
1688	dev_warn(&h->pdev->dev, "resetting device failed.\n");
1689	return FAILED;
1690}
1691
1692static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1693{
1694	int rc;
1695	CommandList_struct *cmd_to_abort;
1696	unsigned char lunaddr[8];
1697	ctlr_info_t *h;
1698
1699	/* find the controller to which the command to be aborted was sent */
1700	h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1701	if (h == NULL) /* paranoia */
1702		return FAILED;
1703	dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
1704
1705	/* find the command to be aborted */
1706	cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1707	if (cmd_to_abort == NULL) /* paranoia */
1708		return FAILED;
1709	memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1710	rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
1711		0, 0, lunaddr, TYPE_MSG);
1712	if (rc == 0)
1713		return SUCCESS;
1714	return FAILED;
1715
1716}
1717
1718#else /* no CONFIG_CISS_SCSI_TAPE */
1719
1720/* If no tape support, then these become defined out of existence */
1721
1722#define cciss_scsi_setup(cntl_num)
 
1723
1724#endif /* CONFIG_CISS_SCSI_TAPE */