aha152x.c | searchcode

/drivers/scsi/aha152x.c

Large files files are truncated, but you can click here to view the full file
   1/* aha152x.c -- Adaptec AHA-152x driver
   2 * Author: Jürgen E. Fischer, fischer@norbit.de
   3 * Copyright 1993-2004 Jürgen E. Fischer
   4 *
   5 * This program is free software; you can redistribute it and/or modify it
   6 * under the terms of the GNU General Public License as published by the
   7 * Free Software Foundation; either version 2, or (at your option) any
   8 * later version.
   9 *
  10 * This program is distributed in the hope that it will be useful, but
  11 * WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 * General Public License for more details.
  14 *
  15 *
  16 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
  17 *
  18 * $Log: aha152x.c,v $
  19 * Revision 2.7  2004/01/24 11:42:59  fischer
  20 * - gather code that is not used by PCMCIA at the end
  21 * - move request_region for !PCMCIA case to detection
  22 * - migration to new scsi host api (remove legacy code)
  23 * - free host scribble before scsi_done
  24 * - fix error handling
  25 * - one isapnp device added to id_table
  26 *
  27 * Revision 2.6  2003/10/30 20:52:47  fischer
  28 * - interfaces changes for kernel 2.6
  29 * - aha152x_probe_one introduced for pcmcia stub
  30 * - fixed pnpdev handling
  31 * - instead of allocation a new one, reuse command for request sense after check condition and reset
  32 * - fixes race in is_complete
  33 *
  34 * Revision 2.5  2002/04/14 11:24:53  fischer
  35 * - isapnp support
  36 * - abort fixed
  37 * - 2.5 support
  38 *
  39 * Revision 2.4  2000/12/16 12:53:56  fischer
  40 * - allow REQUEST SENSE to be queued
  41 * - handle shared PCI interrupts
  42 *
  43 * Revision 2.3  2000/11/04 16:40:26  fischer
  44 * - handle data overruns
  45 * - extend timeout for data phases
  46 *
  47 * Revision 2.2  2000/08/08 19:54:53  fischer
  48 * - minor changes
  49 *
  50 * Revision 2.1  2000/05/17 16:23:17  fischer
  51 * - signature update
  52 * - fix for data out w/o scatter gather
  53 *
  54 * Revision 2.0  1999/12/25 15:07:32  fischer
  55 * - interrupt routine completly reworked
  56 * - basic support for new eh code
  57 *
  58 * Revision 1.21  1999/11/10 23:46:36  fischer
  59 * - default to synchronous operation
  60 * - synchronous negotiation fixed
  61 * - added timeout to loops
  62 * - debugging output can be controlled through procfs
  63 *
  64 * Revision 1.20  1999/11/07 18:37:31  fischer
  65 * - synchronous operation works
  66 * - resid support for sg driver
  67 *
  68 * Revision 1.19  1999/11/02 22:39:59  fischer
  69 * - moved leading comments to README.aha152x
  70 * - new additional module parameters
  71 * - updates for 2.3
  72 * - support for the Tripace TC1550 controller
  73 * - interrupt handling changed
  74 *
  75 * Revision 1.18  1996/09/07 20:10:40  fischer
  76 * - fixed can_queue handling (multiple outstanding commands working again)
  77 *
  78 * Revision 1.17  1996/08/17 16:05:14  fischer
  79 * - biosparam improved
  80 * - interrupt verification
  81 * - updated documentation
  82 * - cleanups
  83 *
  84 * Revision 1.16  1996/06/09 00:04:56  root
  85 * - added configuration symbols for insmod (aha152x/aha152x1)
  86 *
  87 * Revision 1.15  1996/04/30 14:52:06  fischer
  88 * - proc info fixed
  89 * - support for extended translation for >1GB disks
  90 *
  91 * Revision 1.14  1996/01/17  15:11:20  fischer
  92 * - fixed lockup in MESSAGE IN phase after reconnection
  93 *
  94 * Revision 1.13  1996/01/09  02:15:53  fischer
  95 * - some cleanups
  96 * - moved request_irq behind controller initialization
  97 *   (to avoid spurious interrupts)
  98 *
  99 * Revision 1.12  1995/12/16  12:26:07  fischer
 100 * - barrier()s added
 101 * - configurable RESET delay added
 102 *
 103 * Revision 1.11  1995/12/06  21:18:35  fischer
 104 * - some minor updates
 105 *
 106 * Revision 1.10  1995/07/22  19:18:45  fischer
 107 * - support for 2 controllers
 108 * - started synchronous data transfers (not working yet)
 109 *
 110 * Revision 1.9  1995/03/18  09:20:24  root
 111 * - patches for PCMCIA and modules
 112 *
 113 * Revision 1.8  1995/01/21  22:07:19  root
 114 * - snarf_region => request_region
 115 * - aha152x_intr interface change
 116 *
 117 * Revision 1.7  1995/01/02  23:19:36  root
 118 * - updated COMMAND_SIZE to cmd_len
 119 * - changed sti() to restore_flags()
 120 * - fixed some #ifdef which generated warnings
 121 *
 122 * Revision 1.6  1994/11/24  20:35:27  root
 123 * - problem with odd number of bytes in fifo fixed
 124 *
 125 * Revision 1.5  1994/10/30  14:39:56  root
 126 * - abort code fixed
 127 * - debugging improved
 128 *
 129 * Revision 1.4  1994/09/12  11:33:01  root
 130 * - irqaction to request_irq
 131 * - abortion updated
 132 *
 133 * Revision 1.3  1994/08/04  13:53:05  root
 134 * - updates for mid-level-driver changes
 135 * - accept unexpected BUSFREE phase as error condition
 136 * - parity check now configurable
 137 *
 138 * Revision 1.2  1994/07/03  12:56:36  root
 139 * - cleaned up debugging code
 140 * - more tweaking on reset delays
 141 * - updated abort/reset code (pretty untested...)
 142 *
 143 * Revision 1.1  1994/05/28  21:18:49  root
 144 * - update for mid-level interface change (abort-reset)
 145 * - delays after resets adjusted for some slow devices
 146 *
 147 * Revision 1.0  1994/03/25  12:52:00  root
 148 * - Fixed "more data than expected" problem
 149 * - added new BIOS signatures
 150 *
 151 * Revision 0.102  1994/01/31  20:44:12  root
 152 * - minor changes in insw/outsw handling
 153 *
 154 * Revision 0.101  1993/12/13  01:16:27  root
 155 * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
 156 *   fixes problems with CD-ROM sector size detection & media change)
 157 *
 158 * Revision 0.100  1993/12/10  16:58:47  root
 159 * - fix for unsuccessful selections in case of non-continuous id assignments
 160 *   on the scsi bus.
 161 *
 162 * Revision 0.99  1993/10/24  16:19:59  root
 163 * - fixed DATA IN (rare read errors gone)
 164 *
 165 * Revision 0.98  1993/10/17  12:54:44  root
 166 * - fixed some recent fixes (shame on me)
 167 * - moved initialization of scratch area to aha152x_queue
 168 *
 169 * Revision 0.97  1993/10/09  18:53:53  root
 170 * - DATA IN fixed. Rarely left data in the fifo.
 171 *
 172 * Revision 0.96  1993/10/03  00:53:59  root
 173 * - minor changes on DATA IN
 174 *
 175 * Revision 0.95  1993/09/24  10:36:01  root
 176 * - change handling of MSGI after reselection
 177 * - fixed sti/cli
 178 * - minor changes
 179 *
 180 * Revision 0.94  1993/09/18  14:08:22  root
 181 * - fixed bug in multiple outstanding command code
 182 * - changed detection
 183 * - support for kernel command line configuration
 184 * - reset corrected
 185 * - changed message handling
 186 *
 187 * Revision 0.93  1993/09/15  20:41:19  root
 188 * - fixed bugs with multiple outstanding commands
 189 *
 190 * Revision 0.92  1993/09/13  02:46:33  root
 191 * - multiple outstanding commands work (no problems with IBM drive)
 192 *
 193 * Revision 0.91  1993/09/12  20:51:46  root
 194 * added multiple outstanding commands
 195 * (some problem with this $%&? IBM device remain)
 196 *
 197 * Revision 0.9  1993/09/12  11:11:22  root
 198 * - corrected auto-configuration
 199 * - changed the auto-configuration (added some '#define's)
 200 * - added support for dis-/reconnection
 201 *
 202 * Revision 0.8  1993/09/06  23:09:39  root
 203 * - added support for the drive activity light
 204 * - minor changes
 205 *
 206 * Revision 0.7  1993/09/05  14:30:15  root
 207 * - improved phase detection
 208 * - now using the new snarf_region code of 0.99pl13
 209 *
 210 * Revision 0.6  1993/09/02  11:01:38  root
 211 * first public release; added some signatures and biosparam()
 212 *
 213 * Revision 0.5  1993/08/30  10:23:30  root
 214 * fixed timing problems with my IBM drive
 215 *
 216 * Revision 0.4  1993/08/29  14:06:52  root
 217 * fixed some problems with timeouts due incomplete commands
 218 *
 219 * Revision 0.3  1993/08/28  15:55:03  root
 220 * writing data works too.  mounted and worked on a dos partition
 221 *
 222 * Revision 0.2  1993/08/27  22:42:07  root
 223 * reading data works.  Mounted a msdos partition.
 224 *
 225 * Revision 0.1  1993/08/25  13:38:30  root
 226 * first "damn thing doesn't work" version
 227 *
 228 * Revision 0.0  1993/08/14  19:54:25  root
 229 * empty function bodies; detect() works.
 230 *
 231 *
 232 **************************************************************************
 233 
 234 see Documentation/scsi/aha152x.txt for configuration details
 235
 236 **************************************************************************/
 237
 238#include <linux/module.h>
 239#include <asm/irq.h>
 240#include <linux/io.h>
 241#include <linux/blkdev.h>
 242#include <asm/system.h>
 243#include <linux/completion.h>
 244#include <linux/errno.h>
 245#include <linux/string.h>
 246#include <linux/wait.h>
 247#include <linux/ioport.h>
 248#include <linux/delay.h>
 249#include <linux/proc_fs.h>
 250#include <linux/interrupt.h>
 251#include <linux/init.h>
 252#include <linux/kernel.h>
 253#include <linux/isapnp.h>
 254#include <linux/spinlock.h>
 255#include <linux/workqueue.h>
 256#include <linux/list.h>
 257#include <linux/slab.h>
 258#include <scsi/scsicam.h>
 259
 260#include "scsi.h"
 261#include <scsi/scsi_dbg.h>
 262#include <scsi/scsi_host.h>
 263#include <scsi/scsi_transport_spi.h>
 264#include <scsi/scsi_eh.h>
 265#include "aha152x.h"
 266
 267static LIST_HEAD(aha152x_host_list);
 268
 269
 270/* DEFINES */
 271
 272/* For PCMCIA cards, always use AUTOCONF */
 273#if defined(PCMCIA) || defined(MODULE)
 274#if !defined(AUTOCONF)
 275#define AUTOCONF
 276#endif
 277#endif
 278
 279#if !defined(AUTOCONF) && !defined(SETUP0)
 280#error define AUTOCONF or SETUP0
 281#endif
 282
 283#if defined(AHA152X_DEBUG)
 284#define DEBUG_DEFAULT debug_eh
 285
 286#define DPRINTK(when,msgs...) \
 287	do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
 288
 289#define DO_LOCK(flags)	\
 290	do { \
 291		if(spin_is_locked(&QLOCK)) { \
 292			DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
 293		} \
 294		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
 295		spin_lock_irqsave(&QLOCK,flags); \
 296		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
 297		QLOCKER=__func__; \
 298		QLOCKERL=__LINE__; \
 299	} while(0)
 300
 301#define DO_UNLOCK(flags)	\
 302	do { \
 303		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
 304		spin_unlock_irqrestore(&QLOCK,flags); \
 305		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
 306		QLOCKER="(not locked)"; \
 307		QLOCKERL=0; \
 308	} while(0)
 309
 310#else
 311#define DPRINTK(when,msgs...)
 312#define	DO_LOCK(flags)		spin_lock_irqsave(&QLOCK,flags)
 313#define	DO_UNLOCK(flags)	spin_unlock_irqrestore(&QLOCK,flags)
 314#endif
 315
 316#define LEAD		"(scsi%d:%d:%d) "
 317#define WARN_LEAD	KERN_WARNING	LEAD
 318#define INFO_LEAD	KERN_INFO	LEAD
 319#define NOTE_LEAD	KERN_NOTICE	LEAD
 320#define ERR_LEAD	KERN_ERR	LEAD
 321#define DEBUG_LEAD	KERN_DEBUG	LEAD
 322#define CMDINFO(cmd) \
 323			(cmd) ? ((cmd)->device->host->host_no) : -1, \
 324                        (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
 325			(cmd) ? ((cmd)->device->lun & 0x07) : -1
 326
 327static inline void
 328CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 329{
 330	scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
 331}
 332
 333#define DELAY_DEFAULT 1000
 334
 335#if defined(PCMCIA)
 336#define IRQ_MIN 0
 337#define IRQ_MAX 16
 338#else
 339#define IRQ_MIN 9
 340#if defined(__PPC)
 341#define IRQ_MAX (nr_irqs-1)
 342#else
 343#define IRQ_MAX 12
 344#endif
 345#endif
 346
 347enum {
 348	not_issued	= 0x0001,	/* command not yet issued */
 349	selecting	= 0x0002, 	/* target is beeing selected */
 350	identified	= 0x0004,	/* IDENTIFY was sent */
 351	disconnected	= 0x0008,	/* target disconnected */
 352	completed	= 0x0010,	/* target sent COMMAND COMPLETE */ 
 353	aborted		= 0x0020,	/* ABORT was sent */
 354	resetted	= 0x0040,	/* BUS DEVICE RESET was sent */
 355	spiordy		= 0x0080,	/* waiting for SPIORDY to raise */
 356	syncneg		= 0x0100,	/* synchronous negotiation in progress */
 357	aborting	= 0x0200,	/* ABORT is pending */
 358	resetting	= 0x0400,	/* BUS DEVICE RESET is pending */
 359	check_condition = 0x0800,	/* requesting sense after CHECK CONDITION */
 360};
 361
 362MODULE_AUTHOR("Jürgen Fischer");
 363MODULE_DESCRIPTION(AHA152X_REVID);
 364MODULE_LICENSE("GPL");
 365
 366#if !defined(PCMCIA)
 367#if defined(MODULE)
 368static int io[] = {0, 0};
 369module_param_array(io, int, NULL, 0);
 370MODULE_PARM_DESC(io,"base io address of controller");
 371
 372static int irq[] = {0, 0};
 373module_param_array(irq, int, NULL, 0);
 374MODULE_PARM_DESC(irq,"interrupt for controller");
 375
 376static int scsiid[] = {7, 7};
 377module_param_array(scsiid, int, NULL, 0);
 378MODULE_PARM_DESC(scsiid,"scsi id of controller");
 379
 380static int reconnect[] = {1, 1};
 381module_param_array(reconnect, int, NULL, 0);
 382MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
 383
 384static int parity[] = {1, 1};
 385module_param_array(parity, int, NULL, 0);
 386MODULE_PARM_DESC(parity,"use scsi parity");
 387
 388static int sync[] = {1, 1};
 389module_param_array(sync, int, NULL, 0);
 390MODULE_PARM_DESC(sync,"use synchronous transfers");
 391
 392static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
 393module_param_array(delay, int, NULL, 0);
 394MODULE_PARM_DESC(delay,"scsi reset delay");
 395
 396static int exttrans[] = {0, 0};
 397module_param_array(exttrans, int, NULL, 0);
 398MODULE_PARM_DESC(exttrans,"use extended translation");
 399
 400#if !defined(AHA152X_DEBUG)
 401static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 402module_param_array(aha152x, int, NULL, 0);
 403MODULE_PARM_DESC(aha152x, "parameters for first controller");
 404
 405static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 406module_param_array(aha152x1, int, NULL, 0);
 407MODULE_PARM_DESC(aha152x1, "parameters for second controller");
 408#else
 409static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
 410module_param_array(debug, int, NULL, 0);
 411MODULE_PARM_DESC(debug, "flags for driver debugging");
 412
 413static int aha152x[]   = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
 414module_param_array(aha152x, int, NULL, 0);
 415MODULE_PARM_DESC(aha152x, "parameters for first controller");
 416
 417static int aha152x1[]  = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
 418module_param_array(aha152x1, int, NULL, 0);
 419MODULE_PARM_DESC(aha152x1, "parameters for second controller");
 420#endif /* !defined(AHA152X_DEBUG) */
 421#endif /* MODULE */
 422
 423#ifdef __ISAPNP__
 424static struct isapnp_device_id id_table[] __devinitdata = {
 425	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
 426	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
 427	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
 428	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
 429	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
 430	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
 431	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
 432	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
 433	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
 434	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
 435	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
 436	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
 437	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,	ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
 438	{ ISAPNP_DEVICE_SINGLE_END, }
 439};
 440MODULE_DEVICE_TABLE(isapnp, id_table);
 441#endif /* ISAPNP */
 442
 443#endif /* !PCMCIA */
 444
 445static struct scsi_host_template aha152x_driver_template;
 446
 447/*
 448 * internal states of the host
 449 *
 450 */ 
 451enum aha152x_state {
 452	idle=0,
 453	unknown,
 454	seldo,
 455	seldi,
 456	selto,
 457	busfree,
 458	msgo,
 459	cmd,
 460	msgi,
 461	status,
 462	datai,
 463	datao,
 464	parerr,
 465	rsti,
 466	maxstate
 467};
 468
 469/*
 470 * current state information of the host
 471 *
 472 */
 473struct aha152x_hostdata {
 474	Scsi_Cmnd *issue_SC;
 475		/* pending commands to issue */
 476
 477	Scsi_Cmnd *current_SC;
 478		/* current command on the bus */
 479
 480	Scsi_Cmnd *disconnected_SC;
 481		/* commands that disconnected */
 482
 483	Scsi_Cmnd *done_SC;
 484		/* command that was completed */
 485
 486	spinlock_t lock;
 487		/* host lock */
 488
 489#if defined(AHA152X_DEBUG)
 490	const char *locker;
 491		/* which function has the lock */
 492	int lockerl;	/* where did it get it */
 493
 494	int debug;	/* current debugging setting */
 495#endif
 496
 497#if defined(AHA152X_STAT)
 498	int           total_commands;
 499	int	      disconnections;
 500	int	      busfree_without_any_action;
 501	int	      busfree_without_old_command;
 502	int	      busfree_without_new_command;
 503	int	      busfree_without_done_command;
 504	int	      busfree_with_check_condition;
 505	int           count[maxstate];
 506	int           count_trans[maxstate];
 507	unsigned long time[maxstate];
 508#endif
 509
 510	int commands;		/* current number of commands */
 511
 512	int reconnect;		/* disconnection allowed */
 513	int parity;		/* parity checking enabled */
 514	int synchronous;	/* synchronous transferes enabled */
 515	int delay;		/* reset out delay */
 516	int ext_trans;		/* extended translation enabled */
 517
 518	int swint; 		/* software-interrupt was fired during detect() */
 519	int service;		/* bh needs to be run */
 520	int in_intr;		/* bh is running */
 521
 522	/* current state,
 523	   previous state,
 524	   last state different from current state */
 525	enum aha152x_state state, prevstate, laststate;
 526
 527	int target;
 528		/* reconnecting target */
 529
 530	unsigned char syncrate[8];
 531		/* current synchronous transfer agreements */
 532
 533	unsigned char syncneg[8];
 534		/* 0: no negotiation;
 535		 * 1: negotiation in progress;
 536		 * 2: negotiation completed
 537		 */
 538
 539	int cmd_i;
 540		/* number of sent bytes of current command */
 541
 542	int msgi_len;
 543		/* number of received message bytes */
 544	unsigned char msgi[256];
 545		/* received message bytes */
 546
 547	int msgo_i, msgo_len;	
 548		/* number of sent bytes and length of current messages */
 549	unsigned char msgo[256];
 550		/* pending messages */
 551
 552	int data_len;
 553		/* number of sent/received bytes in dataphase */
 554
 555	unsigned long io_port0;
 556	unsigned long io_port1;
 557
 558#ifdef __ISAPNP__
 559	struct pnp_dev *pnpdev;
 560#endif
 561	struct list_head host_list;
 562};
 563
 564
 565/*
 566 * host specific command extension
 567 *
 568 */
 569struct aha152x_scdata {
 570	Scsi_Cmnd *next;	/* next sc in queue */
 571	struct completion *done;/* semaphore to block on */
 572	struct scsi_eh_save ses;
 573};
 574
 575/* access macros for hostdata */
 576
 577#define HOSTDATA(shpnt)		((struct aha152x_hostdata *) &shpnt->hostdata)
 578
 579#define HOSTNO			((shpnt)->host_no)
 580
 581#define CURRENT_SC		(HOSTDATA(shpnt)->current_SC)
 582#define DONE_SC			(HOSTDATA(shpnt)->done_SC)
 583#define ISSUE_SC		(HOSTDATA(shpnt)->issue_SC)
 584#define DISCONNECTED_SC		(HOSTDATA(shpnt)->disconnected_SC)
 585#define QLOCK			(HOSTDATA(shpnt)->lock)
 586#define QLOCKER			(HOSTDATA(shpnt)->locker)
 587#define QLOCKERL		(HOSTDATA(shpnt)->lockerl)
 588
 589#define STATE			(HOSTDATA(shpnt)->state)
 590#define PREVSTATE		(HOSTDATA(shpnt)->prevstate)
 591#define LASTSTATE		(HOSTDATA(shpnt)->laststate)
 592
 593#define RECONN_TARGET		(HOSTDATA(shpnt)->target)
 594
 595#define CMD_I			(HOSTDATA(shpnt)->cmd_i)
 596
 597#define MSGO(i)			(HOSTDATA(shpnt)->msgo[i])
 598#define MSGO_I			(HOSTDATA(shpnt)->msgo_i)
 599#define MSGOLEN			(HOSTDATA(shpnt)->msgo_len)
 600#define ADDMSGO(x)		(MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
 601
 602#define MSGI(i)			(HOSTDATA(shpnt)->msgi[i])
 603#define MSGILEN			(HOSTDATA(shpnt)->msgi_len)
 604#define ADDMSGI(x)		(MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
 605
 606#define DATA_LEN		(HOSTDATA(shpnt)->data_len)
 607
 608#define SYNCRATE		(HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
 609#define SYNCNEG			(HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
 610
 611#define DELAY			(HOSTDATA(shpnt)->delay)
 612#define EXT_TRANS		(HOSTDATA(shpnt)->ext_trans)
 613#define TC1550			(HOSTDATA(shpnt)->tc1550)
 614#define RECONNECT		(HOSTDATA(shpnt)->reconnect)
 615#define PARITY			(HOSTDATA(shpnt)->parity)
 616#define SYNCHRONOUS		(HOSTDATA(shpnt)->synchronous)
 617
 618#define HOSTIOPORT0		(HOSTDATA(shpnt)->io_port0)
 619#define HOSTIOPORT1		(HOSTDATA(shpnt)->io_port1)
 620
 621#define SCDATA(SCpnt)		((struct aha152x_scdata *) (SCpnt)->host_scribble)
 622#define SCNEXT(SCpnt)		SCDATA(SCpnt)->next
 623#define SCSEM(SCpnt)		SCDATA(SCpnt)->done
 624
 625#define SG_ADDRESS(buffer)	((char *) sg_virt((buffer)))
 626
 627/* state handling */
 628static void seldi_run(struct Scsi_Host *shpnt);
 629static void seldo_run(struct Scsi_Host *shpnt);
 630static void selto_run(struct Scsi_Host *shpnt);
 631static void busfree_run(struct Scsi_Host *shpnt);
 632
 633static void msgo_init(struct Scsi_Host *shpnt);
 634static void msgo_run(struct Scsi_Host *shpnt);
 635static void msgo_end(struct Scsi_Host *shpnt);
 636
 637static void cmd_init(struct Scsi_Host *shpnt);
 638static void cmd_run(struct Scsi_Host *shpnt);
 639static void cmd_end(struct Scsi_Host *shpnt);
 640
 641static void datai_init(struct Scsi_Host *shpnt);
 642static void datai_run(struct Scsi_Host *shpnt);
 643static void datai_end(struct Scsi_Host *shpnt);
 644
 645static void datao_init(struct Scsi_Host *shpnt);
 646static void datao_run(struct Scsi_Host *shpnt);
 647static void datao_end(struct Scsi_Host *shpnt);
 648
 649static void status_run(struct Scsi_Host *shpnt);
 650
 651static void msgi_run(struct Scsi_Host *shpnt);
 652static void msgi_end(struct Scsi_Host *shpnt);
 653
 654static void parerr_run(struct Scsi_Host *shpnt);
 655static void rsti_run(struct Scsi_Host *shpnt);
 656
 657static void is_complete(struct Scsi_Host *shpnt);
 658
 659/*
 660 * driver states
 661 *
 662 */
 663static struct {
 664	char		*name;
 665	void		(*init)(struct Scsi_Host *);
 666	void		(*run)(struct Scsi_Host *);
 667	void		(*end)(struct Scsi_Host *);
 668	int		spio;
 669} states[] = {
 670	{ "idle",	NULL,		NULL,		NULL,		0},
 671	{ "unknown",	NULL,		NULL,		NULL,		0},
 672	{ "seldo",	NULL,		seldo_run,	NULL,		0},
 673	{ "seldi",	NULL,		seldi_run,	NULL,		0},
 674	{ "selto",	NULL,		selto_run,	NULL,		0},
 675	{ "busfree",	NULL,		busfree_run,	NULL,		0},
 676	{ "msgo",	msgo_init,	msgo_run,	msgo_end,	1},
 677	{ "cmd",	cmd_init,	cmd_run,	cmd_end,	1},
 678	{ "msgi",	NULL,		msgi_run,	msgi_end,	1},
 679	{ "status",	NULL,		status_run,	NULL,		1},
 680	{ "datai",	datai_init,	datai_run,	datai_end,	0},
 681	{ "datao",	datao_init,	datao_run,	datao_end,	0},
 682	{ "parerr",	NULL,		parerr_run,	NULL,		0},
 683	{ "rsti",	NULL,		rsti_run,	NULL,		0},
 684};
 685
 686/* setup & interrupt */
 687static irqreturn_t intr(int irq, void *dev_id);
 688static void reset_ports(struct Scsi_Host *shpnt);
 689static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
 690static void done(struct Scsi_Host *shpnt, int error);
 691
 692/* diagnostics */
 693static void disp_ports(struct Scsi_Host *shpnt);
 694static void show_command(Scsi_Cmnd * ptr);
 695static void show_queues(struct Scsi_Host *shpnt);
 696static void disp_enintr(struct Scsi_Host *shpnt);
 697
 698
 699/*
 700 *  queue services:
 701 *
 702 */
 703static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
 704{
 705	Scsi_Cmnd *end;
 706
 707	SCNEXT(new_SC) = NULL;
 708	if (!*SC)
 709		*SC = new_SC;
 710	else {
 711		for (end = *SC; SCNEXT(end); end = SCNEXT(end))
 712			;
 713		SCNEXT(end) = new_SC;
 714	}
 715}
 716
 717static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
 718{
 719	Scsi_Cmnd *ptr;
 720
 721	ptr = *SC;
 722	if (ptr) {
 723		*SC = SCNEXT(*SC);
 724		SCNEXT(ptr)=NULL;
 725	}
 726	return ptr;
 727}
 728
 729static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
 730{
 731	Scsi_Cmnd *ptr, *prev;
 732
 733	for (ptr = *SC, prev = NULL;
 734	     ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
 735	     prev = ptr, ptr = SCNEXT(ptr))
 736	     ;
 737
 738	if (ptr) {
 739		if (prev)
 740			SCNEXT(prev) = SCNEXT(ptr);
 741		else
 742			*SC = SCNEXT(ptr);
 743
 744		SCNEXT(ptr)=NULL;
 745	}
 746
 747	return ptr;
 748}
 749
 750static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
 751{
 752	Scsi_Cmnd *ptr, *prev;
 753
 754	for (ptr = *SC, prev = NULL;
 755	     ptr && SCp!=ptr;
 756	     prev = ptr, ptr = SCNEXT(ptr))
 757	     ;
 758
 759	if (ptr) {
 760		if (prev)
 761			SCNEXT(prev) = SCNEXT(ptr);
 762		else
 763			*SC = SCNEXT(ptr);
 764
 765		SCNEXT(ptr)=NULL;
 766	}
 767
 768	return ptr;
 769}
 770
 771static irqreturn_t swintr(int irqno, void *dev_id)
 772{
 773	struct Scsi_Host *shpnt = dev_id;
 774
 775	HOSTDATA(shpnt)->swint++;
 776
 777	SETPORT(DMACNTRL0, INTEN);
 778	return IRQ_HANDLED;
 779}
 780
 781struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
 782{
 783	struct Scsi_Host *shpnt;
 784
 785	shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
 786	if (!shpnt) {
 787		printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
 788		return NULL;
 789	}
 790
 791	memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
 792	INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
 793
 794	/* need to have host registered before triggering any interrupt */
 795	list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
 796
 797	shpnt->io_port   = setup->io_port;
 798	shpnt->n_io_port = IO_RANGE;
 799	shpnt->irq       = setup->irq;
 800
 801	if (!setup->tc1550) {
 802		HOSTIOPORT0 = setup->io_port;
 803		HOSTIOPORT1 = setup->io_port;
 804	} else {
 805		HOSTIOPORT0 = setup->io_port+0x10;
 806		HOSTIOPORT1 = setup->io_port-0x10;
 807	}
 808
 809	spin_lock_init(&QLOCK);
 810	RECONNECT   = setup->reconnect;
 811	SYNCHRONOUS = setup->synchronous;
 812	PARITY      = setup->parity;
 813	DELAY       = setup->delay;
 814	EXT_TRANS   = setup->ext_trans;
 815
 816#if defined(AHA152X_DEBUG)
 817	HOSTDATA(shpnt)->debug = setup->debug;
 818#endif
 819
 820	SETPORT(SCSIID, setup->scsiid << 4);
 821	shpnt->this_id = setup->scsiid;
 822
 823	if (setup->reconnect)
 824		shpnt->can_queue = AHA152X_MAXQUEUE;
 825
 826	/* RESET OUT */
 827	printk("aha152x: resetting bus...\n");
 828	SETPORT(SCSISEQ, SCSIRSTO);
 829	mdelay(256);
 830	SETPORT(SCSISEQ, 0);
 831	mdelay(DELAY);
 832
 833	reset_ports(shpnt);
 834
 835	printk(KERN_INFO
 836	       "aha152x%d%s: "
 837	       "vital data: rev=%x, "
 838	       "io=0x%03lx (0x%03lx/0x%03lx), "
 839	       "irq=%d, "
 840	       "scsiid=%d, "
 841	       "reconnect=%s, "
 842	       "parity=%s, "
 843	       "synchronous=%s, "
 844	       "delay=%d, "
 845	       "extended translation=%s\n",
 846	       shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
 847	       GETPORT(REV) & 0x7,
 848	       shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
 849	       shpnt->irq,
 850	       shpnt->this_id,
 851	       RECONNECT ? "enabled" : "disabled",
 852	       PARITY ? "enabled" : "disabled",
 853	       SYNCHRONOUS ? "enabled" : "disabled",
 854	       DELAY,
 855	       EXT_TRANS ? "enabled" : "disabled");
 856
 857	/* not expecting any interrupts */
 858	SETPORT(SIMODE0, 0);
 859	SETPORT(SIMODE1, 0);
 860
 861	if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
 862		printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
 863		goto out_host_put;
 864	}
 865
 866	HOSTDATA(shpnt)->swint = 0;
 867
 868	printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
 869
 870	mb();
 871	SETPORT(DMACNTRL0, SWINT|INTEN);
 872	mdelay(1000);
 873	free_irq(shpnt->irq, shpnt);
 874
 875	if (!HOSTDATA(shpnt)->swint) {
 876		if (TESTHI(DMASTAT, INTSTAT)) {
 877			printk("lost.\n");
 878		} else {
 879			printk("failed.\n");
 880		}
 881
 882		SETPORT(DMACNTRL0, INTEN);
 883
 884		printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
 885				"Please verify.\n", shpnt->host_no, shpnt->irq);
 886		goto out_host_put;
 887	}
 888	printk("ok.\n");
 889
 890
 891	/* clear interrupts */
 892	SETPORT(SSTAT0, 0x7f);
 893	SETPORT(SSTAT1, 0xef);
 894
 895	if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
 896		printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
 897		goto out_host_put;
 898	}
 899
 900	if( scsi_add_host(shpnt, NULL) ) {
 901		free_irq(shpnt->irq, shpnt);
 902		printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
 903		goto out_host_put;
 904	}
 905
 906	scsi_scan_host(shpnt);
 907
 908	return shpnt;
 909
 910out_host_put:
 911	list_del(&HOSTDATA(shpnt)->host_list);
 912	scsi_host_put(shpnt);
 913
 914	return NULL;
 915}
 916
 917void aha152x_release(struct Scsi_Host *shpnt)
 918{
 919	if (!shpnt)
 920		return;
 921
 922	scsi_remove_host(shpnt);
 923	if (shpnt->irq)
 924		free_irq(shpnt->irq, shpnt);
 925
 926#if !defined(PCMCIA)
 927	if (shpnt->io_port)
 928		release_region(shpnt->io_port, IO_RANGE);
 929#endif
 930
 931#ifdef __ISAPNP__
 932	if (HOSTDATA(shpnt)->pnpdev)
 933		pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
 934#endif
 935
 936	list_del(&HOSTDATA(shpnt)->host_list);
 937	scsi_host_put(shpnt);
 938}
 939
 940
 941/*
 942 * setup controller to generate interrupts depending
 943 * on current state (lock has to be acquired)
 944 *
 945 */ 
 946static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 947{
 948	if(CURRENT_SC) {
 949		CURRENT_SC->SCp.phase |= 1 << 16;
 950	
 951		if(CURRENT_SC->SCp.phase & selecting) {
 952			DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
 953			SETPORT(SSTAT1, SELTO);
 954			SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
 955			SETPORT(SIMODE1, ENSELTIMO);
 956		} else {
 957			DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
 958			SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
 959			SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
 960		}
 961	} else if(STATE==seldi) {
 962		DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
 963		SETPORT(SIMODE0, 0);
 964		SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
 965	} else {
 966		DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
 967			CMDINFO(CURRENT_SC),
 968			DISCONNECTED_SC ? "(reselection)" : "",
 969			ISSUE_SC ? "(busfree)" : "");
 970		SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
 971		SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
 972	}
 973
 974	if(!HOSTDATA(shpnt)->in_intr)
 975		SETBITS(DMACNTRL0, INTEN);
 976
 977	return TESTHI(DMASTAT, INTSTAT);
 978}
 979
 980
 981/* 
 982 *  Queue a command and setup interrupts for a free bus.
 983 */
 984static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
 985		int phase, void (*done)(Scsi_Cmnd *))
 986{
 987	struct Scsi_Host *shpnt = SCpnt->device->host;
 988	unsigned long flags;
 989
 990#if defined(AHA152X_DEBUG)
 991	if (HOSTDATA(shpnt)->debug & debug_queue) {
 992		printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
 993		       CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
 994		       scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
 995		__scsi_print_command(SCpnt->cmnd);
 996	}
 997#endif
 998
 999	SCpnt->scsi_done	= done;
1000	SCpnt->SCp.phase	= not_issued | phase;
1001	SCpnt->SCp.Status	= 0x1; /* Ilegal status by SCSI standard */
1002	SCpnt->SCp.Message	= 0;
1003	SCpnt->SCp.have_data_in	= 0;
1004	SCpnt->SCp.sent_command	= 0;
1005
1006	if(SCpnt->SCp.phase & (resetting|check_condition)) {
1007		if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1008			printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1009			return FAILED;
1010		}
1011	} else {
1012		SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1013		if(!SCpnt->host_scribble) {
1014			printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1015			return FAILED;
1016		}
1017	}
1018
1019	SCNEXT(SCpnt)		= NULL;
1020	SCSEM(SCpnt)		= complete;
1021
1022	/* setup scratch area
1023	   SCp.ptr              : buffer pointer
1024	   SCp.this_residual    : buffer length
1025	   SCp.buffer           : next buffer
1026	   SCp.buffers_residual : left buffers in list
1027	   SCp.phase            : current state of the command */
1028
1029	if ((phase & resetting) || !scsi_sglist(SCpnt)) {
1030		SCpnt->SCp.ptr           = NULL;
1031		SCpnt->SCp.this_residual = 0;
1032		scsi_set_resid(SCpnt, 0);
1033		SCpnt->SCp.buffer           = NULL;
1034		SCpnt->SCp.buffers_residual = 0;
1035	} else {
1036		scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1037		SCpnt->SCp.buffer           = scsi_sglist(SCpnt);
1038		SCpnt->SCp.ptr              = SG_ADDRESS(SCpnt->SCp.buffer);
1039		SCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
1040		SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1041	}
1042
1043	DO_LOCK(flags);
1044
1045#if defined(AHA152X_STAT)
1046	HOSTDATA(shpnt)->total_commands++;
1047#endif
1048
1049	/* Turn led on, when this is the first command. */
1050	HOSTDATA(shpnt)->commands++;
1051	if (HOSTDATA(shpnt)->commands==1)
1052		SETPORT(PORTA, 1);
1053
1054	append_SC(&ISSUE_SC, SCpnt);
1055
1056	if(!HOSTDATA(shpnt)->in_intr)
1057		setup_expected_interrupts(shpnt);
1058
1059	DO_UNLOCK(flags);
1060
1061	return 0;
1062}
1063
1064/*
1065 *  queue a command
1066 *
1067 */
1068static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1069{
1070#if 0
1071	if(*SCpnt->cmnd == REQUEST_SENSE) {
1072		SCpnt->result = 0;
1073		done(SCpnt);
1074
1075		return 0;
1076	}
1077#endif
1078
1079	return aha152x_internal_queue(SCpnt, NULL, 0, done);
1080}
1081
1082static DEF_SCSI_QCMD(aha152x_queue)
1083
1084
1085/*
1086 *  
1087 *
1088 */
1089static void reset_done(Scsi_Cmnd *SCpnt)
1090{
1091#if 0
1092	struct Scsi_Host *shpnt = SCpnt->host;
1093	DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1094#endif
1095	if(SCSEM(SCpnt)) {
1096		complete(SCSEM(SCpnt));
1097	} else {
1098		printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1099	}
1100}
1101
1102/*
1103 *  Abort a command
1104 *
1105 */
1106static int aha152x_abort(Scsi_Cmnd *SCpnt)
1107{
1108	struct Scsi_Host *shpnt = SCpnt->device->host;
1109	Scsi_Cmnd *ptr;
1110	unsigned long flags;
1111
1112#if defined(AHA152X_DEBUG)
1113	if(HOSTDATA(shpnt)->debug & debug_eh) {
1114		printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1115		show_queues(shpnt);
1116	}
1117#endif
1118
1119	DO_LOCK(flags);
1120
1121	ptr=remove_SC(&ISSUE_SC, SCpnt);
1122
1123	if(ptr) {
1124		DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1125
1126		HOSTDATA(shpnt)->commands--;
1127		if (!HOSTDATA(shpnt)->commands)
1128			SETPORT(PORTA, 0);
1129		DO_UNLOCK(flags);
1130
1131		kfree(SCpnt->host_scribble);
1132		SCpnt->host_scribble=NULL;
1133
1134		return SUCCESS;
1135	} 
1136
1137	DO_UNLOCK(flags);
1138
1139	/*
1140	 * FIXME:
1141	 * for current command: queue ABORT for message out and raise ATN
1142	 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1143	 *
1144	 */
1145
1146	printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1147
1148	return FAILED;
1149}
1150
1151/*
1152 * Reset a device
1153 *
1154 */
1155static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1156{
1157	struct Scsi_Host *shpnt = SCpnt->device->host;
1158	DECLARE_COMPLETION(done);
1159	int ret, issued, disconnected;
1160	unsigned char old_cmd_len = SCpnt->cmd_len;
1161	unsigned long flags;
1162	unsigned long timeleft;
1163
1164#if defined(AHA152X_DEBUG)
1165	if(HOSTDATA(shpnt)->debug & debug_eh) {
1166		printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1167		show_queues(shpnt);
1168	}
1169#endif
1170
1171	if(CURRENT_SC==SCpnt) {
1172		printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1173		return FAILED;
1174	}
1175
1176	DO_LOCK(flags);
1177	issued       = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1178	disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1179	DO_UNLOCK(flags);
1180
1181	SCpnt->cmd_len         = 0;
1182
1183	aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1184
1185	timeleft = wait_for_completion_timeout(&done, 100*HZ);
1186	if (!timeleft) {
1187		/* remove command from issue queue */
1188		DO_LOCK(flags);
1189		remove_SC(&ISSUE_SC, SCpnt);
1190		DO_UNLOCK(flags);
1191	}
1192
1193	SCpnt->cmd_len         = old_cmd_len;
1194
1195	DO_LOCK(flags);
1196
1197	if(SCpnt->SCp.phase & resetted) {
1198		HOSTDATA(shpnt)->commands--;
1199		if (!HOSTDATA(shpnt)->commands)
1200			SETPORT(PORTA, 0);
1201		kfree(SCpnt->host_scribble);
1202		SCpnt->host_scribble=NULL;
1203
1204		ret = SUCCESS;
1205	} else {
1206		/* requeue */
1207		if(!issued) {
1208			append_SC(&ISSUE_SC, SCpnt);
1209		} else if(disconnected) {
1210			append_SC(&DISCONNECTED_SC, SCpnt);
1211		}
1212	
1213		ret = FAILED;
1214	}
1215
1216	DO_UNLOCK(flags);
1217	return ret;
1218}
1219
1220static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1221{
1222	Scsi_Cmnd *ptr;
1223
1224	ptr=*SCs;
1225	while(ptr) {
1226		Scsi_Cmnd *next;
1227
1228		if(SCDATA(ptr)) {
1229			next = SCNEXT(ptr);
1230		} else {
1231			printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1232			next = NULL;
1233		}
1234
1235		if (!ptr->device->soft_reset) {
1236			DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1237			remove_SC(SCs, ptr);
1238			HOSTDATA(shpnt)->commands--;
1239			kfree(ptr->host_scribble);
1240			ptr->host_scribble=NULL;
1241		}
1242
1243		ptr = next;
1244	}
1245}
1246
1247/*
1248 * Reset the bus
1249 *
1250 */
1251static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1252{
1253	unsigned long flags;
1254
1255	DO_LOCK(flags);
1256
1257#if defined(AHA152X_DEBUG)
1258	if(HOSTDATA(shpnt)->debug & debug_eh) {
1259		printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1260		show_queues(shpnt);
1261	}
1262#endif
1263
1264	free_hard_reset_SCs(shpnt, &ISSUE_SC);
1265	free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1266
1267	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1268
1269	SETPORT(SCSISEQ, SCSIRSTO);
1270	mdelay(256);
1271	SETPORT(SCSISEQ, 0);
1272	mdelay(DELAY);
1273
1274	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1275
1276	setup_expected_interrupts(shpnt);
1277	if(HOSTDATA(shpnt)->commands==0)
1278		SETPORT(PORTA, 0);
1279
1280	DO_UNLOCK(flags);
1281
1282	return SUCCESS;
1283}
1284
1285/*
1286 * Reset the bus
1287 *
1288 */
1289static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1290{
1291	return aha152x_bus_reset_host(SCpnt->device->host);
1292}
1293
1294/*
1295 *  Restore default values to the AIC-6260 registers and reset the fifos
1296 *
1297 */
1298static void reset_ports(struct Scsi_Host *shpnt)
1299{
1300	unsigned long flags;
1301
1302	/* disable interrupts */
1303	SETPORT(DMACNTRL0, RSTFIFO);
1304
1305	SETPORT(SCSISEQ, 0);
1306
1307	SETPORT(SXFRCTL1, 0);
1308	SETPORT(SCSISIG, 0);
1309	SETRATE(0);
1310
1311	/* clear all interrupt conditions */
1312	SETPORT(SSTAT0, 0x7f);
1313	SETPORT(SSTAT1, 0xef);
1314
1315	SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1316
1317	SETPORT(DMACNTRL0, 0);
1318	SETPORT(DMACNTRL1, 0);
1319
1320	SETPORT(BRSTCNTRL, 0xf1);
1321
1322	/* clear SCSI fifos and transfer count */
1323	SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1324	SETPORT(SXFRCTL0, CH1);
1325
1326	DO_LOCK(flags);
1327	setup_expected_interrupts(shpnt);
1328	DO_UNLOCK(flags);
1329}
1330
1331/*
1332 * Reset the host (bus and controller)
1333 *
1334 */
1335int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1336{
1337	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1338
1339	aha152x_bus_reset_host(shpnt);
1340
1341	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1342	reset_ports(shpnt);
1343
1344	return SUCCESS;
1345}
1346
1347/*
1348 * Reset the host (bus and controller)
1349 * 
1350 */
1351static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1352{
1353	return aha152x_host_reset_host(SCpnt->device->host);
1354}
1355
1356/*
1357 * Return the "logical geometry"
1358 *
1359 */
1360static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1361		sector_t capacity, int *info_array)
1362{
1363	struct Scsi_Host *shpnt = sdev->host;
1364
1365	/* try default translation */
1366	info_array[0] = 64;
1367	info_array[1] = 32;
1368	info_array[2] = (unsigned long)capacity / (64 * 32);
1369
1370	/* for disks >1GB do some guessing */
1371	if (info_array[2] >= 1024) {
1372		int info[3];
1373
1374		/* try to figure out the geometry from the partition table */
1375		if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1376		    !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1377			if (EXT_TRANS) {
1378				printk(KERN_NOTICE
1379				       "aha152x: unable to verify geometry for disk with >1GB.\n"
1380				       "         using extended translation.\n");
1381				info_array[0] = 255;
1382				info_array[1] = 63;
1383				info_array[2] = (unsigned long)capacity / (255 * 63);
1384			} else {
1385				printk(KERN_NOTICE
1386				       "aha152x: unable to verify geometry for disk with >1GB.\n"
1387				       "         Using default translation. Please verify yourself.\n"
1388				       "         Perhaps you need to enable extended translation in the driver.\n"
1389				       "         See Documentation/scsi/aha152x.txt for details.\n");
1390			}
1391		} else {
1392			info_array[0] = info[0];
1393			info_array[1] = info[1];
1394			info_array[2] = info[2];
1395
1396			if (info[0] == 255 && !EXT_TRANS) {
1397				printk(KERN_NOTICE
1398				       "aha152x: current partition table is using extended translation.\n"
1399				       "         using it also, although it's not explicitly enabled.\n");
1400			}
1401		}
1402	}
1403
1404	return 0;
1405}
1406
1407/*
1408 *  Internal done function
1409 *
1410 */
1411static void done(struct Scsi_Host *shpnt, int error)
1412{
1413	if (CURRENT_SC) {
1414		if(DONE_SC)
1415			printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1416
1417		DONE_SC = CURRENT_SC;
1418		CURRENT_SC = NULL;
1419		DONE_SC->result = error;
1420	} else
1421		printk(KERN_ERR "aha152x: done() called outside of command\n");
1422}
1423
1424static struct work_struct aha152x_tq;
1425
1426/*
1427 * Run service completions on the card with interrupts enabled.
1428 *
1429 */
1430static void run(struct work_struct *work)
1431{
1432	struct aha152x_hostdata *hd;
1433
1434	list_for_each_entry(hd, &aha152x_host_list, host_list) {
1435		struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1436
1437		is_complete(shost);
1438	}
1439}
1440
1441/*
1442 * Interrupt handler
1443 *
1444 */
1445static irqreturn_t intr(int irqno, void *dev_id)
1446{
1447	struct Scsi_Host *shpnt = dev_id;
1448	unsigned long flags;
1449	unsigned char rev, dmacntrl0;
1450
1451	/*
1452	 * Read a couple of registers that are known to not be all 1's. If
1453	 * we read all 1's (-1), that means that either:
1454	 *
1455	 * a. The host adapter chip has gone bad, and we cannot control it,
1456	 *	OR
1457	 * b. The host adapter is a PCMCIA card that has been ejected
1458	 *
1459	 * In either case, we cannot do anything with the host adapter at
1460	 * this point in time. So just ignore the interrupt and return.
1461	 * In the latter case, the interrupt might actually be meant for
1462	 * someone else sharing this IRQ, and that driver will handle it.
1463	 */
1464	rev = GETPORT(REV);
1465	dmacntrl0 = GETPORT(DMACNTRL0);
1466	if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1467		return IRQ_NONE;
1468
1469	if( TESTLO(DMASTAT, INTSTAT) )
1470		return IRQ_NONE;	
1471
1472	/* no more interrupts from the controller, while we're busy.
1473	   INTEN is restored by the BH handler */
1474	CLRBITS(DMACNTRL0, INTEN);
1475
1476	DO_LOCK(flags);
1477	if( HOSTDATA(shpnt)->service==0 ) {
1478		HOSTDATA(shpnt)->service=1;
1479
1480		/* Poke the BH handler */
1481		INIT_WORK(&aha152x_tq, run);
1482		schedule_work(&aha152x_tq);
1483	}
1484	DO_UNLOCK(flags);
1485
1486	return IRQ_HANDLED;
1487}
1488
1489/*
1490 * busfree phase
1491 * - handle completition/disconnection/error of current command
1492 * - start selection for next command (if any)
1493 */
1494static void busfree_run(struct Scsi_Host *shpnt)
1495{
1496	unsigned long flags;
1497#if defined(AHA152X_STAT)
1498	int action=0;
1499#endif
1500
1501	SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1502	SETPORT(SXFRCTL0, CH1);
1503
1504	SETPORT(SSTAT1, CLRBUSFREE);
1505	
1506	if(CURRENT_SC) {
1507#if defined(AHA152X_STAT)
1508		action++;
1509#endif
1510		CURRENT_SC->SCp.phase &= ~syncneg;
1511
1512		if(CURRENT_SC->SCp.phase & completed) {
1513			/* target sent COMMAND COMPLETE */
1514			done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1515
1516		} else if(CURRENT_SC->SCp.phase & aborted) {
1517			DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1518			done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1519
1520		} else if(CURRENT_SC->SCp.phase & resetted) {
1521			DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1522			done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1523
1524		} else if(CURRENT_SC->SCp.phase & disconnected) {
1525			/* target sent DISCONNECT */
1526			DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1527				CMDINFO(CURRENT_SC),
1528				scsi_get_resid(CURRENT_SC),
1529				scsi_bufflen(CURRENT_SC));
1530#if defined(AHA152X_STAT)
1531			HOSTDATA(shpnt)->disconnections++;
1532#endif
1533			append_SC(&DISCONNECTED_SC, CURRENT_SC);
1534			CURRENT_SC->SCp.phase |= 1 << 16;
1535			CURRENT_SC = NULL;
1536
1537		} else {
1538			done(shpnt, DID_ERROR << 16);
1539		}
1540#if defined(AHA152X_STAT)
1541	} else {
1542		HOSTDATA(shpnt)->busfree_without_old_command++;
1543#endif
1544	}
1545
1546	DO_LOCK(flags);
1547
1548	if(DONE_SC) {
1549#if defined(AHA152X_STAT)
1550		action++;
1551#endif
1552
1553		if(DONE_SC->SCp.phase & check_condition) {
1554			struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1555			struct aha152x_scdata *sc = SCDATA(cmd);
1556
1557#if 0
1558			if(HOSTDATA(shpnt)->debug & debug_eh) {
1559				printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1560				scsi_print_sense("bh", DONE_SC);
1561			}
1562#endif
1563
1564			scsi_eh_restore_cmnd(cmd, &sc->ses);
1565
1566			cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1567
1568			HOSTDATA(shpnt)->commands--;
1569			if (!HOSTDATA(shpnt)->commands)
1570				SETPORT(PORTA, 0);	/* turn led off */
1571		} else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1572#if defined(AHA152X_STAT)
1573			HOSTDATA(shpnt)->busfree_with_check_condition++;
1574#endif
1575#if 0
1576			DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1577#endif
1578
1579			if(!(DONE_SC->SCp.phase & not_issued)) {
1580				struct aha152x_scdata *sc;
1581				Scsi_Cmnd *ptr = DONE_SC;
1582				DONE_SC=NULL;
1583#if 0
1584				DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1585#endif
1586
1587				sc = SCDATA(ptr);
1588				/* It was allocated in aha152x_internal_queue? */
1589				BUG_ON(!sc);
1590				scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1591
1592				DO_UNLOCK(flags);
1593				aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1594				DO_LOCK(flags);
1595#if 0
1596			} else {
1597				DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1598#endif
1599			}
1600		}
1601
1602		if(DONE_SC && DONE_SC->scsi_done) {
1603#if defined(AHA152X_DEBUG)
1604			int hostno=DONE_SC->device->host->host_no;
1605			int id=DONE_SC->device->id & 0xf;
1606			int lun=DONE_SC->device->lun & 0x7;
1607#endif
1608			Scsi_Cmnd *ptr = DONE_SC;
1609			DONE_SC=NULL;
1610
1611			/* turn led off, when no commands are in the driver */
1612			HOSTDATA(shpnt)->commands--;
1613			if (!HOSTDATA(shpnt)->commands)
1614				SETPORT(PORTA, 0);	/* turn led off */
1615
1616			if(ptr->scsi_done != reset_done) {
1617				kfree(ptr->host_scribble);
1618				ptr->host_scribble=NULL;
1619			}
1620
1621			DO_UNLOCK(flags);
1622			DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1623                	ptr->scsi_done(ptr);
1624			DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1625			DO_LOCK(flags);
1626		}
1627
1628		DONE_SC=NULL;
1629#if defined(AHA152X_STAT)
1630	} else {
1631		HOSTDATA(shpnt)->busfree_without_done_command++;
1632#endif
1633	}
1634
1635	if(ISSUE_SC)
1636		CURRENT_SC = remove_first_SC(&ISSUE_SC);
1637
1638	DO_UNLOCK(flags);
1639
1640	if(CURRENT_SC) {
1641#if defined(AHA152X_STAT)
1642		action++;
1643#endif
1644	    	CURRENT_SC->SCp.phase |= selecting;
1645
1646		DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1647
1648		/* clear selection timeout */
1649		SETPORT(SSTAT1, SELTO);
1650
1651		SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1652		SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1653		SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1654	} else {
1655#if defined(AHA152X_STAT)
1656		HOSTDATA(shpnt)->busfree_without_new_command++;
1657#endif
1658		SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1659	}
1660
1661#if defined(AHA152X_STAT)
1662	if(!action)
1663		HOSTDATA(shpnt)->busfree_without_any_action++;
1664#endif
1665}
1666
1667/*
1668 * Selection done (OUT)
1669 * - queue IDENTIFY message and SDTR to selected target for message out
1670 *   (ATN asserted automagically via ENAUTOATNO in busfree())
1671 */
1672static void seldo_run(struct Scsi_Host *shpnt)
1673{
1674	SETPORT(SCSISIG, 0);
1675	SETPORT(SSTAT1, CLRBUSFREE);
1676	SETPORT(SSTAT1, CLRPHASECHG);
1677
1678    	CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1679
1680	SETPORT(SCSISEQ, 0);
1681
1682	if (TESTLO(SSTAT0, SELDO)) {
1683		printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1684		done(shpnt, DID_NO_CONNECT << 16);
1685		return;
1686	}
1687
1688	SETPORT(SSTAT0, CLRSELDO);
1689	
1690	ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1691
1692	if (CURRENT_SC->SCp.phase & aborting) {
1693		ADDMSGO(ABORT);
1694	} else if (CURRENT_SC->SCp.phase & resetting) {
1695		ADDMSGO(BUS_DEVICE_RESET);
1696	} else if (SYNCNEG==0 && SYNCHRONOUS) {
1697    		CURRENT_SC->SCp.phase |= syncneg;
1698		MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1699		SYNCNEG=1;		/* negotiation in progress */
1700	}
1701
1702	SETRATE(SYNCRATE);
1703}
1704
1705/*
1706 * Selection timeout
1707 * - return command to mid-level with failure cause
1708 *
1709 */
1710static void selto_run(struct Scsi_Host *shpnt)
1711{
1712	SETPORT(SCSISEQ, 0);		
1713	SETPORT(SSTAT1, CLRSELTIMO);
1714
1715	DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1716
1717	if(!CURRENT_SC) {
1718		DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1719		return;
1720	}
1721
1722    	CURRENT_SC->SCp.phase &= ~selecting;
1723
1724	if (CURRENT_SC->SCp.phase & aborted) {
1725		DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1726		done(shpnt, DID_ABORT << 16);
1727	} else if (TESTLO(SSTAT0, SELINGO)) {
1728		DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1729		done(shpnt, DID_BUS_BUSY << 16);
1730	} else {
1731		/* ARBITRATION won, but SELECTION failed */
1732		DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1733		done(shpnt, DID_NO_CONNECT << 16);
1734	}
1735}
1736
1737/*
1738 * Selection in done
1739 * - put current command back to issue queue
1740 *   (reconnection of a disconnected nexus instead
1741 *    of successful selection out)
1742 *
1743 */
1744static void seldi_run(struct Scsi_Host *shpnt)
1745{
1746	int selid;
1747	int target;
1748	unsigned long flags;
1749
1750	SETPORT(SCSISIG, 0);
1751	SETPORT(SSTAT0, CLRSELDI);
1752	SETPORT(SSTAT1, CLRBUSFREE);
1753	SETPORT(SSTAT1, CLRPHASECHG);
1754
1755	if(CURRENT_SC) {
1756		if(!(CURRENT_SC->SCp.phase & not_issued))
1757			printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1758
1759		DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1760
1761		DO_LOCK(flags);
1762		append_SC(&ISSUE_SC, CURRENT_SC);
1763		DO_UNLOCK(flags);
1764
1765		CURRENT_SC = NULL;
1766	}
1767
1768	if(!DISCONNECTED_SC) {
1769		DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1770		return;
1771	}
1772
1773	RECONN_TARGET=-1;
1774
1775	selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1776
1777	if (selid==0) {
1778		printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1779		return;
1780	}
1781
1782	for(target=7; !(selid & (1 << target)); target--)
1783		;
1784
1785	if(selid & ~(1 << target)) {
1786		printk("aha152x%d: multiple targets reconnected (%02x)\n",
1787		       HOSTNO, selid);
1788	}
1789
1790
1791	SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1792	SETPORT(SCSISEQ, 0);
1793
1794	SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1795
1796	RECONN_TARGET=target;
1797	DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1798}
1799
1800/*
1801 * message in phase
1802 * - handle initial message after reconnection to identify
1803 *   reconnecting nexus
1804 * - queue command on DISCONNECTED_SC on DISCONNECT message
1805 * - set completed flag on COMMAND COMPLETE
1806 *   (other completition code moved to busfree_run)
1807 * - handle response to SDTR
1808 * - clear synchronous transfer agreements on BUS RESET
1809 *
1810 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1811 *
1812 */
1813static void msgi_run(struct Scsi_Host *shpnt)
1814{
1815	for(;;) {
1816		int sstat1 = GETPORT(SSTAT1);
1817
1818		if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1819			return;
1820
1821		if(TESTLO(SSTAT0,SPIORDY)) {
1822			DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1823			return;
1824		}	
1825
1826		ADDMSGI(GETPORT(SCSIDAT));
1827
1828#if defined(AHA152X_DEBUG)
1829		if (HOSTDATA(shpnt)->debug & debug_msgi) {
1830			printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1831			spi_print_msg(&MSGI(0));
1832			printk("\n");
1833		}
1834#endif
1835
1836		if(!CURRENT_SC) {
1837			if(LASTSTATE!=seldi) {
1838				printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1839			}
1840
1841			/*
1842	 	 	 * Handle reselection
1843	 		 */
1844			if(!(MSGI(0) & IDENTIFY_BASE)) {
1845				printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1846				continue;
1847			}
1848
1849			CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1850
1851			if (!CURRENT_SC) {
1852				show_queues(shpnt);
1853				printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1854				continue;
1855			}
1856
1857			DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1858
1859			CURRENT_SC->SCp.Message = MSGI(0);
1860			CURRENT_SC->SCp.phase &= ~disconnected;
1861
1862			MSGILEN=0;
1863
1864			/* next message if any */
1865			continue;
1866		} 
1867
1868		CURRENT_SC->SCp.Message = MSGI(0);
1869
1870		switch (MSGI(0)) {
1871		case DISCONNECT:
1872			if (!RECONNECT)
1873				printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1874
1875			CURRENT_SC->SCp.phase |= disconnected;
1876			break;
1877
1878		case COMMAND_COMPLETE:
1879			if(CURRENT_SC->SCp.phase & completed)
1880				DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1881
1882			CURRENT_SC->SCp.phase |= completed;
1883			break;
1884
1885		case MESSAGE_REJECT:
1886			if…
Large files files are truncated, but you can click here to view the full file