PageRenderTime 118ms CodeModel.GetById 28ms app.highlight 75ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/scsi/aic7xxx/aic79xx_osm.c

http://github.com/mirrors/linux
C | 2877 lines | 2076 code | 328 blank | 473 comment | 403 complexity | c54d73ed5603ab3e4e9a16716720a790 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * Adaptec AIC79xx device driver for Linux.
   3 *
   4 * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.c#171 $
   5 *
   6 * --------------------------------------------------------------------------
   7 * Copyright (c) 1994-2000 Justin T. Gibbs.
   8 * Copyright (c) 1997-1999 Doug Ledford
   9 * Copyright (c) 2000-2003 Adaptec Inc.
  10 * All rights reserved.
  11 *
  12 * Redistribution and use in source and binary forms, with or without
  13 * modification, are permitted provided that the following conditions
  14 * are met:
  15 * 1. Redistributions of source code must retain the above copyright
  16 *    notice, this list of conditions, and the following disclaimer,
  17 *    without modification.
  18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19 *    substantially similar to the "NO WARRANTY" disclaimer below
  20 *    ("Disclaimer") and any redistribution must be conditioned upon
  21 *    including a substantially similar Disclaimer requirement for further
  22 *    binary redistribution.
  23 * 3. Neither the names of the above-listed copyright holders nor the names
  24 *    of any contributors may be used to endorse or promote products derived
  25 *    from this software without specific prior written permission.
  26 *
  27 * Alternatively, this software may be distributed under the terms of the
  28 * GNU General Public License ("GPL") version 2 as published by the Free
  29 * Software Foundation.
  30 *
  31 * NO WARRANTY
  32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42 * POSSIBILITY OF SUCH DAMAGES.
  43 */
  44
  45#include "aic79xx_osm.h"
  46#include "aic79xx_inline.h"
  47#include <scsi/scsicam.h>
  48
  49static struct scsi_transport_template *ahd_linux_transport_template = NULL;
  50
  51#include <linux/init.h>		/* __setup */
  52#include <linux/mm.h>		/* For fetching system memory size */
  53#include <linux/blkdev.h>		/* For block_size() */
  54#include <linux/delay.h>	/* For ssleep/msleep */
  55#include <linux/device.h>
  56#include <linux/slab.h>
  57
  58/*
  59 * Bucket size for counting good commands in between bad ones.
  60 */
  61#define AHD_LINUX_ERR_THRESH	1000
  62
  63/*
  64 * Set this to the delay in seconds after SCSI bus reset.
  65 * Note, we honor this only for the initial bus reset.
  66 * The scsi error recovery code performs its own bus settle
  67 * delay handling for error recovery actions.
  68 */
  69#ifdef CONFIG_AIC79XX_RESET_DELAY_MS
  70#define AIC79XX_RESET_DELAY CONFIG_AIC79XX_RESET_DELAY_MS
  71#else
  72#define AIC79XX_RESET_DELAY 5000
  73#endif
  74
  75/*
  76 * To change the default number of tagged transactions allowed per-device,
  77 * add a line to the lilo.conf file like:
  78 * append="aic79xx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"
  79 * which will result in the first four devices on the first two
  80 * controllers being set to a tagged queue depth of 32.
  81 *
  82 * The tag_commands is an array of 16 to allow for wide and twin adapters.
  83 * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15
  84 * for channel 1.
  85 */
  86typedef struct {
  87	uint16_t tag_commands[16];	/* Allow for wide/twin adapters. */
  88} adapter_tag_info_t;
  89
  90/*
  91 * Modify this as you see fit for your system.
  92 *
  93 * 0			tagged queuing disabled
  94 * 1 <= n <= 253	n == max tags ever dispatched.
  95 *
  96 * The driver will throttle the number of commands dispatched to a
  97 * device if it returns queue full.  For devices with a fixed maximum
  98 * queue depth, the driver will eventually determine this depth and
  99 * lock it in (a console message is printed to indicate that a lock
 100 * has occurred).  On some devices, queue full is returned for a temporary
 101 * resource shortage.  These devices will return queue full at varying
 102 * depths.  The driver will throttle back when the queue fulls occur and
 103 * attempt to slowly increase the depth over time as the device recovers
 104 * from the resource shortage.
 105 *
 106 * In this example, the first line will disable tagged queueing for all
 107 * the devices on the first probed aic79xx adapter.
 108 *
 109 * The second line enables tagged queueing with 4 commands/LUN for IDs
 110 * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
 111 * driver to attempt to use up to 64 tags for ID 1.
 112 *
 113 * The third line is the same as the first line.
 114 *
 115 * The fourth line disables tagged queueing for devices 0 and 3.  It
 116 * enables tagged queueing for the other IDs, with 16 commands/LUN
 117 * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
 118 * IDs 2, 5-7, and 9-15.
 119 */
 120
 121/*
 122 * NOTE: The below structure is for reference only, the actual structure
 123 *       to modify in order to change things is just below this comment block.
 124adapter_tag_info_t aic79xx_tag_info[] =
 125{
 126	{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
 127	{{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}},
 128	{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
 129	{{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
 130};
 131*/
 132
 133#ifdef CONFIG_AIC79XX_CMDS_PER_DEVICE
 134#define AIC79XX_CMDS_PER_DEVICE CONFIG_AIC79XX_CMDS_PER_DEVICE
 135#else
 136#define AIC79XX_CMDS_PER_DEVICE AHD_MAX_QUEUE
 137#endif
 138
 139#define AIC79XX_CONFIGED_TAG_COMMANDS {					\
 140	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 141	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 142	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 143	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 144	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 145	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 146	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,		\
 147	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE		\
 148}
 149
 150/*
 151 * By default, use the number of commands specified by
 152 * the users kernel configuration.
 153 */
 154static adapter_tag_info_t aic79xx_tag_info[] =
 155{
 156	{AIC79XX_CONFIGED_TAG_COMMANDS},
 157	{AIC79XX_CONFIGED_TAG_COMMANDS},
 158	{AIC79XX_CONFIGED_TAG_COMMANDS},
 159	{AIC79XX_CONFIGED_TAG_COMMANDS},
 160	{AIC79XX_CONFIGED_TAG_COMMANDS},
 161	{AIC79XX_CONFIGED_TAG_COMMANDS},
 162	{AIC79XX_CONFIGED_TAG_COMMANDS},
 163	{AIC79XX_CONFIGED_TAG_COMMANDS},
 164	{AIC79XX_CONFIGED_TAG_COMMANDS},
 165	{AIC79XX_CONFIGED_TAG_COMMANDS},
 166	{AIC79XX_CONFIGED_TAG_COMMANDS},
 167	{AIC79XX_CONFIGED_TAG_COMMANDS},
 168	{AIC79XX_CONFIGED_TAG_COMMANDS},
 169	{AIC79XX_CONFIGED_TAG_COMMANDS},
 170	{AIC79XX_CONFIGED_TAG_COMMANDS},
 171	{AIC79XX_CONFIGED_TAG_COMMANDS}
 172};
 173
 174/*
 175 * The I/O cell on the chip is very configurable in respect to its analog
 176 * characteristics.  Set the defaults here; they can be overriden with
 177 * the proper insmod parameters.
 178 */
 179struct ahd_linux_iocell_opts
 180{
 181	uint8_t	precomp;
 182	uint8_t	slewrate;
 183	uint8_t amplitude;
 184};
 185#define AIC79XX_DEFAULT_PRECOMP		0xFF
 186#define AIC79XX_DEFAULT_SLEWRATE	0xFF
 187#define AIC79XX_DEFAULT_AMPLITUDE	0xFF
 188#define AIC79XX_DEFAULT_IOOPTS			\
 189{						\
 190	AIC79XX_DEFAULT_PRECOMP,		\
 191	AIC79XX_DEFAULT_SLEWRATE,		\
 192	AIC79XX_DEFAULT_AMPLITUDE		\
 193}
 194#define AIC79XX_PRECOMP_INDEX	0
 195#define AIC79XX_SLEWRATE_INDEX	1
 196#define AIC79XX_AMPLITUDE_INDEX	2
 197static const struct ahd_linux_iocell_opts aic79xx_iocell_info[] =
 198{
 199	AIC79XX_DEFAULT_IOOPTS,
 200	AIC79XX_DEFAULT_IOOPTS,
 201	AIC79XX_DEFAULT_IOOPTS,
 202	AIC79XX_DEFAULT_IOOPTS,
 203	AIC79XX_DEFAULT_IOOPTS,
 204	AIC79XX_DEFAULT_IOOPTS,
 205	AIC79XX_DEFAULT_IOOPTS,
 206	AIC79XX_DEFAULT_IOOPTS,
 207	AIC79XX_DEFAULT_IOOPTS,
 208	AIC79XX_DEFAULT_IOOPTS,
 209	AIC79XX_DEFAULT_IOOPTS,
 210	AIC79XX_DEFAULT_IOOPTS,
 211	AIC79XX_DEFAULT_IOOPTS,
 212	AIC79XX_DEFAULT_IOOPTS,
 213	AIC79XX_DEFAULT_IOOPTS,
 214	AIC79XX_DEFAULT_IOOPTS
 215};
 216
 217/*
 218 * There should be a specific return value for this in scsi.h, but
 219 * it seems that most drivers ignore it.
 220 */
 221#define DID_UNDERFLOW   DID_ERROR
 222
 223void
 224ahd_print_path(struct ahd_softc *ahd, struct scb *scb)
 225{
 226	printk("(scsi%d:%c:%d:%d): ",
 227	       ahd->platform_data->host->host_no,
 228	       scb != NULL ? SCB_GET_CHANNEL(ahd, scb) : 'X',
 229	       scb != NULL ? SCB_GET_TARGET(ahd, scb) : -1,
 230	       scb != NULL ? SCB_GET_LUN(scb) : -1);
 231}
 232
 233/*
 234 * XXX - these options apply unilaterally to _all_ adapters
 235 *       cards in the system.  This should be fixed.  Exceptions to this
 236 *       rule are noted in the comments.
 237 */
 238
 239/*
 240 * Skip the scsi bus reset.  Non 0 make us skip the reset at startup.  This
 241 * has no effect on any later resets that might occur due to things like
 242 * SCSI bus timeouts.
 243 */
 244static uint32_t aic79xx_no_reset;
 245
 246/*
 247 * Should we force EXTENDED translation on a controller.
 248 *     0 == Use whatever is in the SEEPROM or default to off
 249 *     1 == Use whatever is in the SEEPROM or default to on
 250 */
 251static uint32_t aic79xx_extended;
 252
 253/*
 254 * PCI bus parity checking of the Adaptec controllers.  This is somewhat
 255 * dubious at best.  To my knowledge, this option has never actually
 256 * solved a PCI parity problem, but on certain machines with broken PCI
 257 * chipset configurations, it can generate tons of false error messages.
 258 * It's included in the driver for completeness.
 259 *   0	   = Shut off PCI parity check
 260 *   non-0 = Enable PCI parity check
 261 *
 262 * NOTE: you can't actually pass -1 on the lilo prompt.  So, to set this
 263 * variable to -1 you would actually want to simply pass the variable
 264 * name without a number.  That will invert the 0 which will result in
 265 * -1.
 266 */
 267static uint32_t aic79xx_pci_parity = ~0;
 268
 269/*
 270 * There are lots of broken chipsets in the world.  Some of them will
 271 * violate the PCI spec when we issue byte sized memory writes to our
 272 * controller.  I/O mapped register access, if allowed by the given
 273 * platform, will work in almost all cases.
 274 */
 275uint32_t aic79xx_allow_memio = ~0;
 276
 277/*
 278 * So that we can set how long each device is given as a selection timeout.
 279 * The table of values goes like this:
 280 *   0 - 256ms
 281 *   1 - 128ms
 282 *   2 - 64ms
 283 *   3 - 32ms
 284 * We default to 256ms because some older devices need a longer time
 285 * to respond to initial selection.
 286 */
 287static uint32_t aic79xx_seltime;
 288
 289/*
 290 * Certain devices do not perform any aging on commands.  Should the
 291 * device be saturated by commands in one portion of the disk, it is
 292 * possible for transactions on far away sectors to never be serviced.
 293 * To handle these devices, we can periodically send an ordered tag to
 294 * force all outstanding transactions to be serviced prior to a new
 295 * transaction.
 296 */
 297static uint32_t aic79xx_periodic_otag;
 298
 299/* Some storage boxes are using an LSI chip which has a bug making it
 300 * impossible to use aic79xx Rev B chip in 320 speeds.  The following
 301 * storage boxes have been reported to be buggy:
 302 * EonStor 3U 16-Bay: U16U-G3A3
 303 * EonStor 2U 12-Bay: U12U-G3A3
 304 * SentinelRAID: 2500F R5 / R6
 305 * SentinelRAID: 2500F R1
 306 * SentinelRAID: 2500F/1500F
 307 * SentinelRAID: 150F
 308 * 
 309 * To get around this LSI bug, you can set your board to 160 mode
 310 * or you can enable the SLOWCRC bit.
 311 */
 312uint32_t aic79xx_slowcrc;
 313
 314/*
 315 * Module information and settable options.
 316 */
 317static char *aic79xx = NULL;
 318
 319MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
 320MODULE_DESCRIPTION("Adaptec AIC790X U320 SCSI Host Bus Adapter driver");
 321MODULE_LICENSE("Dual BSD/GPL");
 322MODULE_VERSION(AIC79XX_DRIVER_VERSION);
 323module_param(aic79xx, charp, 0444);
 324MODULE_PARM_DESC(aic79xx,
 325"period-delimited options string:\n"
 326"	verbose			Enable verbose/diagnostic logging\n"
 327"	allow_memio		Allow device registers to be memory mapped\n"
 328"	debug			Bitmask of debug values to enable\n"
 329"	no_reset		Suppress initial bus resets\n"
 330"	extended		Enable extended geometry on all controllers\n"
 331"	periodic_otag		Send an ordered tagged transaction\n"
 332"				periodically to prevent tag starvation.\n"
 333"				This may be required by some older disk\n"
 334"				or drives/RAID arrays.\n"
 335"	tag_info:<tag_str>	Set per-target tag depth\n"
 336"	global_tag_depth:<int>	Global tag depth for all targets on all buses\n"
 337"	slewrate:<slewrate_list>Set the signal slew rate (0-15).\n"
 338"	precomp:<pcomp_list>	Set the signal precompensation (0-7).\n"
 339"	amplitude:<int>		Set the signal amplitude (0-7).\n"
 340"	seltime:<int>		Selection Timeout:\n"
 341"				(0/256ms,1/128ms,2/64ms,3/32ms)\n"
 342"	slowcrc			Turn on the SLOWCRC bit (Rev B only)\n"		 
 343"\n"
 344"	Sample modprobe configuration file:\n"
 345"	#	Enable verbose logging\n"
 346"	#	Set tag depth on Controller 2/Target 2 to 10 tags\n"
 347"	#	Shorten the selection timeout to 128ms\n"
 348"\n"
 349"	options aic79xx 'aic79xx=verbose.tag_info:{{}.{}.{..10}}.seltime:1'\n"
 350);
 351
 352static void ahd_linux_handle_scsi_status(struct ahd_softc *,
 353					 struct scsi_device *,
 354					 struct scb *);
 355static void ahd_linux_queue_cmd_complete(struct ahd_softc *ahd,
 356					 struct scsi_cmnd *cmd);
 357static int ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd);
 358static void ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd);
 359static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd,
 360				     struct ahd_devinfo *devinfo);
 361static void ahd_linux_device_queue_depth(struct scsi_device *);
 362static int ahd_linux_run_command(struct ahd_softc*,
 363				 struct ahd_linux_device *,
 364				 struct scsi_cmnd *);
 365static void ahd_linux_setup_tag_info_global(char *p);
 366static int  aic79xx_setup(char *c);
 367static void ahd_freeze_simq(struct ahd_softc *ahd);
 368static void ahd_release_simq(struct ahd_softc *ahd);
 369
 370static int ahd_linux_unit;
 371
 372
 373/************************** OS Utility Wrappers *******************************/
 374void ahd_delay(long);
 375void
 376ahd_delay(long usec)
 377{
 378	/*
 379	 * udelay on Linux can have problems for
 380	 * multi-millisecond waits.  Wait at most
 381	 * 1024us per call.
 382	 */
 383	while (usec > 0) {
 384		udelay(usec % 1024);
 385		usec -= 1024;
 386	}
 387}
 388
 389
 390/***************************** Low Level I/O **********************************/
 391uint8_t ahd_inb(struct ahd_softc * ahd, long port);
 392void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val);
 393void ahd_outw_atomic(struct ahd_softc * ahd,
 394				     long port, uint16_t val);
 395void ahd_outsb(struct ahd_softc * ahd, long port,
 396			       uint8_t *, int count);
 397void ahd_insb(struct ahd_softc * ahd, long port,
 398			       uint8_t *, int count);
 399
 400uint8_t
 401ahd_inb(struct ahd_softc * ahd, long port)
 402{
 403	uint8_t x;
 404
 405	if (ahd->tags[0] == BUS_SPACE_MEMIO) {
 406		x = readb(ahd->bshs[0].maddr + port);
 407	} else {
 408		x = inb(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF));
 409	}
 410	mb();
 411	return (x);
 412}
 413
 414#if 0 /* unused */
 415static uint16_t
 416ahd_inw_atomic(struct ahd_softc * ahd, long port)
 417{
 418	uint8_t x;
 419
 420	if (ahd->tags[0] == BUS_SPACE_MEMIO) {
 421		x = readw(ahd->bshs[0].maddr + port);
 422	} else {
 423		x = inw(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF));
 424	}
 425	mb();
 426	return (x);
 427}
 428#endif
 429
 430void
 431ahd_outb(struct ahd_softc * ahd, long port, uint8_t val)
 432{
 433	if (ahd->tags[0] == BUS_SPACE_MEMIO) {
 434		writeb(val, ahd->bshs[0].maddr + port);
 435	} else {
 436		outb(val, ahd->bshs[(port) >> 8].ioport + (port & 0xFF));
 437	}
 438	mb();
 439}
 440
 441void
 442ahd_outw_atomic(struct ahd_softc * ahd, long port, uint16_t val)
 443{
 444	if (ahd->tags[0] == BUS_SPACE_MEMIO) {
 445		writew(val, ahd->bshs[0].maddr + port);
 446	} else {
 447		outw(val, ahd->bshs[(port) >> 8].ioport + (port & 0xFF));
 448	}
 449	mb();
 450}
 451
 452void
 453ahd_outsb(struct ahd_softc * ahd, long port, uint8_t *array, int count)
 454{
 455	int i;
 456
 457	/*
 458	 * There is probably a more efficient way to do this on Linux
 459	 * but we don't use this for anything speed critical and this
 460	 * should work.
 461	 */
 462	for (i = 0; i < count; i++)
 463		ahd_outb(ahd, port, *array++);
 464}
 465
 466void
 467ahd_insb(struct ahd_softc * ahd, long port, uint8_t *array, int count)
 468{
 469	int i;
 470
 471	/*
 472	 * There is probably a more efficient way to do this on Linux
 473	 * but we don't use this for anything speed critical and this
 474	 * should work.
 475	 */
 476	for (i = 0; i < count; i++)
 477		*array++ = ahd_inb(ahd, port);
 478}
 479
 480/******************************* PCI Routines *********************************/
 481uint32_t
 482ahd_pci_read_config(ahd_dev_softc_t pci, int reg, int width)
 483{
 484	switch (width) {
 485	case 1:
 486	{
 487		uint8_t retval;
 488
 489		pci_read_config_byte(pci, reg, &retval);
 490		return (retval);
 491	}
 492	case 2:
 493	{
 494		uint16_t retval;
 495		pci_read_config_word(pci, reg, &retval);
 496		return (retval);
 497	}
 498	case 4:
 499	{
 500		uint32_t retval;
 501		pci_read_config_dword(pci, reg, &retval);
 502		return (retval);
 503	}
 504	default:
 505		panic("ahd_pci_read_config: Read size too big");
 506		/* NOTREACHED */
 507		return (0);
 508	}
 509}
 510
 511void
 512ahd_pci_write_config(ahd_dev_softc_t pci, int reg, uint32_t value, int width)
 513{
 514	switch (width) {
 515	case 1:
 516		pci_write_config_byte(pci, reg, value);
 517		break;
 518	case 2:
 519		pci_write_config_word(pci, reg, value);
 520		break;
 521	case 4:
 522		pci_write_config_dword(pci, reg, value);
 523		break;
 524	default:
 525		panic("ahd_pci_write_config: Write size too big");
 526		/* NOTREACHED */
 527	}
 528}
 529
 530/****************************** Inlines ***************************************/
 531static void ahd_linux_unmap_scb(struct ahd_softc*, struct scb*);
 532
 533static void
 534ahd_linux_unmap_scb(struct ahd_softc *ahd, struct scb *scb)
 535{
 536	struct scsi_cmnd *cmd;
 537
 538	cmd = scb->io_ctx;
 539	ahd_sync_sglist(ahd, scb, BUS_DMASYNC_POSTWRITE);
 540	scsi_dma_unmap(cmd);
 541}
 542
 543/******************************** Macros **************************************/
 544#define BUILD_SCSIID(ahd, cmd)						\
 545	(((scmd_id(cmd) << TID_SHIFT) & TID) | (ahd)->our_id)
 546
 547/*
 548 * Return a string describing the driver.
 549 */
 550static const char *
 551ahd_linux_info(struct Scsi_Host *host)
 552{
 553	static char buffer[512];
 554	char	ahd_info[256];
 555	char   *bp;
 556	struct ahd_softc *ahd;
 557
 558	bp = &buffer[0];
 559	ahd = *(struct ahd_softc **)host->hostdata;
 560	memset(bp, 0, sizeof(buffer));
 561	strcpy(bp, "Adaptec AIC79XX PCI-X SCSI HBA DRIVER, Rev " AIC79XX_DRIVER_VERSION "\n"
 562			"        <");
 563	strcat(bp, ahd->description);
 564	strcat(bp, ">\n"
 565			"        ");
 566	ahd_controller_info(ahd, ahd_info);
 567	strcat(bp, ahd_info);
 568
 569	return (bp);
 570}
 571
 572/*
 573 * Queue an SCB to the controller.
 574 */
 575static int
 576ahd_linux_queue_lck(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *))
 577{
 578	struct	 ahd_softc *ahd;
 579	struct	 ahd_linux_device *dev = scsi_transport_device_data(cmd->device);
 580	int rtn = SCSI_MLQUEUE_HOST_BUSY;
 581
 582	ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
 583
 584	cmd->scsi_done = scsi_done;
 585	cmd->result = CAM_REQ_INPROG << 16;
 586	rtn = ahd_linux_run_command(ahd, dev, cmd);
 587
 588	return rtn;
 589}
 590
 591static DEF_SCSI_QCMD(ahd_linux_queue)
 592
 593static struct scsi_target **
 594ahd_linux_target_in_softc(struct scsi_target *starget)
 595{
 596	struct	ahd_softc *ahd =
 597		*((struct ahd_softc **)dev_to_shost(&starget->dev)->hostdata);
 598	unsigned int target_offset;
 599
 600	target_offset = starget->id;
 601	if (starget->channel != 0)
 602		target_offset += 8;
 603
 604	return &ahd->platform_data->starget[target_offset];
 605}
 606
 607static int
 608ahd_linux_target_alloc(struct scsi_target *starget)
 609{
 610	struct	ahd_softc *ahd =
 611		*((struct ahd_softc **)dev_to_shost(&starget->dev)->hostdata);
 612	struct seeprom_config *sc = ahd->seep_config;
 613	unsigned long flags;
 614	struct scsi_target **ahd_targp = ahd_linux_target_in_softc(starget);
 615	struct ahd_devinfo devinfo;
 616	struct ahd_initiator_tinfo *tinfo;
 617	struct ahd_tmode_tstate *tstate;
 618	char channel = starget->channel + 'A';
 619
 620	ahd_lock(ahd, &flags);
 621
 622	BUG_ON(*ahd_targp != NULL);
 623
 624	*ahd_targp = starget;
 625
 626	if (sc) {
 627		int flags = sc->device_flags[starget->id];
 628
 629		tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
 630					    starget->id, &tstate);
 631
 632		if ((flags  & CFPACKETIZED) == 0) {
 633			/* don't negotiate packetized (IU) transfers */
 634			spi_max_iu(starget) = 0;
 635		} else {
 636			if ((ahd->features & AHD_RTI) == 0)
 637				spi_rti(starget) = 0;
 638		}
 639
 640		if ((flags & CFQAS) == 0)
 641			spi_max_qas(starget) = 0;
 642
 643		/* Transinfo values have been set to BIOS settings */
 644		spi_max_width(starget) = (flags & CFWIDEB) ? 1 : 0;
 645		spi_min_period(starget) = tinfo->user.period;
 646		spi_max_offset(starget) = tinfo->user.offset;
 647	}
 648
 649	tinfo = ahd_fetch_transinfo(ahd, channel, ahd->our_id,
 650				    starget->id, &tstate);
 651	ahd_compile_devinfo(&devinfo, ahd->our_id, starget->id,
 652			    CAM_LUN_WILDCARD, channel,
 653			    ROLE_INITIATOR);
 654	ahd_set_syncrate(ahd, &devinfo, 0, 0, 0,
 655			 AHD_TRANS_GOAL, /*paused*/FALSE);
 656	ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
 657		      AHD_TRANS_GOAL, /*paused*/FALSE);
 658	ahd_unlock(ahd, &flags);
 659
 660	return 0;
 661}
 662
 663static void
 664ahd_linux_target_destroy(struct scsi_target *starget)
 665{
 666	struct scsi_target **ahd_targp = ahd_linux_target_in_softc(starget);
 667
 668	*ahd_targp = NULL;
 669}
 670
 671static int
 672ahd_linux_slave_alloc(struct scsi_device *sdev)
 673{
 674	struct	ahd_softc *ahd =
 675		*((struct ahd_softc **)sdev->host->hostdata);
 676	struct ahd_linux_device *dev;
 677
 678	if (bootverbose)
 679		printk("%s: Slave Alloc %d\n", ahd_name(ahd), sdev->id);
 680
 681	dev = scsi_transport_device_data(sdev);
 682	memset(dev, 0, sizeof(*dev));
 683
 684	/*
 685	 * We start out life using untagged
 686	 * transactions of which we allow one.
 687	 */
 688	dev->openings = 1;
 689
 690	/*
 691	 * Set maxtags to 0.  This will be changed if we
 692	 * later determine that we are dealing with
 693	 * a tagged queuing capable device.
 694	 */
 695	dev->maxtags = 0;
 696	
 697	return (0);
 698}
 699
 700static int
 701ahd_linux_slave_configure(struct scsi_device *sdev)
 702{
 703	struct	ahd_softc *ahd;
 704
 705	ahd = *((struct ahd_softc **)sdev->host->hostdata);
 706	if (bootverbose)
 707		sdev_printk(KERN_INFO, sdev, "Slave Configure\n");
 708
 709	ahd_linux_device_queue_depth(sdev);
 710
 711	/* Initial Domain Validation */
 712	if (!spi_initial_dv(sdev->sdev_target))
 713		spi_dv_device(sdev);
 714
 715	return 0;
 716}
 717
 718#if defined(__i386__)
 719/*
 720 * Return the disk geometry for the given SCSI device.
 721 */
 722static int
 723ahd_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
 724		    sector_t capacity, int geom[])
 725{
 726	int	 heads;
 727	int	 sectors;
 728	int	 cylinders;
 729	int	 extended;
 730	struct	 ahd_softc *ahd;
 731
 732	ahd = *((struct ahd_softc **)sdev->host->hostdata);
 733
 734	if (scsi_partsize(bdev, capacity, geom))
 735		return 0;
 736
 737	heads = 64;
 738	sectors = 32;
 739	cylinders = aic_sector_div(capacity, heads, sectors);
 740
 741	if (aic79xx_extended != 0)
 742		extended = 1;
 743	else
 744		extended = (ahd->flags & AHD_EXTENDED_TRANS_A) != 0;
 745	if (extended && cylinders >= 1024) {
 746		heads = 255;
 747		sectors = 63;
 748		cylinders = aic_sector_div(capacity, heads, sectors);
 749	}
 750	geom[0] = heads;
 751	geom[1] = sectors;
 752	geom[2] = cylinders;
 753	return (0);
 754}
 755#endif
 756
 757/*
 758 * Abort the current SCSI command(s).
 759 */
 760static int
 761ahd_linux_abort(struct scsi_cmnd *cmd)
 762{
 763	int error;
 764	
 765	error = ahd_linux_queue_abort_cmd(cmd);
 766
 767	return error;
 768}
 769
 770/*
 771 * Attempt to send a target reset message to the device that timed out.
 772 */
 773static int
 774ahd_linux_dev_reset(struct scsi_cmnd *cmd)
 775{
 776	struct ahd_softc *ahd;
 777	struct ahd_linux_device *dev;
 778	struct scb *reset_scb;
 779	u_int  cdb_byte;
 780	int    retval = SUCCESS;
 781	int    paused;
 782	int    wait;
 783	struct	ahd_initiator_tinfo *tinfo;
 784	struct	ahd_tmode_tstate *tstate;
 785	unsigned long flags;
 786	DECLARE_COMPLETION_ONSTACK(done);
 787
 788	reset_scb = NULL;
 789	paused = FALSE;
 790	wait = FALSE;
 791	ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
 792
 793	scmd_printk(KERN_INFO, cmd,
 794		    "Attempting to queue a TARGET RESET message:");
 795
 796	printk("CDB:");
 797	for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++)
 798		printk(" 0x%x", cmd->cmnd[cdb_byte]);
 799	printk("\n");
 800
 801	/*
 802	 * Determine if we currently own this command.
 803	 */
 804	dev = scsi_transport_device_data(cmd->device);
 805
 806	if (dev == NULL) {
 807		/*
 808		 * No target device for this command exists,
 809		 * so we must not still own the command.
 810		 */
 811		scmd_printk(KERN_INFO, cmd, "Is not an active device\n");
 812		return SUCCESS;
 813	}
 814
 815	/*
 816	 * Generate us a new SCB
 817	 */
 818	reset_scb = ahd_get_scb(ahd, AHD_NEVER_COL_IDX);
 819	if (!reset_scb) {
 820		scmd_printk(KERN_INFO, cmd, "No SCB available\n");
 821		return FAILED;
 822	}
 823
 824	tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
 825				    cmd->device->id, &tstate);
 826	reset_scb->io_ctx = cmd;
 827	reset_scb->platform_data->dev = dev;
 828	reset_scb->sg_count = 0;
 829	ahd_set_residual(reset_scb, 0);
 830	ahd_set_sense_residual(reset_scb, 0);
 831	reset_scb->platform_data->xfer_len = 0;
 832	reset_scb->hscb->control = 0;
 833	reset_scb->hscb->scsiid = BUILD_SCSIID(ahd,cmd);
 834	reset_scb->hscb->lun = cmd->device->lun;
 835	reset_scb->hscb->cdb_len = 0;
 836	reset_scb->hscb->task_management = SIU_TASKMGMT_LUN_RESET;
 837	reset_scb->flags |= SCB_DEVICE_RESET|SCB_RECOVERY_SCB|SCB_ACTIVE;
 838	if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0) {
 839		reset_scb->flags |= SCB_PACKETIZED;
 840	} else {
 841		reset_scb->hscb->control |= MK_MESSAGE;
 842	}
 843	dev->openings--;
 844	dev->active++;
 845	dev->commands_issued++;
 846
 847	ahd_lock(ahd, &flags);
 848
 849	LIST_INSERT_HEAD(&ahd->pending_scbs, reset_scb, pending_links);
 850	ahd_queue_scb(ahd, reset_scb);
 851
 852	ahd->platform_data->eh_done = &done;
 853	ahd_unlock(ahd, &flags);
 854
 855	printk("%s: Device reset code sleeping\n", ahd_name(ahd));
 856	if (!wait_for_completion_timeout(&done, 5 * HZ)) {
 857		ahd_lock(ahd, &flags);
 858		ahd->platform_data->eh_done = NULL;
 859		ahd_unlock(ahd, &flags);
 860		printk("%s: Device reset timer expired (active %d)\n",
 861		       ahd_name(ahd), dev->active);
 862		retval = FAILED;
 863	}
 864	printk("%s: Device reset returning 0x%x\n", ahd_name(ahd), retval);
 865
 866	return (retval);
 867}
 868
 869/*
 870 * Reset the SCSI bus.
 871 */
 872static int
 873ahd_linux_bus_reset(struct scsi_cmnd *cmd)
 874{
 875	struct ahd_softc *ahd;
 876	int    found;
 877	unsigned long flags;
 878
 879	ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
 880#ifdef AHD_DEBUG
 881	if ((ahd_debug & AHD_SHOW_RECOVERY) != 0)
 882		printk("%s: Bus reset called for cmd %p\n",
 883		       ahd_name(ahd), cmd);
 884#endif
 885	ahd_lock(ahd, &flags);
 886
 887	found = ahd_reset_channel(ahd, scmd_channel(cmd) + 'A',
 888				  /*initiate reset*/TRUE);
 889	ahd_unlock(ahd, &flags);
 890
 891	if (bootverbose)
 892		printk("%s: SCSI bus reset delivered. "
 893		       "%d SCBs aborted.\n", ahd_name(ahd), found);
 894
 895	return (SUCCESS);
 896}
 897
 898struct scsi_host_template aic79xx_driver_template = {
 899	.module			= THIS_MODULE,
 900	.name			= "aic79xx",
 901	.proc_name		= "aic79xx",
 902	.show_info		= ahd_linux_show_info,
 903	.write_info	 	= ahd_proc_write_seeprom,
 904	.info			= ahd_linux_info,
 905	.queuecommand		= ahd_linux_queue,
 906	.eh_abort_handler	= ahd_linux_abort,
 907	.eh_device_reset_handler = ahd_linux_dev_reset,
 908	.eh_bus_reset_handler	= ahd_linux_bus_reset,
 909#if defined(__i386__)
 910	.bios_param		= ahd_linux_biosparam,
 911#endif
 912	.can_queue		= AHD_MAX_QUEUE,
 913	.this_id		= -1,
 914	.max_sectors		= 8192,
 915	.cmd_per_lun		= 2,
 916	.slave_alloc		= ahd_linux_slave_alloc,
 917	.slave_configure	= ahd_linux_slave_configure,
 918	.target_alloc		= ahd_linux_target_alloc,
 919	.target_destroy		= ahd_linux_target_destroy,
 920};
 921
 922/******************************** Bus DMA *************************************/
 923int
 924ahd_dma_tag_create(struct ahd_softc *ahd, bus_dma_tag_t parent,
 925		   bus_size_t alignment, bus_size_t boundary,
 926		   dma_addr_t lowaddr, dma_addr_t highaddr,
 927		   bus_dma_filter_t *filter, void *filterarg,
 928		   bus_size_t maxsize, int nsegments,
 929		   bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag)
 930{
 931	bus_dma_tag_t dmat;
 932
 933	dmat = kmalloc(sizeof(*dmat), GFP_ATOMIC);
 934	if (dmat == NULL)
 935		return (ENOMEM);
 936
 937	/*
 938	 * Linux is very simplistic about DMA memory.  For now don't
 939	 * maintain all specification information.  Once Linux supplies
 940	 * better facilities for doing these operations, or the
 941	 * needs of this particular driver change, we might need to do
 942	 * more here.
 943	 */
 944	dmat->alignment = alignment;
 945	dmat->boundary = boundary;
 946	dmat->maxsize = maxsize;
 947	*ret_tag = dmat;
 948	return (0);
 949}
 950
 951void
 952ahd_dma_tag_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat)
 953{
 954	kfree(dmat);
 955}
 956
 957int
 958ahd_dmamem_alloc(struct ahd_softc *ahd, bus_dma_tag_t dmat, void** vaddr,
 959		 int flags, bus_dmamap_t *mapp)
 960{
 961	*vaddr = pci_alloc_consistent(ahd->dev_softc,
 962				      dmat->maxsize, mapp);
 963	if (*vaddr == NULL)
 964		return (ENOMEM);
 965	return(0);
 966}
 967
 968void
 969ahd_dmamem_free(struct ahd_softc *ahd, bus_dma_tag_t dmat,
 970		void* vaddr, bus_dmamap_t map)
 971{
 972	pci_free_consistent(ahd->dev_softc, dmat->maxsize,
 973			    vaddr, map);
 974}
 975
 976int
 977ahd_dmamap_load(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map,
 978		void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb,
 979		void *cb_arg, int flags)
 980{
 981	/*
 982	 * Assume for now that this will only be used during
 983	 * initialization and not for per-transaction buffer mapping.
 984	 */
 985	bus_dma_segment_t stack_sg;
 986
 987	stack_sg.ds_addr = map;
 988	stack_sg.ds_len = dmat->maxsize;
 989	cb(cb_arg, &stack_sg, /*nseg*/1, /*error*/0);
 990	return (0);
 991}
 992
 993void
 994ahd_dmamap_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map)
 995{
 996}
 997
 998int
 999ahd_dmamap_unload(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map)
1000{
1001	/* Nothing to do */
1002	return (0);
1003}
1004
1005/********************* Platform Dependent Functions ***************************/
1006static void
1007ahd_linux_setup_iocell_info(u_long index, int instance, int targ, int32_t value)
1008{
1009
1010	if ((instance >= 0)
1011	 && (instance < ARRAY_SIZE(aic79xx_iocell_info))) {
1012		uint8_t *iocell_info;
1013
1014		iocell_info = (uint8_t*)&aic79xx_iocell_info[instance];
1015		iocell_info[index] = value & 0xFFFF;
1016		if (bootverbose)
1017			printk("iocell[%d:%ld] = %d\n", instance, index, value);
1018	}
1019}
1020
1021static void
1022ahd_linux_setup_tag_info_global(char *p)
1023{
1024	int tags, i, j;
1025
1026	tags = simple_strtoul(p + 1, NULL, 0) & 0xff;
1027	printk("Setting Global Tags= %d\n", tags);
1028
1029	for (i = 0; i < ARRAY_SIZE(aic79xx_tag_info); i++) {
1030		for (j = 0; j < AHD_NUM_TARGETS; j++) {
1031			aic79xx_tag_info[i].tag_commands[j] = tags;
1032		}
1033	}
1034}
1035
1036static void
1037ahd_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value)
1038{
1039
1040	if ((instance >= 0) && (targ >= 0)
1041	 && (instance < ARRAY_SIZE(aic79xx_tag_info))
1042	 && (targ < AHD_NUM_TARGETS)) {
1043		aic79xx_tag_info[instance].tag_commands[targ] = value & 0x1FF;
1044		if (bootverbose)
1045			printk("tag_info[%d:%d] = %d\n", instance, targ, value);
1046	}
1047}
1048
1049static char *
1050ahd_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth,
1051		       void (*callback)(u_long, int, int, int32_t),
1052		       u_long callback_arg)
1053{
1054	char	*tok_end;
1055	char	*tok_end2;
1056	int      i;
1057	int      instance;
1058	int	 targ;
1059	int	 done;
1060	char	 tok_list[] = {'.', ',', '{', '}', '\0'};
1061
1062	/* All options use a ':' name/arg separator */
1063	if (*opt_arg != ':')
1064		return (opt_arg);
1065	opt_arg++;
1066	instance = -1;
1067	targ = -1;
1068	done = FALSE;
1069	/*
1070	 * Restore separator that may be in
1071	 * the middle of our option argument.
1072	 */
1073	tok_end = strchr(opt_arg, '\0');
1074	if (tok_end < end)
1075		*tok_end = ',';
1076	while (!done) {
1077		switch (*opt_arg) {
1078		case '{':
1079			if (instance == -1) {
1080				instance = 0;
1081			} else {
1082				if (depth > 1) {
1083					if (targ == -1)
1084						targ = 0;
1085				} else {
1086					printk("Malformed Option %s\n",
1087					       opt_name);
1088					done = TRUE;
1089				}
1090			}
1091			opt_arg++;
1092			break;
1093		case '}':
1094			if (targ != -1)
1095				targ = -1;
1096			else if (instance != -1)
1097				instance = -1;
1098			opt_arg++;
1099			break;
1100		case ',':
1101		case '.':
1102			if (instance == -1)
1103				done = TRUE;
1104			else if (targ >= 0)
1105				targ++;
1106			else if (instance >= 0)
1107				instance++;
1108			opt_arg++;
1109			break;
1110		case '\0':
1111			done = TRUE;
1112			break;
1113		default:
1114			tok_end = end;
1115			for (i = 0; tok_list[i]; i++) {
1116				tok_end2 = strchr(opt_arg, tok_list[i]);
1117				if ((tok_end2) && (tok_end2 < tok_end))
1118					tok_end = tok_end2;
1119			}
1120			callback(callback_arg, instance, targ,
1121				 simple_strtol(opt_arg, NULL, 0));
1122			opt_arg = tok_end;
1123			break;
1124		}
1125	}
1126	return (opt_arg);
1127}
1128
1129/*
1130 * Handle Linux boot parameters. This routine allows for assigning a value
1131 * to a parameter with a ':' between the parameter and the value.
1132 * ie. aic79xx=stpwlev:1,extended
1133 */
1134static int
1135aic79xx_setup(char *s)
1136{
1137	int	i, n;
1138	char   *p;
1139	char   *end;
1140
1141	static const struct {
1142		const char *name;
1143		uint32_t *flag;
1144	} options[] = {
1145		{ "extended", &aic79xx_extended },
1146		{ "no_reset", &aic79xx_no_reset },
1147		{ "verbose", &aic79xx_verbose },
1148		{ "allow_memio", &aic79xx_allow_memio},
1149#ifdef AHD_DEBUG
1150		{ "debug", &ahd_debug },
1151#endif
1152		{ "periodic_otag", &aic79xx_periodic_otag },
1153		{ "pci_parity", &aic79xx_pci_parity },
1154		{ "seltime", &aic79xx_seltime },
1155		{ "tag_info", NULL },
1156		{ "global_tag_depth", NULL},
1157		{ "slewrate", NULL },
1158		{ "precomp", NULL },
1159		{ "amplitude", NULL },
1160		{ "slowcrc", &aic79xx_slowcrc },
1161	};
1162
1163	end = strchr(s, '\0');
1164
1165	/*
1166	 * XXX ia64 gcc isn't smart enough to know that ARRAY_SIZE
1167	 * will never be 0 in this case.
1168	 */
1169	n = 0;
1170
1171	while ((p = strsep(&s, ",.")) != NULL) {
1172		if (*p == '\0')
1173			continue;
1174		for (i = 0; i < ARRAY_SIZE(options); i++) {
1175
1176			n = strlen(options[i].name);
1177			if (strncmp(options[i].name, p, n) == 0)
1178				break;
1179		}
1180		if (i == ARRAY_SIZE(options))
1181			continue;
1182
1183		if (strncmp(p, "global_tag_depth", n) == 0) {
1184			ahd_linux_setup_tag_info_global(p + n);
1185		} else if (strncmp(p, "tag_info", n) == 0) {
1186			s = ahd_parse_brace_option("tag_info", p + n, end,
1187			    2, ahd_linux_setup_tag_info, 0);
1188		} else if (strncmp(p, "slewrate", n) == 0) {
1189			s = ahd_parse_brace_option("slewrate",
1190			    p + n, end, 1, ahd_linux_setup_iocell_info,
1191			    AIC79XX_SLEWRATE_INDEX);
1192		} else if (strncmp(p, "precomp", n) == 0) {
1193			s = ahd_parse_brace_option("precomp",
1194			    p + n, end, 1, ahd_linux_setup_iocell_info,
1195			    AIC79XX_PRECOMP_INDEX);
1196		} else if (strncmp(p, "amplitude", n) == 0) {
1197			s = ahd_parse_brace_option("amplitude",
1198			    p + n, end, 1, ahd_linux_setup_iocell_info,
1199			    AIC79XX_AMPLITUDE_INDEX);
1200		} else if (p[n] == ':') {
1201			*(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);
1202		} else if (!strncmp(p, "verbose", n)) {
1203			*(options[i].flag) = 1;
1204		} else {
1205			*(options[i].flag) ^= 0xFFFFFFFF;
1206		}
1207	}
1208	return 1;
1209}
1210
1211__setup("aic79xx=", aic79xx_setup);
1212
1213uint32_t aic79xx_verbose;
1214
1215int
1216ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *template)
1217{
1218	char	buf[80];
1219	struct	Scsi_Host *host;
1220	char	*new_name;
1221	u_long	s;
1222	int	retval;
1223
1224	template->name = ahd->description;
1225	host = scsi_host_alloc(template, sizeof(struct ahd_softc *));
1226	if (host == NULL)
1227		return (ENOMEM);
1228
1229	*((struct ahd_softc **)host->hostdata) = ahd;
1230	ahd->platform_data->host = host;
1231	host->can_queue = AHD_MAX_QUEUE;
1232	host->cmd_per_lun = 2;
1233	host->sg_tablesize = AHD_NSEG;
1234	host->this_id = ahd->our_id;
1235	host->irq = ahd->platform_data->irq;
1236	host->max_id = (ahd->features & AHD_WIDE) ? 16 : 8;
1237	host->max_lun = AHD_NUM_LUNS;
1238	host->max_channel = 0;
1239	host->sg_tablesize = AHD_NSEG;
1240	ahd_lock(ahd, &s);
1241	ahd_set_unit(ahd, ahd_linux_unit++);
1242	ahd_unlock(ahd, &s);
1243	sprintf(buf, "scsi%d", host->host_no);
1244	new_name = kmalloc(strlen(buf) + 1, GFP_ATOMIC);
1245	if (new_name != NULL) {
1246		strcpy(new_name, buf);
1247		ahd_set_name(ahd, new_name);
1248	}
1249	host->unique_id = ahd->unit;
1250	ahd_linux_initialize_scsi_bus(ahd);
1251	ahd_intr_enable(ahd, TRUE);
1252
1253	host->transportt = ahd_linux_transport_template;
1254
1255	retval = scsi_add_host(host, &ahd->dev_softc->dev);
1256	if (retval) {
1257		printk(KERN_WARNING "aic79xx: scsi_add_host failed\n");
1258		scsi_host_put(host);
1259		return retval;
1260	}
1261
1262	scsi_scan_host(host);
1263	return 0;
1264}
1265
1266/*
1267 * Place the SCSI bus into a known state by either resetting it,
1268 * or forcing transfer negotiations on the next command to any
1269 * target.
1270 */
1271static void
1272ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd)
1273{
1274	u_int target_id;
1275	u_int numtarg;
1276	unsigned long s;
1277
1278	target_id = 0;
1279	numtarg = 0;
1280
1281	if (aic79xx_no_reset != 0)
1282		ahd->flags &= ~AHD_RESET_BUS_A;
1283
1284	if ((ahd->flags & AHD_RESET_BUS_A) != 0)
1285		ahd_reset_channel(ahd, 'A', /*initiate_reset*/TRUE);
1286	else
1287		numtarg = (ahd->features & AHD_WIDE) ? 16 : 8;
1288
1289	ahd_lock(ahd, &s);
1290
1291	/*
1292	 * Force negotiation to async for all targets that
1293	 * will not see an initial bus reset.
1294	 */
1295	for (; target_id < numtarg; target_id++) {
1296		struct ahd_devinfo devinfo;
1297		struct ahd_initiator_tinfo *tinfo;
1298		struct ahd_tmode_tstate *tstate;
1299
1300		tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
1301					    target_id, &tstate);
1302		ahd_compile_devinfo(&devinfo, ahd->our_id, target_id,
1303				    CAM_LUN_WILDCARD, 'A', ROLE_INITIATOR);
1304		ahd_update_neg_request(ahd, &devinfo, tstate,
1305				       tinfo, AHD_NEG_ALWAYS);
1306	}
1307	ahd_unlock(ahd, &s);
1308	/* Give the bus some time to recover */
1309	if ((ahd->flags & AHD_RESET_BUS_A) != 0) {
1310		ahd_freeze_simq(ahd);
1311		msleep(AIC79XX_RESET_DELAY);
1312		ahd_release_simq(ahd);
1313	}
1314}
1315
1316int
1317ahd_platform_alloc(struct ahd_softc *ahd, void *platform_arg)
1318{
1319	ahd->platform_data =
1320	    kzalloc(sizeof(struct ahd_platform_data), GFP_ATOMIC);
1321	if (ahd->platform_data == NULL)
1322		return (ENOMEM);
1323	ahd->platform_data->irq = AHD_LINUX_NOIRQ;
1324	ahd_lockinit(ahd);
1325	ahd->seltime = (aic79xx_seltime & 0x3) << 4;
1326	return (0);
1327}
1328
1329void
1330ahd_platform_free(struct ahd_softc *ahd)
1331{
1332	struct scsi_target *starget;
1333	int i;
1334
1335	if (ahd->platform_data != NULL) {
1336		/* destroy all of the device and target objects */
1337		for (i = 0; i < AHD_NUM_TARGETS; i++) {
1338			starget = ahd->platform_data->starget[i];
1339			if (starget != NULL) {
1340				ahd->platform_data->starget[i] = NULL;
1341			}
1342		}
1343
1344		if (ahd->platform_data->irq != AHD_LINUX_NOIRQ)
1345			free_irq(ahd->platform_data->irq, ahd);
1346		if (ahd->tags[0] == BUS_SPACE_PIO
1347		 && ahd->bshs[0].ioport != 0)
1348			release_region(ahd->bshs[0].ioport, 256);
1349		if (ahd->tags[1] == BUS_SPACE_PIO
1350		 && ahd->bshs[1].ioport != 0)
1351			release_region(ahd->bshs[1].ioport, 256);
1352		if (ahd->tags[0] == BUS_SPACE_MEMIO
1353		 && ahd->bshs[0].maddr != NULL) {
1354			iounmap(ahd->bshs[0].maddr);
1355			release_mem_region(ahd->platform_data->mem_busaddr,
1356					   0x1000);
1357		}
1358		if (ahd->platform_data->host)
1359			scsi_host_put(ahd->platform_data->host);
1360
1361		kfree(ahd->platform_data);
1362	}
1363}
1364
1365void
1366ahd_platform_init(struct ahd_softc *ahd)
1367{
1368	/*
1369	 * Lookup and commit any modified IO Cell options.
1370	 */
1371	if (ahd->unit < ARRAY_SIZE(aic79xx_iocell_info)) {
1372		const struct ahd_linux_iocell_opts *iocell_opts;
1373
1374		iocell_opts = &aic79xx_iocell_info[ahd->unit];
1375		if (iocell_opts->precomp != AIC79XX_DEFAULT_PRECOMP)
1376			AHD_SET_PRECOMP(ahd, iocell_opts->precomp);
1377		if (iocell_opts->slewrate != AIC79XX_DEFAULT_SLEWRATE)
1378			AHD_SET_SLEWRATE(ahd, iocell_opts->slewrate);
1379		if (iocell_opts->amplitude != AIC79XX_DEFAULT_AMPLITUDE)
1380			AHD_SET_AMPLITUDE(ahd, iocell_opts->amplitude);
1381	}
1382
1383}
1384
1385void
1386ahd_platform_freeze_devq(struct ahd_softc *ahd, struct scb *scb)
1387{
1388	ahd_platform_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
1389				SCB_GET_CHANNEL(ahd, scb),
1390				SCB_GET_LUN(scb), SCB_LIST_NULL,
1391				ROLE_UNKNOWN, CAM_REQUEUE_REQ);
1392}
1393
1394void
1395ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev,
1396		      struct ahd_devinfo *devinfo, ahd_queue_alg alg)
1397{
1398	struct ahd_linux_device *dev;
1399	int was_queuing;
1400	int now_queuing;
1401
1402	if (sdev == NULL)
1403		return;
1404
1405	dev = scsi_transport_device_data(sdev);
1406
1407	if (dev == NULL)
1408		return;
1409	was_queuing = dev->flags & (AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED);
1410	switch (alg) {
1411	default:
1412	case AHD_QUEUE_NONE:
1413		now_queuing = 0;
1414		break; 
1415	case AHD_QUEUE_BASIC:
1416		now_queuing = AHD_DEV_Q_BASIC;
1417		break;
1418	case AHD_QUEUE_TAGGED:
1419		now_queuing = AHD_DEV_Q_TAGGED;
1420		break;
1421	}
1422	if ((dev->flags & AHD_DEV_FREEZE_TIL_EMPTY) == 0
1423	 && (was_queuing != now_queuing)
1424	 && (dev->active != 0)) {
1425		dev->flags |= AHD_DEV_FREEZE_TIL_EMPTY;
1426		dev->qfrozen++;
1427	}
1428
1429	dev->flags &= ~(AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED|AHD_DEV_PERIODIC_OTAG);
1430	if (now_queuing) {
1431		u_int usertags;
1432
1433		usertags = ahd_linux_user_tagdepth(ahd, devinfo);
1434		if (!was_queuing) {
1435			/*
1436			 * Start out aggressively and allow our
1437			 * dynamic queue depth algorithm to take
1438			 * care of the rest.
1439			 */
1440			dev->maxtags = usertags;
1441			dev->openings = dev->maxtags - dev->active;
1442		}
1443		if (dev->maxtags == 0) {
1444			/*
1445			 * Queueing is disabled by the user.
1446			 */
1447			dev->openings = 1;
1448		} else if (alg == AHD_QUEUE_TAGGED) {
1449			dev->flags |= AHD_DEV_Q_TAGGED;
1450			if (aic79xx_periodic_otag != 0)
1451				dev->flags |= AHD_DEV_PERIODIC_OTAG;
1452		} else
1453			dev->flags |= AHD_DEV_Q_BASIC;
1454	} else {
1455		/* We can only have one opening. */
1456		dev->maxtags = 0;
1457		dev->openings =  1 - dev->active;
1458	}
1459
1460	switch ((dev->flags & (AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED))) {
1461	case AHD_DEV_Q_BASIC:
1462	case AHD_DEV_Q_TAGGED:
1463		scsi_change_queue_depth(sdev,
1464				dev->openings + dev->active);
1465		break;
1466	default:
1467		/*
1468		 * We allow the OS to queue 2 untagged transactions to
1469		 * us at any time even though we can only execute them
1470		 * serially on the controller/device.  This should
1471		 * remove some latency.
1472		 */
1473		scsi_change_queue_depth(sdev, 1);
1474		break;
1475	}
1476}
1477
1478int
1479ahd_platform_abort_scbs(struct ahd_softc *ahd, int target, char channel,
1480			int lun, u_int tag, role_t role, uint32_t status)
1481{
1482	return 0;
1483}
1484
1485static u_int
1486ahd_linux_user_tagdepth(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
1487{
1488	static int warned_user;
1489	u_int tags;
1490
1491	tags = 0;
1492	if ((ahd->user_discenable & devinfo->target_mask) != 0) {
1493		if (ahd->unit >= ARRAY_SIZE(aic79xx_tag_info)) {
1494
1495			if (warned_user == 0) {
1496				printk(KERN_WARNING
1497"aic79xx: WARNING: Insufficient tag_info instances\n"
1498"aic79xx: for installed controllers.  Using defaults\n"
1499"aic79xx: Please update the aic79xx_tag_info array in\n"
1500"aic79xx: the aic79xx_osm.c source file.\n");
1501				warned_user++;
1502			}
1503			tags = AHD_MAX_QUEUE;
1504		} else {
1505			adapter_tag_info_t *tag_info;
1506
1507			tag_info = &aic79xx_tag_info[ahd->unit];
1508			tags = tag_info->tag_commands[devinfo->target_offset];
1509			if (tags > AHD_MAX_QUEUE)
1510				tags = AHD_MAX_QUEUE;
1511		}
1512	}
1513	return (tags);
1514}
1515
1516/*
1517 * Determines the queue depth for a given device.
1518 */
1519static void
1520ahd_linux_device_queue_depth(struct scsi_device *sdev)
1521{
1522	struct	ahd_devinfo devinfo;
1523	u_int	tags;
1524	struct ahd_softc *ahd = *((struct ahd_softc **)sdev->host->hostdata);
1525
1526	ahd_compile_devinfo(&devinfo,
1527			    ahd->our_id,
1528			    sdev->sdev_target->id, sdev->lun,
1529			    sdev->sdev_target->channel == 0 ? 'A' : 'B',
1530			    ROLE_INITIATOR);
1531	tags = ahd_linux_user_tagdepth(ahd, &devinfo);
1532	if (tags != 0 && sdev->tagged_supported != 0) {
1533
1534		ahd_platform_set_tags(ahd, sdev, &devinfo, AHD_QUEUE_TAGGED);
1535		ahd_send_async(ahd, devinfo.channel, devinfo.target,
1536			       devinfo.lun, AC_TRANSFER_NEG);
1537		ahd_print_devinfo(ahd, &devinfo);
1538		printk("Tagged Queuing enabled.  Depth %d\n", tags);
1539	} else {
1540		ahd_platform_set_tags(ahd, sdev, &devinfo, AHD_QUEUE_NONE);
1541		ahd_send_async(ahd, devinfo.channel, devinfo.target,
1542			       devinfo.lun, AC_TRANSFER_NEG);
1543	}
1544}
1545
1546static int
1547ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev,
1548		      struct scsi_cmnd *cmd)
1549{
1550	struct	 scb *scb;
1551	struct	 hardware_scb *hscb;
1552	struct	 ahd_initiator_tinfo *tinfo;
1553	struct	 ahd_tmode_tstate *tstate;
1554	u_int	 col_idx;
1555	uint16_t mask;
1556	unsigned long flags;
1557	int nseg;
1558
1559	nseg = scsi_dma_map(cmd);
1560	if (nseg < 0)
1561		return SCSI_MLQUEUE_HOST_BUSY;
1562
1563	ahd_lock(ahd, &flags);
1564
1565	/*
1566	 * Get an scb to use.
1567	 */
1568	tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
1569				    cmd->device->id, &tstate);
1570	if ((dev->flags & (AHD_DEV_Q_TAGGED|AHD_DEV_Q_BASIC)) == 0
1571	 || (tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0) {
1572		col_idx = AHD_NEVER_COL_IDX;
1573	} else {
1574		col_idx = AHD_BUILD_COL_IDX(cmd->device->id,
1575					    cmd->device->lun);
1576	}
1577	if ((scb = ahd_get_scb(ahd, col_idx)) == NULL) {
1578		ahd->flags |= AHD_RESOURCE_SHORTAGE;
1579		ahd_unlock(ahd, &flags);
1580		scsi_dma_unmap(cmd);
1581		return SCSI_MLQUEUE_HOST_BUSY;
1582	}
1583
1584	scb->io_ctx = cmd;
1585	scb->platform_data->dev = dev;
1586	hscb = scb->hscb;
1587	cmd->host_scribble = (char *)scb;
1588
1589	/*
1590	 * Fill out basics of the HSCB.
1591	 */
1592	hscb->control = 0;
1593	hscb->scsiid = BUILD_SCSIID(ahd, cmd);
1594	hscb->lun = cmd->device->lun;
1595	scb->hscb->task_management = 0;
1596	mask = SCB_GET_TARGET_MASK(ahd, scb);
1597
1598	if ((ahd->user_discenable & mask) != 0)
1599		hscb->control |= DISCENB;
1600
1601	if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0)
1602		scb->flags |= SCB_PACKETIZED;
1603
1604	if ((tstate->auto_negotiate & mask) != 0) {
1605		scb->flags |= SCB_AUTO_NEGOTIATE;
1606		scb->hscb->control |= MK_MESSAGE;
1607	}
1608
1609	if ((dev->flags & (AHD_DEV_Q_TAGGED|AHD_DEV_Q_BASIC)) != 0) {
1610		if (dev->commands_since_idle_or_otag == AHD_OTAG_THRESH
1611		 && (dev->flags & AHD_DEV_Q_TAGGED) != 0) {
1612			hscb->control |= MSG_ORDERED_TASK;
1613			dev->commands_since_idle_or_otag = 0;
1614		} else {
1615			hscb->control |= MSG_SIMPLE_TASK;
1616		}
1617	}
1618
1619	hscb->cdb_len = cmd->cmd_len;
1620	memcpy(hscb->shared_data.idata.cdb, cmd->cmnd, hscb->cdb_len);
1621
1622	scb->platform_data->xfer_len = 0;
1623	ahd_set_residual(scb, 0);
1624	ahd_set_sense_residual(scb, 0);
1625	scb->sg_count = 0;
1626
1627	if (nseg > 0) {
1628		void *sg = scb->sg_list;
1629		struct scatterlist *cur_seg;
1630		int i;
1631
1632		scb->platform_data->xfer_len = 0;
1633
1634		scsi_for_each_sg(cmd, cur_seg, nseg, i) {
1635			dma_addr_t addr;
1636			bus_size_t len;
1637
1638			addr = sg_dma_address(cur_seg);
1639			len = sg_dma_len(cur_seg);
1640			scb->platform_data->xfer_len += len;
1641			sg = ahd_sg_setup(ahd, scb, sg, addr, len,
1642					  i == (nseg - 1));
1643		}
1644	}
1645
1646	LIST_INSERT_HEAD(&ahd->pending_scbs, scb, pending_links);
1647	dev->openings--;
1648	dev->active++;
1649	dev->commands_issued++;
1650
1651	if ((dev->flags & AHD_DEV_PERIODIC_OTAG) != 0)
1652		dev->commands_since_idle_or_otag++;
1653	scb->flags |= SCB_ACTIVE;
1654	ahd_queue_scb(ahd, scb);
1655
1656	ahd_unlock(ahd, &flags);
1657
1658	return 0;
1659}
1660
1661/*
1662 * SCSI controller interrupt handler.
1663 */
1664irqreturn_t
1665ahd_linux_isr(int irq, void *dev_id)
1666{
1667	struct	ahd_softc *ahd;
1668	u_long	flags;
1669	int	ours;
1670
1671	ahd = (struct ahd_softc *) dev_id;
1672	ahd_lock(ahd, &flags); 
1673	ours = ahd_intr(ahd);
1674	ahd_unlock(ahd, &flags);
1675	return IRQ_RETVAL(ours);
1676}
1677
1678void
1679ahd_send_async(struct ahd_softc *ahd, char channel,
1680	       u_int target, u_int lun, ac_code code)
1681{
1682	switch (code) {
1683	case AC_TRANSFER_NEG:
1684	{
1685		struct  scsi_target *starget;
1686		struct	ahd_initiator_tinfo *tinfo;
1687		struct	ahd_tmode_tstate *tstate;
1688		unsigned int target_ppr_options;
1689
1690		BUG_ON(target == CAM_TARGET_WILDCARD);
1691
1692		tinfo = ahd_fetch_transinfo(ahd, channel, ahd->our_id,
1693					    target, &tstate);
1694
1695		/*
1696		 * Don't bother reporting results while
1697		 * negotiations are still pending.
1698		 */
1699		if (tinfo->curr.period != tinfo->goal.period
1700		 || tinfo->curr.width != tinfo->goal.width
1701		 || tinfo->curr.offset != tinfo->goal.offset
1702		 || tinfo->curr.ppr_options != tinfo->goal.ppr_options)
1703			if (bootverbose == 0)
1704				break;
1705
1706		/*
1707		 * Don't bother reporting results that
1708		 * are identical to those last reported.
1709		 */
1710		starget = ahd->platform_data->starget[target];
1711		if (starget == NULL)
1712			break;
1713
1714		target_ppr_options =
1715			(spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0)
1716			+ (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : 0)
1717			+ (spi_iu(starget) ?  MSG_EXT_PPR_IU_REQ : 0)
1718			+ (spi_rd_strm(starget) ? MSG_EXT_PPR_RD_STRM : 0)
1719			+ (spi_pcomp_en(starget) ? MSG_EXT_PPR_PCOMP_EN : 0)
1720			+ (spi_rti(starget) ? MSG_EXT_PPR_RTI : 0)
1721			+ (spi_wr_flow(starget) ? MSG_EXT_PPR_WR_FLOW : 0)
1722			+ (spi_hold_mcs(starget) ? MSG_EXT_PPR_HOLD_MCS : 0);
1723
1724		if (tinfo->curr.period == spi_period(starget)
1725		    && tinfo->curr.width == spi_width(starget)
1726		    && tinfo->curr.offset == spi_offset(starget)
1727		 && tinfo->curr.ppr_options == target_ppr_options)
1728			if (bootverbose == 0)
1729				break;
1730
1731		spi_period(starget) = tinfo->curr.period;
1732		spi_width(starget) = tinfo->curr.width;
1733		spi_offset(starget) = tinfo->curr.offset;
1734		spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ ? 1 : 0;
1735		spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ ? 1 : 0;
1736		spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ ? 1 : 0;
1737		spi_rd_strm(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_RD_STRM ? 1 : 0;
1738		spi_pcomp_en(starget) =  tinfo->curr.ppr_options & MSG_EXT_PPR_PCOMP_EN ? 1 : 0;
1739		spi_rti(starget) =  tinfo->curr.ppr_options &  MSG_EXT_PPR_RTI ? 1 : 0;
1740		spi_wr_flow(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_WR_FLOW ? 1 : 0;
1741		spi_hold_mcs(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_HOLD_MCS ? 1 : 0;
1742		spi_display_xfer_agreement(starget);
1743		break;
1744	}
1745        case AC_SENT_BDR:
1746	{
1747		WARN_ON(lun != CAM_LUN_WILDCARD);
1748		scsi_report_device_reset(ahd->platform_data->host,
1749					 channel - 'A', target);
1750		break;
1751	}
1752        case AC_BUS_RESET:
1753		if (ahd->platform_data->host != NULL) {
1754			scsi_report_bus_reset(ahd->platform_data->host,
1755					      channel - 'A');
1756		}
1757                break;
1758        default:
1759                panic("ahd_send_async: Unexpected async event");
1760        }
1761}
1762
1763/*
1764 * Calls the higher level scsi done function and frees the scb.
1765 */
1766void
1767ahd_done(struct ahd_softc *ahd, struct scb *scb)
1768{
1769	struct scsi_cmnd *cmd;
1770	struct	  ahd_linux_device *dev;
1771
1772	if ((scb->flags & SCB_ACTIVE) == 0) {
1773		printk("SCB %d done'd twice\n", SCB_GET_TAG(scb));
1774		ahd_dump_card_state(ahd);
1775		panic("Stopping for safety");
1776	}
1777	LIST_REMOVE(scb, pending_links);
1778	cmd = scb->io_ctx;
1779	dev = scb->platform_data->dev;
1780	dev->active--;
1781	dev->openings++;
1782	if ((cmd->result & (CAM_DEV_QFRZN << 16)) != 0) {
1783		cmd->result &= ~(CAM_DEV_QFRZN << 16);
1784		dev->qfrozen--;
1785	}
1786	ahd_linux_unmap_scb(ahd, scb);
1787
1788	/*
1789	 * Guard against stale sense data.
1790	 * The Linux mid-layer assumes that sense
1791	 * was retrieved anytime the first byte of
1792	 * the sense buffer looks "sane".
1793	 */
1794	cmd->sense_buffer[0] = 0;
1795	if (ahd_get_transaction_status(scb) == CAM_REQ_INPROG) {
1796		uint32_t amount_xferred;
1797
1798		amount_xferred =
1799		    ahd_get_transfer_length(scb) - ahd_get_residual(scb);
1800		if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {
1801#ifdef AHD_DEBUG
1802			if ((ahd_debug & AHD_SHOW_MISC) != 0) {
1803				ahd_print_path(ahd, scb);
1804				printk("Set CAM_UNCOR_PARITY\n");
1805			}
1806#endif
1807			ahd_set_transaction_status(scb, CAM_UNCOR_PARITY);
1808#ifdef AHD_REPORT_UNDERFLOWS
1809		/*
1810		 * This code is disabled by default as some
1811		 * clients of the SCSI system do not properly
1812		 * initialize the underflow parameter.  This
1813		 * results in spurious termination of commands
1814		 * that complete as expected (e.g. underflow is
1815		 * allowed as command can return variable amounts
1816		 * of data.
1817		 */
1818		} else if (amount_xferred < scb->io_ctx->underflow) {
1819			u_int i;
1820
1821			ahd_print_path(ahd, scb);
1822			printk("CDB:");
1823			for (i = 0; i < scb->io_ctx->cmd_len; i++)
1824				printk(" 0x%x", scb->io_ctx->cmnd[i]);
1825			printk("\n");
1826			ahd_print_path(ahd, scb);
1827			printk("Saw underflow (%ld of %ld bytes). "
1828			       "Treated as error\n",
1829				ahd_get_residual(scb),
1830				ahd_get_transfer_length(scb));
1831			ahd_set_transaction_status(scb, CAM_DATA_RUN_ERR);
1832#endif
1833		} else {
1834			ahd_set_transaction_status(scb, CAM_REQ_CMP);
1835		}
1836	} else if (ahd_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {
1837		ahd_linux_handle_scsi_status(ahd, cmd->device, scb);
1838	}
1839
1840	if (dev->openings == 1
1841	 && ahd_get_transaction_status(scb) == CAM_REQ_CMP
1842	 && ahd_get_scsi_status(scb) != SCSI_STATUS_QUEUE_FULL)
1843		dev->tag_success_count++;
1844	/*
1845	 * Some devices deal with…

Large files files are truncated, but you can click here to view the full file