PageRenderTime 80ms CodeModel.GetById 25ms app.highlight 46ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/block/cciss_scsi.c

https://bitbucket.org/ndreys/linux-sunxi
C | 1717 lines | 1308 code | 197 blank | 212 comment | 225 complexity | e04fd19a86dea37a2d739d5a4cafd0e4 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
   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 <asm/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	/* Ordinarily, this case should never happen, but there is a bug
 769	   in some released firmware revisions that allows it to happen
 770	   if, for example, a 4100 backplane loses power and the tape
 771	   drive is in it.  We assume that it's a fatal error of some
 772	   kind because we can't show that it wasn't. We will make it
 773	   look like selection timeout since that is the most common
 774	   reason for this to occur, and it's severe enough. */
 775
 776					cmd->result = DID_NO_CONNECT << 16;
 777				}
 778			break;
 779			case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 780			break;
 781			case CMD_DATA_OVERRUN:
 782				dev_warn(&h->pdev->dev, "%p has"
 783					" completed with data overrun "
 784					"reported\n", c);
 785			break;
 786			case CMD_INVALID: {
 787				/* print_bytes(c, sizeof(*c), 1, 0);
 788				print_cmd(c); */
 789     /* We get CMD_INVALID if you address a non-existent tape drive instead
 790	of a selection timeout (no response).  You will see this if you yank 
 791	out a tape drive, then try to access it. This is kind of a shame
 792	because it means that any other CMD_INVALID (e.g. driver bug) will
 793	get interpreted as a missing target. */
 794				cmd->result = DID_NO_CONNECT << 16;
 795				}
 796			break;
 797			case CMD_PROTOCOL_ERR:
 798				cmd->result = DID_ERROR << 16;
 799				dev_warn(&h->pdev->dev,
 800					"%p has protocol error\n", c);
 801                        break;
 802			case CMD_HARDWARE_ERR:
 803				cmd->result = DID_ERROR << 16;
 804				dev_warn(&h->pdev->dev,
 805					"%p had hardware error\n", c);
 806                        break;
 807			case CMD_CONNECTION_LOST:
 808				cmd->result = DID_ERROR << 16;
 809				dev_warn(&h->pdev->dev,
 810					"%p had connection lost\n", c);
 811			break;
 812			case CMD_ABORTED:
 813				cmd->result = DID_ABORT << 16;
 814				dev_warn(&h->pdev->dev, "%p was aborted\n", c);
 815			break;
 816			case CMD_ABORT_FAILED:
 817				cmd->result = DID_ERROR << 16;
 818				dev_warn(&h->pdev->dev,
 819					"%p reports abort failed\n", c);
 820			break;
 821			case CMD_UNSOLICITED_ABORT:
 822				cmd->result = DID_ABORT << 16;
 823				dev_warn(&h->pdev->dev, "%p aborted due to an "
 824					"unsolicited abort\n", c);
 825			break;
 826			case CMD_TIMEOUT:
 827				cmd->result = DID_TIME_OUT << 16;
 828				dev_warn(&h->pdev->dev, "%p timedout\n", c);
 829			break;
 830			case CMD_UNABORTABLE:
 831				cmd->result = DID_ERROR << 16;
 832				dev_warn(&h->pdev->dev, "c %p command "
 833					"unabortable\n", c);
 834			break;
 835			default:
 836				cmd->result = DID_ERROR << 16;
 837				dev_warn(&h->pdev->dev,
 838					"%p returned unknown status %x\n", c,
 839						ei->CommandStatus); 
 840		}
 841	}
 842	cmd->scsi_done(cmd);
 843	scsi_cmd_free(h, c);
 844}
 845
 846static int
 847cciss_scsi_detect(ctlr_info_t *h)
 848{
 849	struct Scsi_Host *sh;
 850	int error;
 851
 852	sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
 853	if (sh == NULL)
 854		goto fail;
 855	sh->io_port = 0;	// good enough?  FIXME, 
 856	sh->n_io_port = 0;	// I don't think we use these two...
 857	sh->this_id = SELF_SCSI_ID;  
 858	sh->can_queue = cciss_tape_cmds;
 859	sh->sg_tablesize = h->maxsgentries;
 860	sh->max_cmd_len = MAX_COMMAND_SIZE;
 861	sh->max_sectors = h->cciss_max_sectors;
 862
 863	((struct cciss_scsi_adapter_data_t *) 
 864		h->scsi_ctlr)->scsi_host = sh;
 865	sh->hostdata[0] = (unsigned long) h;
 866	sh->irq = h->intr[SIMPLE_MODE_INT];
 867	sh->unique_id = sh->irq;
 868	error = scsi_add_host(sh, &h->pdev->dev);
 869	if (error)
 870		goto fail_host_put;
 871	scsi_scan_host(sh);
 872	return 1;
 873
 874 fail_host_put:
 875	scsi_host_put(sh);
 876 fail:
 877	return 0;
 878}
 879
 880static void
 881cciss_unmap_one(struct pci_dev *pdev,
 882		CommandList_struct *c,
 883		size_t buflen,
 884		int data_direction)
 885{
 886	u64bit addr64;
 887
 888	addr64.val32.lower = c->SG[0].Addr.lower;
 889	addr64.val32.upper = c->SG[0].Addr.upper;
 890	pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
 891}
 892
 893static void
 894cciss_map_one(struct pci_dev *pdev,
 895		CommandList_struct *c,
 896		unsigned char *buf,
 897		size_t buflen,
 898		int data_direction)
 899{
 900	__u64 addr64;
 901
 902	addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
 903	c->SG[0].Addr.lower =
 904	  (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
 905	c->SG[0].Addr.upper =
 906	  (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
 907	c->SG[0].Len = buflen;
 908	c->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
 909	c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
 910}
 911
 912static int
 913cciss_scsi_do_simple_cmd(ctlr_info_t *h,
 914			CommandList_struct *c,
 915			unsigned char *scsi3addr, 
 916			unsigned char *cdb,
 917			unsigned char cdblen,
 918			unsigned char *buf, int bufsize,
 919			int direction)
 920{
 921	DECLARE_COMPLETION_ONSTACK(wait);
 922
 923	c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
 924	c->scsi_cmd = NULL;
 925	c->Header.ReplyQueue = 0;  /* unused in simple mode */
 926	memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
 927	c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
 928	// Fill in the request block...
 929
 930	/* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", 
 931		scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
 932		scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
 933
 934	memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
 935	memcpy(c->Request.CDB, cdb, cdblen);
 936	c->Request.Timeout = 0;
 937	c->Request.CDBLen = cdblen;
 938	c->Request.Type.Type = TYPE_CMD;
 939	c->Request.Type.Attribute = ATTR_SIMPLE;
 940	c->Request.Type.Direction = direction;
 941
 942	/* Fill in the SG list and do dma mapping */
 943	cciss_map_one(h->pdev, c, (unsigned char *) buf,
 944			bufsize, DMA_FROM_DEVICE); 
 945
 946	c->waiting = &wait;
 947	enqueue_cmd_and_start_io(h, c);
 948	wait_for_completion(&wait);
 949
 950	/* undo the dma mapping */
 951	cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
 952	return(0);
 953}
 954
 955static void 
 956cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
 957{
 958	ErrorInfo_struct *ei;
 959
 960	ei = c->err_info;
 961	switch(ei->CommandStatus)
 962	{
 963		case CMD_TARGET_STATUS:
 964			dev_warn(&h->pdev->dev,
 965				"cmd %p has completed with errors\n", c);
 966			dev_warn(&h->pdev->dev,
 967				"cmd %p has SCSI Status = %x\n",
 968				c, ei->ScsiStatus);
 969			if (ei->ScsiStatus == 0)
 970				dev_warn(&h->pdev->dev,
 971				"SCSI status is abnormally zero.  "
 972				"(probably indicates selection timeout "
 973				"reported incorrectly due to a known "
 974				"firmware bug, circa July, 2001.)\n");
 975		break;
 976		case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 977			dev_info(&h->pdev->dev, "UNDERRUN\n");
 978		break;
 979		case CMD_DATA_OVERRUN:
 980			dev_warn(&h->pdev->dev, "%p has"
 981				" completed with data overrun "
 982				"reported\n", c);
 983		break;
 984		case CMD_INVALID: {
 985			/* controller unfortunately reports SCSI passthru's */
 986			/* to non-existent targets as invalid commands. */
 987			dev_warn(&h->pdev->dev,
 988				"%p is reported invalid (probably means "
 989				"target device no longer present)\n", c);
 990			/* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
 991			print_cmd(c);  */
 992			}
 993		break;
 994		case CMD_PROTOCOL_ERR:
 995			dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
 996		break;
 997		case CMD_HARDWARE_ERR:
 998			/* cmd->result = DID_ERROR << 16; */
 999			dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
1000		break;
1001		case CMD_CONNECTION_LOST:
1002			dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
1003		break;
1004		case CMD_ABORTED:
1005			dev_warn(&h->pdev->dev, "%p was aborted\n", c);
1006		break;
1007		case CMD_ABORT_FAILED:
1008			dev_warn(&h->pdev->dev,
1009				"%p reports abort failed\n", c);
1010		break;
1011		case CMD_UNSOLICITED_ABORT:
1012			dev_warn(&h->pdev->dev,
1013				"%p aborted due to an unsolicited abort\n", c);
1014		break;
1015		case CMD_TIMEOUT:
1016			dev_warn(&h->pdev->dev, "%p timedout\n", c);
1017		break;
1018		case CMD_UNABORTABLE:
1019			dev_warn(&h->pdev->dev,
1020				"%p unabortable\n", c);
1021		break;
1022		default:
1023			dev_warn(&h->pdev->dev,
1024				"%p returned unknown status %x\n",
1025				c, ei->CommandStatus);
1026	}
1027}
1028
1029static int
1030cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
1031	unsigned char page, unsigned char *buf,
1032	unsigned char bufsize)
1033{
1034	int rc;
1035	CommandList_struct *c;
1036	char cdb[6];
1037	ErrorInfo_struct *ei;
1038	unsigned long flags;
1039
1040	spin_lock_irqsave(&h->lock, flags);
1041	c = scsi_cmd_alloc(h);
1042	spin_unlock_irqrestore(&h->lock, flags);
1043
1044	if (c == NULL) {			/* trouble... */
1045		printk("cmd_alloc returned NULL!\n");
1046		return -1;
1047	}
1048
1049	ei = c->err_info;
1050
1051	cdb[0] = CISS_INQUIRY;
1052	cdb[1] = (page != 0);
1053	cdb[2] = page;
1054	cdb[3] = 0;
1055	cdb[4] = bufsize;
1056	cdb[5] = 0;
1057	rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
1058				6, buf, bufsize, XFER_READ);
1059
1060	if (rc != 0) return rc; /* something went wrong */
1061
1062	if (ei->CommandStatus != 0 && 
1063	    ei->CommandStatus != CMD_DATA_UNDERRUN) {
1064		cciss_scsi_interpret_error(h, c);
1065		rc = -1;
1066	}
1067	spin_lock_irqsave(&h->lock, flags);
1068	scsi_cmd_free(h, c);
1069	spin_unlock_irqrestore(&h->lock, flags);
1070	return rc;	
1071}
1072
1073/* Get the device id from inquiry page 0x83 */
1074static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
1075	unsigned char *device_id, int buflen)
1076{
1077	int rc;
1078	unsigned char *buf;
1079
1080	if (buflen > 16)
1081		buflen = 16;
1082	buf = kzalloc(64, GFP_KERNEL);
1083	if (!buf)
1084		return -1;
1085	rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
1086	if (rc == 0)
1087		memcpy(device_id, &buf[8], buflen);
1088	kfree(buf);
1089	return rc != 0;
1090}
1091
1092static int
1093cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
1094		ReportLunData_struct *buf, int bufsize)
1095{
1096	int rc;
1097	CommandList_struct *c;
1098	unsigned char cdb[12];
1099	unsigned char scsi3addr[8]; 
1100	ErrorInfo_struct *ei;
1101	unsigned long flags;
1102
1103	spin_lock_irqsave(&h->lock, flags);
1104	c = scsi_cmd_alloc(h);
1105	spin_unlock_irqrestore(&h->lock, flags);
1106	if (c == NULL) {			/* trouble... */
1107		printk("cmd_alloc returned NULL!\n");
1108		return -1;
1109	}
1110
1111	memset(&scsi3addr[0], 0, 8); /* address the controller */
1112	cdb[0] = CISS_REPORT_PHYS;
1113	cdb[1] = 0;
1114	cdb[2] = 0;
1115	cdb[3] = 0;
1116	cdb[4] = 0;
1117	cdb[5] = 0;
1118	cdb[6] = (bufsize >> 24) & 0xFF;  //MSB
1119	cdb[7] = (bufsize >> 16) & 0xFF;
1120	cdb[8] = (bufsize >> 8) & 0xFF;
1121	cdb[9] = bufsize & 0xFF;
1122	cdb[10] = 0;
1123	cdb[11] = 0;
1124
1125	rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
1126				cdb, 12, 
1127				(unsigned char *) buf, 
1128				bufsize, XFER_READ);
1129
1130	if (rc != 0) return rc; /* something went wrong */
1131
1132	ei = c->err_info;
1133	if (ei->CommandStatus != 0 && 
1134	    ei->CommandStatus != CMD_DATA_UNDERRUN) {
1135		cciss_scsi_interpret_error(h, c);
1136		rc = -1;
1137	}
1138	spin_lock_irqsave(&h->lock, flags);
1139	scsi_cmd_free(h, c);
1140	spin_unlock_irqrestore(&h->lock, flags);
1141	return rc;	
1142}
1143
1144static void
1145cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
1146{
1147	/* the idea here is we could get notified from /proc
1148	   that some devices have changed, so we do a report 
1149	   physical luns cmd, and adjust our list of devices 
1150	   accordingly.  (We can't rely on the scsi-mid layer just
1151	   doing inquiries, because the "busses" that the scsi 
1152	   mid-layer probes are totally fabricated by this driver,
1153	   so new devices wouldn't show up.
1154
1155	   the scsi3addr's of devices won't change so long as the 
1156	   adapter is not reset.  That means we can rescan and 
1157	   tell which devices we already know about, vs. new 
1158	   devices, vs.  disappearing devices.
1159
1160	   Also, if you yank out a tape drive, then put in a disk
1161	   in it's place, (say, a configured volume from another 
1162	   array controller for instance)  _don't_ poke this driver 
1163           (so it thinks it's still a tape, but _do_ poke the scsi 
1164           mid layer, so it does an inquiry... the scsi mid layer 
1165           will see the physical disk.  This would be bad.  Need to
1166	   think about how to prevent that.  One idea would be to 
1167	   snoop all scsi responses and if an inquiry repsonse comes
1168	   back that reports a disk, chuck it an return selection
1169	   timeout instead and adjust our table...  Not sure i like
1170	   that though.  
1171
1172	 */
1173#define OBDR_TAPE_INQ_SIZE 49
1174#define OBDR_TAPE_SIG "$DR-10"
1175	ReportLunData_struct *ld_buff;
1176	unsigned char *inq_buff;
1177	unsigned char scsi3addr[8];
1178	__u32 num_luns=0;
1179	unsigned char *ch;
1180	struct cciss_scsi_dev_t *currentsd, *this_device;
1181	int ncurrent=0;
1182	int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1183	int i;
1184
1185	ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1186	inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1187	currentsd = kzalloc(sizeof(*currentsd) *
1188			(CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1189	if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1190		printk(KERN_ERR "cciss: out of memory\n");
1191		goto out;
1192	}
1193	this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1194	if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
1195		ch = &ld_buff->LUNListLength[0];
1196		num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1197		if (num_luns > CISS_MAX_PHYS_LUN) {
1198			printk(KERN_WARNING 
1199				"cciss: Maximum physical LUNs (%d) exceeded.  "
1200				"%d LUNs ignored.\n", CISS_MAX_PHYS_LUN, 
1201				num_luns - CISS_MAX_PHYS_LUN);
1202			num_luns = CISS_MAX_PHYS_LUN;
1203		}
1204	}
1205	else {
1206		printk(KERN_ERR  "cciss: Report physical LUNs failed.\n");
1207		goto out;
1208	}
1209
1210
1211	/* adjust our table of devices */	
1212	for (i = 0; i < num_luns; i++) {
1213		/* for each physical lun, do an inquiry */
1214		if (ld_buff->LUN[i][3] & 0xC0) continue;
1215		memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1216		memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1217
1218		if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
1219			(unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1220			/* Inquiry failed (msg printed already) */
1221			continue; /* so we will skip this device. */
1222
1223		this_device->devtype = (inq_buff[0] & 0x1f);
1224		this_device->bus = -1;
1225		this_device->target = -1;
1226		this_device->lun = -1;
1227		memcpy(this_device->scsi3addr, scsi3addr, 8);
1228		memcpy(this_device->vendor, &inq_buff[8],
1229			sizeof(this_device->vendor));
1230		memcpy(this_device->model, &inq_buff[16],
1231			sizeof(this_device->model));
1232		memcpy(this_device->revision, &inq_buff[32],
1233			sizeof(this_device->revision));
1234		memset(this_device->device_id, 0,
1235			sizeof(this_device->device_id));
1236		cciss_scsi_get_device_id(h, scsi3addr,
1237			this_device->device_id, sizeof(this_device->device_id));
1238
1239		switch (this_device->devtype)
1240		{
1241		  case 0x05: /* CD-ROM */ {
1242
1243			/* We don't *really* support actual CD-ROM devices,
1244			 * just this "One Button Disaster Recovery" tape drive
1245			 * which temporarily pretends to be a CD-ROM drive.
1246			 * So we check that the device is really an OBDR tape
1247			 * device by checking for "$DR-10" in bytes 43-48 of
1248			 * the inquiry data.
1249			 */
1250				char obdr_sig[7];
1251
1252				strncpy(obdr_sig, &inq_buff[43], 6);
1253				obdr_sig[6] = '\0';
1254				if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1255					/* Not OBDR device, ignore it. */
1256					break;
1257			}
1258			/* fall through . . . */
1259		  case 0x01: /* sequential access, (tape) */
1260		  case 0x08: /* medium changer */
1261			if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1262				printk(KERN_INFO "cciss%d: %s ignored, "
1263					"too many devices.\n", h->ctlr,
1264					scsi_device_type(this_device->devtype));
1265				break;
1266			}
1267			currentsd[ncurrent] = *this_device;
1268			ncurrent++;
1269			break;
1270		  default: 
1271			break;
1272		}
1273	}
1274
1275	adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
1276out:
1277	kfree(inq_buff);
1278	kfree(ld_buff);
1279	kfree(currentsd);
1280	return;
1281}
1282
1283static int
1284is_keyword(char *ptr, int len, char *verb)  // Thanks to ncr53c8xx.c
1285{
1286	int verb_len = strlen(verb);
1287	if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1288		return verb_len;
1289	else
1290		return 0;
1291}
1292
1293static int
1294cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
1295{
1296	int arg_len;
1297
1298	if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1299		cciss_update_non_disk_devices(h, hostno);
1300	else
1301		return -EINVAL;
1302	return length;
1303}
1304
1305
1306static int
1307cciss_scsi_proc_info(struct Scsi_Host *sh,
1308		char *buffer, /* data buffer */
1309		char **start, 	   /* where data in buffer starts */
1310		off_t offset,	   /* offset from start of imaginary file */
1311		int length, 	   /* length of data in buffer */
1312		int func)	   /* 0 == read, 1 == write */
1313{
1314
1315	int buflen, datalen;
1316	ctlr_info_t *h;
1317	int i;
1318
1319	h = (ctlr_info_t *) sh->hostdata[0];
1320	if (h == NULL)  /* This really shouldn't ever happen. */
1321		return -EINVAL;
1322
1323	if (func == 0) {	/* User is reading from /proc/scsi/ciss*?/?*  */
1324		buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1325				h->ctlr, sh->host_no);
1326
1327		/* this information is needed by apps to know which cciss
1328		   device corresponds to which scsi host number without
1329		   having to open a scsi target device node.  The device
1330		   information is not a duplicate of /proc/scsi/scsi because
1331		   the two may be out of sync due to scsi hotplug, rather
1332		   this info is for an app to be able to use to know how to
1333		   get them back in sync. */
1334
1335		for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1336			struct cciss_scsi_dev_t *sd =
1337				&ccissscsi[h->ctlr].dev[i];
1338			buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1339				"0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1340				sh->host_no, sd->bus, sd->target, sd->lun,
1341				sd->devtype,
1342				sd->scsi3addr[0], sd->scsi3addr[1],
1343				sd->scsi3addr[2], sd->scsi3addr[3],
1344				sd->scsi3addr[4], sd->scsi3addr[5],
1345				sd->scsi3addr[6], sd->scsi3addr[7]);
1346		}
1347		datalen = buflen - offset;
1348		if (datalen < 0) { 	/* they're reading past EOF. */
1349			datalen = 0;
1350			*start = buffer+buflen;	
1351		} else
1352			*start = buffer + offset;
1353		return(datalen);
1354	} else 	/* User is writing to /proc/scsi/cciss*?/?*  ... */
1355		return cciss_scsi_user_command(h, sh->host_no,
1356			buffer, length);	
1357} 
1358
1359/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci 
1360   dma mapping  and fills in the scatter gather entries of the 
1361   cciss command, c. */
1362
1363static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
1364	struct scsi_cmnd *cmd)
1365{
1366	unsigned int len;
1367	struct scatterlist *sg;
1368	__u64 addr64;
1369	int request_nsgs, i, chained, sg_index;
1370	struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1371	SGDescriptor_struct *curr_sg;
1372
1373	BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1374
1375	chained = 0;
1376	sg_index = 0;
1377	curr_sg = c->SG;
1378	request_nsgs = scsi_dma_map(cmd);
1379	if (request_nsgs) {
1380		scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1381			if (sg_index + 1 == h->max_cmd_sgentries &&
1382				!chained && request_nsgs - i > 1) {
1383				chained = 1;
1384				sg_index = 0;
1385				curr_sg = sa->cmd_sg_list[c->cmdindex];
1386			}
1387			addr64 = (__u64) sg_dma_address(sg);
1388			len  = sg_dma_len(sg);
1389			curr_sg[sg_index].Addr.lower =
1390				(__u32) (addr64 & 0x0FFFFFFFFULL);
1391			curr_sg[sg_index].Addr.upper =
1392				(__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1393			curr_sg[sg_index].Len = len;
1394			curr_sg[sg_index].Ext = 0;
1395			++sg_index;
1396		}
1397		if (chained)
1398			cciss_map_sg_chain_block(h, c,
1399				sa->cmd_sg_list[c->cmdindex],
1400				(request_nsgs - (h->max_cmd_sgentries - 1)) *
1401					sizeof(SGDescriptor_struct));
1402	}
1403	/* track how many SG entries we are using */
1404	if (request_nsgs > h->maxSG)
1405		h->maxSG = request_nsgs;
1406	c->Header.SGTotal = (u16) request_nsgs + chained;
1407	if (request_nsgs > h->max_cmd_sgentries)
1408		c->Header.SGList = h->max_cmd_sgentries;
1409	else
1410		c->Header.SGList = c->Header.SGTotal;
1411	return;
1412}
1413
1414
1415static int
1416cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1417{
1418	ctlr_info_t *h;
1419	int rc;
1420	unsigned char scsi3addr[8];
1421	CommandList_struct *c;
1422	unsigned long flags;
1423
1424	// Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1425	// We violate cmd->host privacy here.  (Is there another way?)
1426	h = (ctlr_info_t *) cmd->device->host->hostdata[0];
1427
1428	rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
1429			cmd->device->lun, scsi3addr);
1430	if (rc != 0) {
1431		/* the scsi nexus does not match any that we presented... */
1432		/* pretend to mid layer that we got selection timeout */
1433		cmd->result = DID_NO_CONNECT << 16;
1434		done(cmd);
1435		/* we might want to think about registering controller itself
1436		   as a processor device on the bus so sg binds to it. */
1437		return 0;
1438	}
1439
1440	/* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1441           see what the device thinks of it. */
1442
1443	spin_lock_irqsave(&h->lock, flags);
1444	c = scsi_cmd_alloc(h);
1445	spin_unlock_irqrestore(&h->lock, flags);
1446	if (c == NULL) {			/* trouble... */
1447		dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
1448		/* FIXME: next 3 lines are -> BAD! <- */
1449		cmd->result = DID_NO_CONNECT << 16;
1450		done(cmd);
1451		return 0;
1452	}
1453
1454	// Fill in the command list header
1455
1456	cmd->scsi_done = done;    // save this for use by completion code 
1457
1458	/* save c in case we have to abort it */
1459	cmd->host_scribble = (unsigned char *) c;
1460
1461	c->cmd_type = CMD_SCSI;
1462	c->scsi_cmd = cmd;
1463	c->Header.ReplyQueue = 0;  /* unused in simple mode */
1464	memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1465	c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
1466	
1467	// Fill in the request block...
1468
1469	c->Request.Timeout = 0;
1470	memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1471	BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1472	c->Request.CDBLen = cmd->cmd_len;
1473	memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1474	c->Request.Type.Type = TYPE_CMD;
1475	c->Request.Type.Attribute = ATTR_SIMPLE;
1476	switch(cmd->sc_data_direction)
1477	{
1478	  case DMA_TO_DEVICE:
1479		c->Request.Type.Direction = XFER_WRITE;
1480		break;
1481	  case DMA_FROM_DEVICE:
1482		c->Request.Type.Direction = XFER_READ;
1483		break;
1484	  case DMA_NONE:
1485		c->Request.Type.Direction = XFER_NONE;
1486		break;
1487	  case DMA_BIDIRECTIONAL:
1488		// This can happen if a buggy application does a scsi passthru
1489		// and sets both inlen and outlen to non-zero. ( see
1490		// ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1491
1492		c->Request.Type.Direction = XFER_RSVD;
1493		// This is technically wrong, and cciss controllers should
1494		// reject it with CMD_INVALID, which is the most correct 
1495		// response, but non-fibre backends appear to let it 
1496		// slide by, and give the same results as if this field
1497		// were set correctly.  Either way is acceptable for
1498		// our purposes here.
1499
1500		break;
1501
1502	  default: 
1503		dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
1504			cmd->sc_data_direction);
1505		BUG();
1506		break;
1507	}
1508	cciss_scatter_gather(h, c, cmd);
1509	enqueue_cmd_and_start_io(h, c);
1510	/* the cmd'll come back via intr handler in complete_scsi_command()  */
1511	return 0;
1512}
1513
1514static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1515
1516static void cciss_unregister_scsi(ctlr_info_t *h)
1517{
1518	struct cciss_scsi_adapter_data_t *sa;
1519	struct cciss_scsi_cmd_stack_t *stk;
1520	unsigned long flags;
1521
1522	/* we are being forcibly unloaded, and may not refuse. */
1523
1524	spin_lock_irqsave(&h->lock, flags);
1525	sa = h->scsi_ctlr;
1526	stk = &sa->cmd_stack; 
1527
1528	/* if we weren't ever actually registered, don't unregister */ 
1529	if (sa->registered) {
1530		spin_unlock_irqrestore(&h->lock, flags);
1531		scsi_remove_host(sa->scsi_host);
1532		scsi_host_put(sa->scsi_host);
1533		spin_lock_irqsave(&h->lock, flags);
1534	}
1535
1536	/* set scsi_host to NULL so our detect routine will 
1537	   find us on register */
1538	sa->scsi_host = NULL;
1539	spin_unlock_irqrestore(&h->lock, flags);
1540	scsi_cmd_stack_free(h);
1541	kfree(sa);
1542}
1543
1544static int cciss_engage_scsi(ctlr_info_t *h)
1545{
1546	struct cciss_scsi_adapter_data_t *sa;
1547	struct cciss_scsi_cmd_stack_t *stk;
1548	unsigned long flags;
1549
1550	spin_lock_irqsave(&h->lock, flags);
1551	sa = h->scsi_ctlr;
1552	stk = &sa->cmd_stack; 
1553
1554	if (sa->registered) {
1555		dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
1556		spin_unlock_irqrestore(&h->lock, flags);
1557		return -ENXIO;
1558	}
1559	sa->registered = 1;
1560	spin_unlock_irqrestore(&h->lock, flags);
1561	cciss_update_non_disk_devices(h, -1);
1562	cciss_scsi_detect(h);
1563	return 0;
1564}
1565
1566static void
1567cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
1568{
1569	unsigned long flags;
1570
1571	CPQ_TAPE_LOCK(h, flags);
1572	seq_printf(seq,
1573		"Sequential access devices: %d\n\n",
1574			ccissscsi[h->ctlr].ndevices);
1575	CPQ_TAPE_UNLOCK(h, flags);
1576}
1577
1578static int wait_for_device_to_become_ready(ctlr_info_t *h,
1579	unsigned char lunaddr[])
1580{
1581	int rc;
1582	int count = 0;
1583	int waittime = HZ;
1584	CommandList_struct *c;
1585
1586	c = cmd_alloc(h);
1587	if (!c) {
1588		dev_warn(&h->pdev->dev, "out of memory in "
1589			"wait_for_device_to_become_ready.\n");
1590		return IO_ERROR;
1591	}
1592
1593	/* Send test unit ready until device ready, or give up. */
1594	while (count < 20) {
1595
1596		/* Wait for a bit.  do this first, because if we send
1597		 * the TUR right away, the reset will just abort it.
1598		 */
1599		schedule_timeout_uninterruptible(waittime);
1600		count++;
1601
1602		/* Increase wait time with each try, up to a point. */
1603		if (waittime < (HZ * 30))
1604			waittime = waittime * 2;
1605
1606		/* Send the Test Unit Ready */
1607		rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
1608			lunaddr, TYPE_CMD);
1609		if (rc == 0)
1610			rc = sendcmd_withirq_core(h, c, 0);
1611
1612		(void) process_sendcmd_error(h, c);
1613
1614		if (rc != 0)
1615			goto retry_tur;
1616
1617		if (c->err_info->CommandStatus == CMD_SUCCESS)
1618			break;
1619
1620		if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1621			c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1622			if (c->err_info->SenseInfo[2] == NO_SENSE)
1623				break;
1624			if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1625				unsigned char asc;
1626				asc = c->err_info->SenseInfo[12];
1627				check_for_unit_attention(h, c);
1628				if (asc == POWER_OR_RESET)
1629					break;
1630			}
1631		}
1632retry_tur:
1633		dev_warn(&h->pdev->dev, "Waiting %d secs "
1634			"for device to become ready.\n",
1635			waittime / HZ);
1636		rc = 1; /* device not ready. */
1637	}
1638
1639	if (rc)
1640		dev_warn(&h->pdev->dev, "giving up on device.\n");
1641	else
1642		dev_warn(&h->pdev->dev, "device is ready.\n");
1643
1644	cmd_free(h, c);
1645	return rc;
1646}
1647
1648/* Need at least one of these error handlers to keep ../scsi/hosts.c from 
1649 * complaining.  Doing a host- or bus-reset can't do anything good here. 
1650 * Despite what it might say in scsi_error.c, there may well be commands
1651 * on the controller, as the cciss driver registers twice, once as a block
1652 * device for the logical drives, and once as a scsi device, for any tape
1653 * drives.  So we know there are no commands out on the tape drives, but we
1654 * don't know there are no commands on the controller, and it is likely 
1655 * that there probably are, as the cciss block device is most commonly used
1656 * as a boot device (embedded controller on HP/Compaq systems.)
1657*/
1658
1659static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1660{
1661	int rc;
1662	CommandList_struct *cmd_in_trouble;
1663	unsigned char lunaddr[8];
1664	ctlr_info_t *h;
1665
1666	/* find the controller to which the command to be aborted was sent */
1667	h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1668	if (h == NULL) /* paranoia */
1669		return FAILED;
1670	dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
1671	/* find the command that's giving us trouble */
1672	cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1673	if (cmd_in_trouble == NULL) /* paranoia */
1674		return FAILED;
1675	memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1676	/* send a reset to the SCSI LUN which the command was sent to */
1677	rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
1678		TYPE_MSG);
1679	if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
1680		return SUCCESS;
1681	dev_warn(&h->pdev->dev, "resetting device failed.\n");
1682	return FAILED;
1683}
1684
1685static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1686{
1687	int rc;
1688	CommandList_struct *cmd_to_abort;
1689	unsigned char lunaddr[8];
1690	ctlr_info_t *h;
1691
1692	/* find the controller to which the command to be aborted was sent */
1693	h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1694	if (h == NULL) /* paranoia */
1695		return FAILED;
1696	dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
1697
1698	/* find the command to be aborted */
1699	cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1700	if (cmd_to_abort == NULL) /* paranoia */
1701		return FAILED;
1702	memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1703	rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
1704		0, 0, lunaddr, TYPE_MSG);
1705	if (rc == 0)
1706		return SUCCESS;
1707	return FAILED;
1708
1709}
1710
1711#else /* no CONFIG_CISS_SCSI_TAPE */
1712
1713/* If no tape support, then these become defined out of existence */
1714
1715#define cciss_scsi_setup(cntl_num)
1716
1717#endif /* CONFIG_CISS_SCSI_TAPE */