linux/drivers/scsi/aha152x.c
<<
>>
Prefs
   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 <linux/completion.h>
 243#include <linux/errno.h>
 244#include <linux/string.h>
 245#include <linux/wait.h>
 246#include <linux/ioport.h>
 247#include <linux/delay.h>
 248#include <linux/proc_fs.h>
 249#include <linux/interrupt.h>
 250#include <linux/init.h>
 251#include <linux/kernel.h>
 252#include <linux/isapnp.h>
 253#include <linux/spinlock.h>
 254#include <linux/workqueue.h>
 255#include <linux/list.h>
 256#include <linux/slab.h>
 257#include <scsi/scsicam.h>
 258
 259#include "scsi.h"
 260#include <scsi/scsi_dbg.h>
 261#include <scsi/scsi_host.h>
 262#include <scsi/scsi_transport_spi.h>
 263#include <scsi/scsi_eh.h>
 264#include "aha152x.h"
 265
 266static LIST_HEAD(aha152x_host_list);
 267
 268
 269/* DEFINES */
 270
 271/* For PCMCIA cards, always use AUTOCONF */
 272#if defined(PCMCIA) || defined(MODULE)
 273#if !defined(AUTOCONF)
 274#define AUTOCONF
 275#endif
 276#endif
 277
 278#if !defined(AUTOCONF) && !defined(SETUP0)
 279#error define AUTOCONF or SETUP0
 280#endif
 281
 282#if defined(AHA152X_DEBUG)
 283#define DEBUG_DEFAULT debug_eh
 284
 285#define DPRINTK(when,msgs...) \
 286        do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
 287
 288#define DO_LOCK(flags)  \
 289        do { \
 290                if(spin_is_locked(&QLOCK)) { \
 291                        DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
 292                } \
 293                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
 294                spin_lock_irqsave(&QLOCK,flags); \
 295                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
 296                QLOCKER=__func__; \
 297                QLOCKERL=__LINE__; \
 298        } while(0)
 299
 300#define DO_UNLOCK(flags)        \
 301        do { \
 302                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
 303                spin_unlock_irqrestore(&QLOCK,flags); \
 304                DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
 305                QLOCKER="(not locked)"; \
 306                QLOCKERL=0; \
 307        } while(0)
 308
 309#else
 310#define DPRINTK(when,msgs...)
 311#define DO_LOCK(flags)          spin_lock_irqsave(&QLOCK,flags)
 312#define DO_UNLOCK(flags)        spin_unlock_irqrestore(&QLOCK,flags)
 313#endif
 314
 315#define LEAD            "(scsi%d:%d:%d) "
 316#define WARN_LEAD       KERN_WARNING    LEAD
 317#define INFO_LEAD       KERN_INFO       LEAD
 318#define NOTE_LEAD       KERN_NOTICE     LEAD
 319#define ERR_LEAD        KERN_ERR        LEAD
 320#define DEBUG_LEAD      KERN_DEBUG      LEAD
 321#define CMDINFO(cmd) \
 322                        (cmd) ? ((cmd)->device->host->host_no) : -1, \
 323                        (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
 324                        (cmd) ? ((cmd)->device->lun & 0x07) : -1
 325
 326static inline void
 327CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 328{
 329        scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
 330}
 331
 332#define DELAY_DEFAULT 1000
 333
 334#if defined(PCMCIA)
 335#define IRQ_MIN 0
 336#define IRQ_MAX 16
 337#else
 338#define IRQ_MIN 9
 339#if defined(__PPC)
 340#define IRQ_MAX (nr_irqs-1)
 341#else
 342#define IRQ_MAX 12
 343#endif
 344#endif
 345
 346enum {
 347        not_issued      = 0x0001,       /* command not yet issued */
 348        selecting       = 0x0002,       /* target is beeing selected */
 349        identified      = 0x0004,       /* IDENTIFY was sent */
 350        disconnected    = 0x0008,       /* target disconnected */
 351        completed       = 0x0010,       /* target sent COMMAND COMPLETE */ 
 352        aborted         = 0x0020,       /* ABORT was sent */
 353        resetted        = 0x0040,       /* BUS DEVICE RESET was sent */
 354        spiordy         = 0x0080,       /* waiting for SPIORDY to raise */
 355        syncneg         = 0x0100,       /* synchronous negotiation in progress */
 356        aborting        = 0x0200,       /* ABORT is pending */
 357        resetting       = 0x0400,       /* BUS DEVICE RESET is pending */
 358        check_condition = 0x0800,       /* requesting sense after CHECK CONDITION */
 359};
 360
 361MODULE_AUTHOR("Jürgen Fischer");
 362MODULE_DESCRIPTION(AHA152X_REVID);
 363MODULE_LICENSE("GPL");
 364
 365#if !defined(PCMCIA)
 366#if defined(MODULE)
 367static int io[] = {0, 0};
 368module_param_array(io, int, NULL, 0);
 369MODULE_PARM_DESC(io,"base io address of controller");
 370
 371static int irq[] = {0, 0};
 372module_param_array(irq, int, NULL, 0);
 373MODULE_PARM_DESC(irq,"interrupt for controller");
 374
 375static int scsiid[] = {7, 7};
 376module_param_array(scsiid, int, NULL, 0);
 377MODULE_PARM_DESC(scsiid,"scsi id of controller");
 378
 379static int reconnect[] = {1, 1};
 380module_param_array(reconnect, int, NULL, 0);
 381MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
 382
 383static int parity[] = {1, 1};
 384module_param_array(parity, int, NULL, 0);
 385MODULE_PARM_DESC(parity,"use scsi parity");
 386
 387static int sync[] = {1, 1};
 388module_param_array(sync, int, NULL, 0);
 389MODULE_PARM_DESC(sync,"use synchronous transfers");
 390
 391static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
 392module_param_array(delay, int, NULL, 0);
 393MODULE_PARM_DESC(delay,"scsi reset delay");
 394
 395static int exttrans[] = {0, 0};
 396module_param_array(exttrans, int, NULL, 0);
 397MODULE_PARM_DESC(exttrans,"use extended translation");
 398
 399#if !defined(AHA152X_DEBUG)
 400static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 401module_param_array(aha152x, int, NULL, 0);
 402MODULE_PARM_DESC(aha152x, "parameters for first controller");
 403
 404static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 405module_param_array(aha152x1, int, NULL, 0);
 406MODULE_PARM_DESC(aha152x1, "parameters for second controller");
 407#else
 408static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
 409module_param_array(debug, int, NULL, 0);
 410MODULE_PARM_DESC(debug, "flags for driver debugging");
 411
 412static int aha152x[]   = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
 413module_param_array(aha152x, int, NULL, 0);
 414MODULE_PARM_DESC(aha152x, "parameters for first controller");
 415
 416static int aha152x1[]  = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
 417module_param_array(aha152x1, int, NULL, 0);
 418MODULE_PARM_DESC(aha152x1, "parameters for second controller");
 419#endif /* !defined(AHA152X_DEBUG) */
 420#endif /* MODULE */
 421
 422#ifdef __ISAPNP__
 423static struct isapnp_device_id id_table[] = {
 424        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
 425        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
 426        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
 427        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
 428        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
 429        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
 430        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
 431        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
 432        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
 433        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
 434        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
 435        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
 436        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
 437        { ISAPNP_DEVICE_SINGLE_END, }
 438};
 439MODULE_DEVICE_TABLE(isapnp, id_table);
 440#endif /* ISAPNP */
 441
 442#endif /* !PCMCIA */
 443
 444static struct scsi_host_template aha152x_driver_template;
 445
 446/*
 447 * internal states of the host
 448 *
 449 */ 
 450enum aha152x_state {
 451        idle=0,
 452        unknown,
 453        seldo,
 454        seldi,
 455        selto,
 456        busfree,
 457        msgo,
 458        cmd,
 459        msgi,
 460        status,
 461        datai,
 462        datao,
 463        parerr,
 464        rsti,
 465        maxstate
 466};
 467
 468/*
 469 * current state information of the host
 470 *
 471 */
 472struct aha152x_hostdata {
 473        Scsi_Cmnd *issue_SC;
 474                /* pending commands to issue */
 475
 476        Scsi_Cmnd *current_SC;
 477                /* current command on the bus */
 478
 479        Scsi_Cmnd *disconnected_SC;
 480                /* commands that disconnected */
 481
 482        Scsi_Cmnd *done_SC;
 483                /* command that was completed */
 484
 485        spinlock_t lock;
 486                /* host lock */
 487
 488#if defined(AHA152X_DEBUG)
 489        const char *locker;
 490                /* which function has the lock */
 491        int lockerl;    /* where did it get it */
 492
 493        int debug;      /* current debugging setting */
 494#endif
 495
 496#if defined(AHA152X_STAT)
 497        int           total_commands;
 498        int           disconnections;
 499        int           busfree_without_any_action;
 500        int           busfree_without_old_command;
 501        int           busfree_without_new_command;
 502        int           busfree_without_done_command;
 503        int           busfree_with_check_condition;
 504        int           count[maxstate];
 505        int           count_trans[maxstate];
 506        unsigned long time[maxstate];
 507#endif
 508
 509        int commands;           /* current number of commands */
 510
 511        int reconnect;          /* disconnection allowed */
 512        int parity;             /* parity checking enabled */
 513        int synchronous;        /* synchronous transferes enabled */
 514        int delay;              /* reset out delay */
 515        int ext_trans;          /* extended translation enabled */
 516
 517        int swint;              /* software-interrupt was fired during detect() */
 518        int service;            /* bh needs to be run */
 519        int in_intr;            /* bh is running */
 520
 521        /* current state,
 522           previous state,
 523           last state different from current state */
 524        enum aha152x_state state, prevstate, laststate;
 525
 526        int target;
 527                /* reconnecting target */
 528
 529        unsigned char syncrate[8];
 530                /* current synchronous transfer agreements */
 531
 532        unsigned char syncneg[8];
 533                /* 0: no negotiation;
 534                 * 1: negotiation in progress;
 535                 * 2: negotiation completed
 536                 */
 537
 538        int cmd_i;
 539                /* number of sent bytes of current command */
 540
 541        int msgi_len;
 542                /* number of received message bytes */
 543        unsigned char msgi[256];
 544                /* received message bytes */
 545
 546        int msgo_i, msgo_len;   
 547                /* number of sent bytes and length of current messages */
 548        unsigned char msgo[256];
 549                /* pending messages */
 550
 551        int data_len;
 552                /* number of sent/received bytes in dataphase */
 553
 554        unsigned long io_port0;
 555        unsigned long io_port1;
 556
 557#ifdef __ISAPNP__
 558        struct pnp_dev *pnpdev;
 559#endif
 560        struct list_head host_list;
 561};
 562
 563
 564/*
 565 * host specific command extension
 566 *
 567 */
 568struct aha152x_scdata {
 569        Scsi_Cmnd *next;        /* next sc in queue */
 570        struct completion *done;/* semaphore to block on */
 571        struct scsi_eh_save ses;
 572};
 573
 574/* access macros for hostdata */
 575
 576#define HOSTDATA(shpnt)         ((struct aha152x_hostdata *) &shpnt->hostdata)
 577
 578#define HOSTNO                  ((shpnt)->host_no)
 579
 580#define CURRENT_SC              (HOSTDATA(shpnt)->current_SC)
 581#define DONE_SC                 (HOSTDATA(shpnt)->done_SC)
 582#define ISSUE_SC                (HOSTDATA(shpnt)->issue_SC)
 583#define DISCONNECTED_SC         (HOSTDATA(shpnt)->disconnected_SC)
 584#define QLOCK                   (HOSTDATA(shpnt)->lock)
 585#define QLOCKER                 (HOSTDATA(shpnt)->locker)
 586#define QLOCKERL                (HOSTDATA(shpnt)->lockerl)
 587
 588#define STATE                   (HOSTDATA(shpnt)->state)
 589#define PREVSTATE               (HOSTDATA(shpnt)->prevstate)
 590#define LASTSTATE               (HOSTDATA(shpnt)->laststate)
 591
 592#define RECONN_TARGET           (HOSTDATA(shpnt)->target)
 593
 594#define CMD_I                   (HOSTDATA(shpnt)->cmd_i)
 595
 596#define MSGO(i)                 (HOSTDATA(shpnt)->msgo[i])
 597#define MSGO_I                  (HOSTDATA(shpnt)->msgo_i)
 598#define MSGOLEN                 (HOSTDATA(shpnt)->msgo_len)
 599#define ADDMSGO(x)              (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
 600
 601#define MSGI(i)                 (HOSTDATA(shpnt)->msgi[i])
 602#define MSGILEN                 (HOSTDATA(shpnt)->msgi_len)
 603#define ADDMSGI(x)              (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
 604
 605#define DATA_LEN                (HOSTDATA(shpnt)->data_len)
 606
 607#define SYNCRATE                (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
 608#define SYNCNEG                 (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
 609
 610#define DELAY                   (HOSTDATA(shpnt)->delay)
 611#define EXT_TRANS               (HOSTDATA(shpnt)->ext_trans)
 612#define TC1550                  (HOSTDATA(shpnt)->tc1550)
 613#define RECONNECT               (HOSTDATA(shpnt)->reconnect)
 614#define PARITY                  (HOSTDATA(shpnt)->parity)
 615#define SYNCHRONOUS             (HOSTDATA(shpnt)->synchronous)
 616
 617#define HOSTIOPORT0             (HOSTDATA(shpnt)->io_port0)
 618#define HOSTIOPORT1             (HOSTDATA(shpnt)->io_port1)
 619
 620#define SCDATA(SCpnt)           ((struct aha152x_scdata *) (SCpnt)->host_scribble)
 621#define SCNEXT(SCpnt)           SCDATA(SCpnt)->next
 622#define SCSEM(SCpnt)            SCDATA(SCpnt)->done
 623
 624#define SG_ADDRESS(buffer)      ((char *) sg_virt((buffer)))
 625
 626/* state handling */
 627static void seldi_run(struct Scsi_Host *shpnt);
 628static void seldo_run(struct Scsi_Host *shpnt);
 629static void selto_run(struct Scsi_Host *shpnt);
 630static void busfree_run(struct Scsi_Host *shpnt);
 631
 632static void msgo_init(struct Scsi_Host *shpnt);
 633static void msgo_run(struct Scsi_Host *shpnt);
 634static void msgo_end(struct Scsi_Host *shpnt);
 635
 636static void cmd_init(struct Scsi_Host *shpnt);
 637static void cmd_run(struct Scsi_Host *shpnt);
 638static void cmd_end(struct Scsi_Host *shpnt);
 639
 640static void datai_init(struct Scsi_Host *shpnt);
 641static void datai_run(struct Scsi_Host *shpnt);
 642static void datai_end(struct Scsi_Host *shpnt);
 643
 644static void datao_init(struct Scsi_Host *shpnt);
 645static void datao_run(struct Scsi_Host *shpnt);
 646static void datao_end(struct Scsi_Host *shpnt);
 647
 648static void status_run(struct Scsi_Host *shpnt);
 649
 650static void msgi_run(struct Scsi_Host *shpnt);
 651static void msgi_end(struct Scsi_Host *shpnt);
 652
 653static void parerr_run(struct Scsi_Host *shpnt);
 654static void rsti_run(struct Scsi_Host *shpnt);
 655
 656static void is_complete(struct Scsi_Host *shpnt);
 657
 658/*
 659 * driver states
 660 *
 661 */
 662static struct {
 663        char            *name;
 664        void            (*init)(struct Scsi_Host *);
 665        void            (*run)(struct Scsi_Host *);
 666        void            (*end)(struct Scsi_Host *);
 667        int             spio;
 668} states[] = {
 669        { "idle",       NULL,           NULL,           NULL,           0},
 670        { "unknown",    NULL,           NULL,           NULL,           0},
 671        { "seldo",      NULL,           seldo_run,      NULL,           0},
 672        { "seldi",      NULL,           seldi_run,      NULL,           0},
 673        { "selto",      NULL,           selto_run,      NULL,           0},
 674        { "busfree",    NULL,           busfree_run,    NULL,           0},
 675        { "msgo",       msgo_init,      msgo_run,       msgo_end,       1},
 676        { "cmd",        cmd_init,       cmd_run,        cmd_end,        1},
 677        { "msgi",       NULL,           msgi_run,       msgi_end,       1},
 678        { "status",     NULL,           status_run,     NULL,           1},
 679        { "datai",      datai_init,     datai_run,      datai_end,      0},
 680        { "datao",      datao_init,     datao_run,      datao_end,      0},
 681        { "parerr",     NULL,           parerr_run,     NULL,           0},
 682        { "rsti",       NULL,           rsti_run,       NULL,           0},
 683};
 684
 685/* setup & interrupt */
 686static irqreturn_t intr(int irq, void *dev_id);
 687static void reset_ports(struct Scsi_Host *shpnt);
 688static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
 689static void done(struct Scsi_Host *shpnt, int error);
 690
 691/* diagnostics */
 692static void disp_ports(struct Scsi_Host *shpnt);
 693static void show_command(Scsi_Cmnd * ptr);
 694static void show_queues(struct Scsi_Host *shpnt);
 695static void disp_enintr(struct Scsi_Host *shpnt);
 696
 697
 698/*
 699 *  queue services:
 700 *
 701 */
 702static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
 703{
 704        Scsi_Cmnd *end;
 705
 706        SCNEXT(new_SC) = NULL;
 707        if (!*SC)
 708                *SC = new_SC;
 709        else {
 710                for (end = *SC; SCNEXT(end); end = SCNEXT(end))
 711                        ;
 712                SCNEXT(end) = new_SC;
 713        }
 714}
 715
 716static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
 717{
 718        Scsi_Cmnd *ptr;
 719
 720        ptr = *SC;
 721        if (ptr) {
 722                *SC = SCNEXT(*SC);
 723                SCNEXT(ptr)=NULL;
 724        }
 725        return ptr;
 726}
 727
 728static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
 729{
 730        Scsi_Cmnd *ptr, *prev;
 731
 732        for (ptr = *SC, prev = NULL;
 733             ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
 734             prev = ptr, ptr = SCNEXT(ptr))
 735             ;
 736
 737        if (ptr) {
 738                if (prev)
 739                        SCNEXT(prev) = SCNEXT(ptr);
 740                else
 741                        *SC = SCNEXT(ptr);
 742
 743                SCNEXT(ptr)=NULL;
 744        }
 745
 746        return ptr;
 747}
 748
 749static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
 750{
 751        Scsi_Cmnd *ptr, *prev;
 752
 753        for (ptr = *SC, prev = NULL;
 754             ptr && SCp!=ptr;
 755             prev = ptr, ptr = SCNEXT(ptr))
 756             ;
 757
 758        if (ptr) {
 759                if (prev)
 760                        SCNEXT(prev) = SCNEXT(ptr);
 761                else
 762                        *SC = SCNEXT(ptr);
 763
 764                SCNEXT(ptr)=NULL;
 765        }
 766
 767        return ptr;
 768}
 769
 770static irqreturn_t swintr(int irqno, void *dev_id)
 771{
 772        struct Scsi_Host *shpnt = dev_id;
 773
 774        HOSTDATA(shpnt)->swint++;
 775
 776        SETPORT(DMACNTRL0, INTEN);
 777        return IRQ_HANDLED;
 778}
 779
 780struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
 781{
 782        struct Scsi_Host *shpnt;
 783
 784        shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
 785        if (!shpnt) {
 786                printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
 787                return NULL;
 788        }
 789
 790        memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
 791        INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
 792
 793        /* need to have host registered before triggering any interrupt */
 794        list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
 795
 796        shpnt->io_port   = setup->io_port;
 797        shpnt->n_io_port = IO_RANGE;
 798        shpnt->irq       = setup->irq;
 799
 800        if (!setup->tc1550) {
 801                HOSTIOPORT0 = setup->io_port;
 802                HOSTIOPORT1 = setup->io_port;
 803        } else {
 804                HOSTIOPORT0 = setup->io_port+0x10;
 805                HOSTIOPORT1 = setup->io_port-0x10;
 806        }
 807
 808        spin_lock_init(&QLOCK);
 809        RECONNECT   = setup->reconnect;
 810        SYNCHRONOUS = setup->synchronous;
 811        PARITY      = setup->parity;
 812        DELAY       = setup->delay;
 813        EXT_TRANS   = setup->ext_trans;
 814
 815#if defined(AHA152X_DEBUG)
 816        HOSTDATA(shpnt)->debug = setup->debug;
 817#endif
 818
 819        SETPORT(SCSIID, setup->scsiid << 4);
 820        shpnt->this_id = setup->scsiid;
 821
 822        if (setup->reconnect)
 823                shpnt->can_queue = AHA152X_MAXQUEUE;
 824
 825        /* RESET OUT */
 826        printk("aha152x: resetting bus...\n");
 827        SETPORT(SCSISEQ, SCSIRSTO);
 828        mdelay(256);
 829        SETPORT(SCSISEQ, 0);
 830        mdelay(DELAY);
 831
 832        reset_ports(shpnt);
 833
 834        printk(KERN_INFO
 835               "aha152x%d%s: "
 836               "vital data: rev=%x, "
 837               "io=0x%03lx (0x%03lx/0x%03lx), "
 838               "irq=%d, "
 839               "scsiid=%d, "
 840               "reconnect=%s, "
 841               "parity=%s, "
 842               "synchronous=%s, "
 843               "delay=%d, "
 844               "extended translation=%s\n",
 845               shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
 846               GETPORT(REV) & 0x7,
 847               shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
 848               shpnt->irq,
 849               shpnt->this_id,
 850               RECONNECT ? "enabled" : "disabled",
 851               PARITY ? "enabled" : "disabled",
 852               SYNCHRONOUS ? "enabled" : "disabled",
 853               DELAY,
 854               EXT_TRANS ? "enabled" : "disabled");
 855
 856        /* not expecting any interrupts */
 857        SETPORT(SIMODE0, 0);
 858        SETPORT(SIMODE1, 0);
 859
 860        if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
 861                printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
 862                goto out_host_put;
 863        }
 864
 865        HOSTDATA(shpnt)->swint = 0;
 866
 867        printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
 868
 869        mb();
 870        SETPORT(DMACNTRL0, SWINT|INTEN);
 871        mdelay(1000);
 872        free_irq(shpnt->irq, shpnt);
 873
 874        if (!HOSTDATA(shpnt)->swint) {
 875                if (TESTHI(DMASTAT, INTSTAT)) {
 876                        printk("lost.\n");
 877                } else {
 878                        printk("failed.\n");
 879                }
 880
 881                SETPORT(DMACNTRL0, INTEN);
 882
 883                printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
 884                                "Please verify.\n", shpnt->host_no, shpnt->irq);
 885                goto out_host_put;
 886        }
 887        printk("ok.\n");
 888
 889
 890        /* clear interrupts */
 891        SETPORT(SSTAT0, 0x7f);
 892        SETPORT(SSTAT1, 0xef);
 893
 894        if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
 895                printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
 896                goto out_host_put;
 897        }
 898
 899        if( scsi_add_host(shpnt, NULL) ) {
 900                free_irq(shpnt->irq, shpnt);
 901                printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
 902                goto out_host_put;
 903        }
 904
 905        scsi_scan_host(shpnt);
 906
 907        return shpnt;
 908
 909out_host_put:
 910        list_del(&HOSTDATA(shpnt)->host_list);
 911        scsi_host_put(shpnt);
 912
 913        return NULL;
 914}
 915
 916void aha152x_release(struct Scsi_Host *shpnt)
 917{
 918        if (!shpnt)
 919                return;
 920
 921        scsi_remove_host(shpnt);
 922        if (shpnt->irq)
 923                free_irq(shpnt->irq, shpnt);
 924
 925#if !defined(PCMCIA)
 926        if (shpnt->io_port)
 927                release_region(shpnt->io_port, IO_RANGE);
 928#endif
 929
 930#ifdef __ISAPNP__
 931        if (HOSTDATA(shpnt)->pnpdev)
 932                pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
 933#endif
 934
 935        list_del(&HOSTDATA(shpnt)->host_list);
 936        scsi_host_put(shpnt);
 937}
 938
 939
 940/*
 941 * setup controller to generate interrupts depending
 942 * on current state (lock has to be acquired)
 943 *
 944 */ 
 945static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 946{
 947        if(CURRENT_SC) {
 948                CURRENT_SC->SCp.phase |= 1 << 16;
 949        
 950                if(CURRENT_SC->SCp.phase & selecting) {
 951                        DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
 952                        SETPORT(SSTAT1, SELTO);
 953                        SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
 954                        SETPORT(SIMODE1, ENSELTIMO);
 955                } else {
 956                        DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
 957                        SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
 958                        SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
 959                }
 960        } else if(STATE==seldi) {
 961                DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
 962                SETPORT(SIMODE0, 0);
 963                SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
 964        } else {
 965                DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
 966                        CMDINFO(CURRENT_SC),
 967                        DISCONNECTED_SC ? "(reselection)" : "",
 968                        ISSUE_SC ? "(busfree)" : "");
 969                SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
 970                SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
 971        }
 972
 973        if(!HOSTDATA(shpnt)->in_intr)
 974                SETBITS(DMACNTRL0, INTEN);
 975
 976        return TESTHI(DMASTAT, INTSTAT);
 977}
 978
 979
 980/* 
 981 *  Queue a command and setup interrupts for a free bus.
 982 */
 983static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
 984                int phase, void (*done)(Scsi_Cmnd *))
 985{
 986        struct Scsi_Host *shpnt = SCpnt->device->host;
 987        unsigned long flags;
 988
 989#if defined(AHA152X_DEBUG)
 990        if (HOSTDATA(shpnt)->debug & debug_queue) {
 991                printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
 992                       CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
 993                       scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
 994                __scsi_print_command(SCpnt->cmnd);
 995        }
 996#endif
 997
 998        SCpnt->scsi_done        = done;
 999        SCpnt->SCp.phase        = not_issued | phase;
1000        SCpnt->SCp.Status       = 0x1; /* Ilegal status by SCSI standard */
1001        SCpnt->SCp.Message      = 0;
1002        SCpnt->SCp.have_data_in = 0;
1003        SCpnt->SCp.sent_command = 0;
1004
1005        if(SCpnt->SCp.phase & (resetting|check_condition)) {
1006                if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1007                        printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1008                        return FAILED;
1009                }
1010        } else {
1011                SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1012                if(!SCpnt->host_scribble) {
1013                        printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1014                        return FAILED;
1015                }
1016        }
1017
1018        SCNEXT(SCpnt)           = NULL;
1019        SCSEM(SCpnt)            = complete;
1020
1021        /* setup scratch area
1022           SCp.ptr              : buffer pointer
1023           SCp.this_residual    : buffer length
1024           SCp.buffer           : next buffer
1025           SCp.buffers_residual : left buffers in list
1026           SCp.phase            : current state of the command */
1027
1028        if ((phase & resetting) || !scsi_sglist(SCpnt)) {
1029                SCpnt->SCp.ptr           = NULL;
1030                SCpnt->SCp.this_residual = 0;
1031                scsi_set_resid(SCpnt, 0);
1032                SCpnt->SCp.buffer           = NULL;
1033                SCpnt->SCp.buffers_residual = 0;
1034        } else {
1035                scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1036                SCpnt->SCp.buffer           = scsi_sglist(SCpnt);
1037                SCpnt->SCp.ptr              = SG_ADDRESS(SCpnt->SCp.buffer);
1038                SCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
1039                SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1040        }
1041
1042        DO_LOCK(flags);
1043
1044#if defined(AHA152X_STAT)
1045        HOSTDATA(shpnt)->total_commands++;
1046#endif
1047
1048        /* Turn led on, when this is the first command. */
1049        HOSTDATA(shpnt)->commands++;
1050        if (HOSTDATA(shpnt)->commands==1)
1051                SETPORT(PORTA, 1);
1052
1053        append_SC(&ISSUE_SC, SCpnt);
1054
1055        if(!HOSTDATA(shpnt)->in_intr)
1056                setup_expected_interrupts(shpnt);
1057
1058        DO_UNLOCK(flags);
1059
1060        return 0;
1061}
1062
1063/*
1064 *  queue a command
1065 *
1066 */
1067static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1068{
1069#if 0
1070        if(*SCpnt->cmnd == REQUEST_SENSE) {
1071                SCpnt->result = 0;
1072                done(SCpnt);
1073
1074                return 0;
1075        }
1076#endif
1077
1078        return aha152x_internal_queue(SCpnt, NULL, 0, done);
1079}
1080
1081static DEF_SCSI_QCMD(aha152x_queue)
1082
1083
1084/*
1085 *  
1086 *
1087 */
1088static void reset_done(Scsi_Cmnd *SCpnt)
1089{
1090#if 0
1091        struct Scsi_Host *shpnt = SCpnt->host;
1092        DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1093#endif
1094        if(SCSEM(SCpnt)) {
1095                complete(SCSEM(SCpnt));
1096        } else {
1097                printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1098        }
1099}
1100
1101/*
1102 *  Abort a command
1103 *
1104 */
1105static int aha152x_abort(Scsi_Cmnd *SCpnt)
1106{
1107        struct Scsi_Host *shpnt = SCpnt->device->host;
1108        Scsi_Cmnd *ptr;
1109        unsigned long flags;
1110
1111#if defined(AHA152X_DEBUG)
1112        if(HOSTDATA(shpnt)->debug & debug_eh) {
1113                printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1114                show_queues(shpnt);
1115        }
1116#endif
1117
1118        DO_LOCK(flags);
1119
1120        ptr=remove_SC(&ISSUE_SC, SCpnt);
1121
1122        if(ptr) {
1123                DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1124
1125                HOSTDATA(shpnt)->commands--;
1126                if (!HOSTDATA(shpnt)->commands)
1127                        SETPORT(PORTA, 0);
1128                DO_UNLOCK(flags);
1129
1130                kfree(SCpnt->host_scribble);
1131                SCpnt->host_scribble=NULL;
1132
1133                return SUCCESS;
1134        } 
1135
1136        DO_UNLOCK(flags);
1137
1138        /*
1139         * FIXME:
1140         * for current command: queue ABORT for message out and raise ATN
1141         * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1142         *
1143         */
1144
1145        printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1146
1147        return FAILED;
1148}
1149
1150/*
1151 * Reset a device
1152 *
1153 */
1154static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1155{
1156        struct Scsi_Host *shpnt = SCpnt->device->host;
1157        DECLARE_COMPLETION(done);
1158        int ret, issued, disconnected;
1159        unsigned char old_cmd_len = SCpnt->cmd_len;
1160        unsigned long flags;
1161        unsigned long timeleft;
1162
1163#if defined(AHA152X_DEBUG)
1164        if(HOSTDATA(shpnt)->debug & debug_eh) {
1165                printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1166                show_queues(shpnt);
1167        }
1168#endif
1169
1170        if(CURRENT_SC==SCpnt) {
1171                printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1172                return FAILED;
1173        }
1174
1175        DO_LOCK(flags);
1176        issued       = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1177        disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1178        DO_UNLOCK(flags);
1179
1180        SCpnt->cmd_len         = 0;
1181
1182        aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1183
1184        timeleft = wait_for_completion_timeout(&done, 100*HZ);
1185        if (!timeleft) {
1186                /* remove command from issue queue */
1187                DO_LOCK(flags);
1188                remove_SC(&ISSUE_SC, SCpnt);
1189                DO_UNLOCK(flags);
1190        }
1191
1192        SCpnt->cmd_len         = old_cmd_len;
1193
1194        DO_LOCK(flags);
1195
1196        if(SCpnt->SCp.phase & resetted) {
1197                HOSTDATA(shpnt)->commands--;
1198                if (!HOSTDATA(shpnt)->commands)
1199                        SETPORT(PORTA, 0);
1200                kfree(SCpnt->host_scribble);
1201                SCpnt->host_scribble=NULL;
1202
1203                ret = SUCCESS;
1204        } else {
1205                /* requeue */
1206                if(!issued) {
1207                        append_SC(&ISSUE_SC, SCpnt);
1208                } else if(disconnected) {
1209                        append_SC(&DISCONNECTED_SC, SCpnt);
1210                }
1211        
1212                ret = FAILED;
1213        }
1214
1215        DO_UNLOCK(flags);
1216        return ret;
1217}
1218
1219static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1220{
1221        Scsi_Cmnd *ptr;
1222
1223        ptr=*SCs;
1224        while(ptr) {
1225                Scsi_Cmnd *next;
1226
1227                if(SCDATA(ptr)) {
1228                        next = SCNEXT(ptr);
1229                } else {
1230                        printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1231                        next = NULL;
1232                }
1233
1234                if (!ptr->device->soft_reset) {
1235                        DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1236                        remove_SC(SCs, ptr);
1237                        HOSTDATA(shpnt)->commands--;
1238                        kfree(ptr->host_scribble);
1239                        ptr->host_scribble=NULL;
1240                }
1241
1242                ptr = next;
1243        }
1244}
1245
1246/*
1247 * Reset the bus
1248 *
1249 */
1250static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1251{
1252        unsigned long flags;
1253
1254        DO_LOCK(flags);
1255
1256#if defined(AHA152X_DEBUG)
1257        if(HOSTDATA(shpnt)->debug & debug_eh) {
1258                printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1259                show_queues(shpnt);
1260        }
1261#endif
1262
1263        free_hard_reset_SCs(shpnt, &ISSUE_SC);
1264        free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1265
1266        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1267
1268        SETPORT(SCSISEQ, SCSIRSTO);
1269        mdelay(256);
1270        SETPORT(SCSISEQ, 0);
1271        mdelay(DELAY);
1272
1273        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1274
1275        setup_expected_interrupts(shpnt);
1276        if(HOSTDATA(shpnt)->commands==0)
1277                SETPORT(PORTA, 0);
1278
1279        DO_UNLOCK(flags);
1280
1281        return SUCCESS;
1282}
1283
1284/*
1285 * Reset the bus
1286 *
1287 */
1288static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1289{
1290        return aha152x_bus_reset_host(SCpnt->device->host);
1291}
1292
1293/*
1294 *  Restore default values to the AIC-6260 registers and reset the fifos
1295 *
1296 */
1297static void reset_ports(struct Scsi_Host *shpnt)
1298{
1299        unsigned long flags;
1300
1301        /* disable interrupts */
1302        SETPORT(DMACNTRL0, RSTFIFO);
1303
1304        SETPORT(SCSISEQ, 0);
1305
1306        SETPORT(SXFRCTL1, 0);
1307        SETPORT(SCSISIG, 0);
1308        SETRATE(0);
1309
1310        /* clear all interrupt conditions */
1311        SETPORT(SSTAT0, 0x7f);
1312        SETPORT(SSTAT1, 0xef);
1313
1314        SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1315
1316        SETPORT(DMACNTRL0, 0);
1317        SETPORT(DMACNTRL1, 0);
1318
1319        SETPORT(BRSTCNTRL, 0xf1);
1320
1321        /* clear SCSI fifos and transfer count */
1322        SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1323        SETPORT(SXFRCTL0, CH1);
1324
1325        DO_LOCK(flags);
1326        setup_expected_interrupts(shpnt);
1327        DO_UNLOCK(flags);
1328}
1329
1330/*
1331 * Reset the host (bus and controller)
1332 *
1333 */
1334int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1335{
1336        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1337
1338        aha152x_bus_reset_host(shpnt);
1339
1340        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1341        reset_ports(shpnt);
1342
1343        return SUCCESS;
1344}
1345
1346/*
1347 * Reset the host (bus and controller)
1348 * 
1349 */
1350static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1351{
1352        return aha152x_host_reset_host(SCpnt->device->host);
1353}
1354
1355/*
1356 * Return the "logical geometry"
1357 *
1358 */
1359static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1360                sector_t capacity, int *info_array)
1361{
1362        struct Scsi_Host *shpnt = sdev->host;
1363
1364        /* try default translation */
1365        info_array[0] = 64;
1366        info_array[1] = 32;
1367        info_array[2] = (unsigned long)capacity / (64 * 32);
1368
1369        /* for disks >1GB do some guessing */
1370        if (info_array[2] >= 1024) {
1371                int info[3];
1372
1373                /* try to figure out the geometry from the partition table */
1374                if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1375                    !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1376                        if (EXT_TRANS) {
1377                                printk(KERN_NOTICE
1378                                       "aha152x: unable to verify geometry for disk with >1GB.\n"
1379                                       "         using extended translation.\n");
1380                                info_array[0] = 255;
1381                                info_array[1] = 63;
1382                                info_array[2] = (unsigned long)capacity / (255 * 63);
1383                        } else {
1384                                printk(KERN_NOTICE
1385                                       "aha152x: unable to verify geometry for disk with >1GB.\n"
1386                                       "         Using default translation. Please verify yourself.\n"
1387                                       "         Perhaps you need to enable extended translation in the driver.\n"
1388                                       "         See Documentation/scsi/aha152x.txt for details.\n");
1389                        }
1390                } else {
1391                        info_array[0] = info[0];
1392                        info_array[1] = info[1];
1393                        info_array[2] = info[2];
1394
1395                        if (info[0] == 255 && !EXT_TRANS) {
1396                                printk(KERN_NOTICE
1397                                       "aha152x: current partition table is using extended translation.\n"
1398                                       "         using it also, although it's not explicitly enabled.\n");
1399                        }
1400                }
1401        }
1402
1403        return 0;
1404}
1405
1406/*
1407 *  Internal done function
1408 *
1409 */
1410static void done(struct Scsi_Host *shpnt, int error)
1411{
1412        if (CURRENT_SC) {
1413                if(DONE_SC)
1414                        printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1415
1416                DONE_SC = CURRENT_SC;
1417                CURRENT_SC = NULL;
1418                DONE_SC->result = error;
1419        } else
1420                printk(KERN_ERR "aha152x: done() called outside of command\n");
1421}
1422
1423static struct work_struct aha152x_tq;
1424
1425/*
1426 * Run service completions on the card with interrupts enabled.
1427 *
1428 */
1429static void run(struct work_struct *work)
1430{
1431        struct aha152x_hostdata *hd;
1432
1433        list_for_each_entry(hd, &aha152x_host_list, host_list) {
1434                struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1435
1436                is_complete(shost);
1437        }
1438}
1439
1440/*
1441 * Interrupt handler
1442 *
1443 */
1444static irqreturn_t intr(int irqno, void *dev_id)
1445{
1446        struct Scsi_Host *shpnt = dev_id;
1447        unsigned long flags;
1448        unsigned char rev, dmacntrl0;
1449
1450        /*
1451         * Read a couple of registers that are known to not be all 1's. If
1452         * we read all 1's (-1), that means that either:
1453         *
1454         * a. The host adapter chip has gone bad, and we cannot control it,
1455         *      OR
1456         * b. The host adapter is a PCMCIA card that has been ejected
1457         *
1458         * In either case, we cannot do anything with the host adapter at
1459         * this point in time. So just ignore the interrupt and return.
1460         * In the latter case, the interrupt might actually be meant for
1461         * someone else sharing this IRQ, and that driver will handle it.
1462         */
1463        rev = GETPORT(REV);
1464        dmacntrl0 = GETPORT(DMACNTRL0);
1465        if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1466                return IRQ_NONE;
1467
1468        if( TESTLO(DMASTAT, INTSTAT) )
1469                return IRQ_NONE;        
1470
1471        /* no more interrupts from the controller, while we're busy.
1472           INTEN is restored by the BH handler */
1473        CLRBITS(DMACNTRL0, INTEN);
1474
1475        DO_LOCK(flags);
1476        if( HOSTDATA(shpnt)->service==0 ) {
1477                HOSTDATA(shpnt)->service=1;
1478
1479                /* Poke the BH handler */
1480                INIT_WORK(&aha152x_tq, run);
1481                schedule_work(&aha152x_tq);
1482        }
1483        DO_UNLOCK(flags);
1484
1485        return IRQ_HANDLED;
1486}
1487
1488/*
1489 * busfree phase
1490 * - handle completition/disconnection/error of current command
1491 * - start selection for next command (if any)
1492 */
1493static void busfree_run(struct Scsi_Host *shpnt)
1494{
1495        unsigned long flags;
1496#if defined(AHA152X_STAT)
1497        int action=0;
1498#endif
1499
1500        SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1501        SETPORT(SXFRCTL0, CH1);
1502
1503        SETPORT(SSTAT1, CLRBUSFREE);
1504        
1505        if(CURRENT_SC) {
1506#if defined(AHA152X_STAT)
1507                action++;
1508#endif
1509                CURRENT_SC->SCp.phase &= ~syncneg;
1510
1511                if(CURRENT_SC->SCp.phase & completed) {
1512                        /* target sent COMMAND COMPLETE */
1513                        done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1514
1515                } else if(CURRENT_SC->SCp.phase & aborted) {
1516                        DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1517                        done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1518
1519                } else if(CURRENT_SC->SCp.phase & resetted) {
1520                        DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1521                        done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1522
1523                } else if(CURRENT_SC->SCp.phase & disconnected) {
1524                        /* target sent DISCONNECT */
1525                        DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1526                                CMDINFO(CURRENT_SC),
1527                                scsi_get_resid(CURRENT_SC),
1528                                scsi_bufflen(CURRENT_SC));
1529#if defined(AHA152X_STAT)
1530                        HOSTDATA(shpnt)->disconnections++;
1531#endif
1532                        append_SC(&DISCONNECTED_SC, CURRENT_SC);
1533                        CURRENT_SC->SCp.phase |= 1 << 16;
1534                        CURRENT_SC = NULL;
1535
1536                } else {
1537                        done(shpnt, DID_ERROR << 16);
1538                }
1539#if defined(AHA152X_STAT)
1540        } else {
1541                HOSTDATA(shpnt)->busfree_without_old_command++;
1542#endif
1543        }
1544
1545        DO_LOCK(flags);
1546
1547        if(DONE_SC) {
1548#if defined(AHA152X_STAT)
1549                action++;
1550#endif
1551
1552                if(DONE_SC->SCp.phase & check_condition) {
1553                        struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1554                        struct aha152x_scdata *sc = SCDATA(cmd);
1555
1556#if 0
1557                        if(HOSTDATA(shpnt)->debug & debug_eh) {
1558                                printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1559                                scsi_print_sense("bh", DONE_SC);
1560                        }
1561#endif
1562
1563                        scsi_eh_restore_cmnd(cmd, &sc->ses);
1564
1565                        cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1566
1567                        HOSTDATA(shpnt)->commands--;
1568                        if (!HOSTDATA(shpnt)->commands)
1569                                SETPORT(PORTA, 0);      /* turn led off */
1570                } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1571#if defined(AHA152X_STAT)
1572                        HOSTDATA(shpnt)->busfree_with_check_condition++;
1573#endif
1574#if 0
1575                        DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1576#endif
1577
1578                        if(!(DONE_SC->SCp.phase & not_issued)) {
1579                                struct aha152x_scdata *sc;
1580                                Scsi_Cmnd *ptr = DONE_SC;
1581                                DONE_SC=NULL;
1582#if 0
1583                                DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1584#endif
1585
1586                                sc = SCDATA(ptr);
1587                                /* It was allocated in aha152x_internal_queue? */
1588                                BUG_ON(!sc);
1589                                scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1590
1591                                DO_UNLOCK(flags);
1592                                aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1593                                DO_LOCK(flags);
1594#if 0
1595                        } else {
1596                                DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1597#endif
1598                        }
1599                }
1600
1601                if(DONE_SC && DONE_SC->scsi_done) {
1602#if defined(AHA152X_DEBUG)
1603                        int hostno=DONE_SC->device->host->host_no;
1604                        int id=DONE_SC->device->id & 0xf;
1605                        int lun=DONE_SC->device->lun & 0x7;
1606#endif
1607                        Scsi_Cmnd *ptr = DONE_SC;
1608                        DONE_SC=NULL;
1609
1610                        /* turn led off, when no commands are in the driver */
1611                        HOSTDATA(shpnt)->commands--;
1612                        if (!HOSTDATA(shpnt)->commands)
1613                                SETPORT(PORTA, 0);      /* turn led off */
1614
1615                        if(ptr->scsi_done != reset_done) {
1616                                kfree(ptr->host_scribble);
1617                                ptr->host_scribble=NULL;
1618                        }
1619
1620                        DO_UNLOCK(flags);
1621                        DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1622                        ptr->scsi_done(ptr);
1623                        DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1624                        DO_LOCK(flags);
1625                }
1626
1627                DONE_SC=NULL;
1628#if defined(AHA152X_STAT)
1629        } else {
1630                HOSTDATA(shpnt)->busfree_without_done_command++;
1631#endif
1632        }
1633
1634        if(ISSUE_SC)
1635                CURRENT_SC = remove_first_SC(&ISSUE_SC);
1636
1637        DO_UNLOCK(flags);
1638
1639        if(CURRENT_SC) {
1640#if defined(AHA152X_STAT)
1641                action++;
1642#endif
1643                CURRENT_SC->SCp.phase |= selecting;
1644
1645                DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1646
1647                /* clear selection timeout */
1648                SETPORT(SSTAT1, SELTO);
1649
1650                SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1651                SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1652                SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1653        } else {
1654#if defined(AHA152X_STAT)
1655                HOSTDATA(shpnt)->busfree_without_new_command++;
1656#endif
1657                SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1658        }
1659
1660#if defined(AHA152X_STAT)
1661        if(!action)
1662                HOSTDATA(shpnt)->busfree_without_any_action++;
1663#endif
1664}
1665
1666/*
1667 * Selection done (OUT)
1668 * - queue IDENTIFY message and SDTR to selected target for message out
1669 *   (ATN asserted automagically via ENAUTOATNO in busfree())
1670 */
1671static void seldo_run(struct Scsi_Host *shpnt)
1672{
1673        SETPORT(SCSISIG, 0);
1674        SETPORT(SSTAT1, CLRBUSFREE);
1675        SETPORT(SSTAT1, CLRPHASECHG);
1676
1677        CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1678
1679        SETPORT(SCSISEQ, 0);
1680
1681        if (TESTLO(SSTAT0, SELDO)) {
1682                printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1683                done(shpnt, DID_NO_CONNECT << 16);
1684                return;
1685        }
1686
1687        SETPORT(SSTAT0, CLRSELDO);
1688        
1689        ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1690
1691        if (CURRENT_SC->SCp.phase & aborting) {
1692                ADDMSGO(ABORT);
1693        } else if (CURRENT_SC->SCp.phase & resetting) {
1694                ADDMSGO(BUS_DEVICE_RESET);
1695        } else if (SYNCNEG==0 && SYNCHRONOUS) {
1696                CURRENT_SC->SCp.phase |= syncneg;
1697                MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1698                SYNCNEG=1;              /* negotiation in progress */
1699        }
1700
1701        SETRATE(SYNCRATE);
1702}
1703
1704/*
1705 * Selection timeout
1706 * - return command to mid-level with failure cause
1707 *
1708 */
1709static void selto_run(struct Scsi_Host *shpnt)
1710{
1711        SETPORT(SCSISEQ, 0);            
1712        SETPORT(SSTAT1, CLRSELTIMO);
1713
1714        DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1715
1716        if(!CURRENT_SC) {
1717                DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1718                return;
1719        }
1720
1721        CURRENT_SC->SCp.phase &= ~selecting;
1722
1723        if (CURRENT_SC->SCp.phase & aborted) {
1724                DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1725                done(shpnt, DID_ABORT << 16);
1726        } else if (TESTLO(SSTAT0, SELINGO)) {
1727                DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1728                done(shpnt, DID_BUS_BUSY << 16);
1729        } else {
1730                /* ARBITRATION won, but SELECTION failed */
1731                DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1732                done(shpnt, DID_NO_CONNECT << 16);
1733        }
1734}
1735
1736/*
1737 * Selection in done
1738 * - put current command back to issue queue
1739 *   (reconnection of a disconnected nexus instead
1740 *    of successful selection out)
1741 *
1742 */
1743static void seldi_run(struct Scsi_Host *shpnt)
1744{
1745        int selid;
1746        int target;
1747        unsigned long flags;
1748
1749        SETPORT(SCSISIG, 0);
1750        SETPORT(SSTAT0, CLRSELDI);
1751        SETPORT(SSTAT1, CLRBUSFREE);
1752        SETPORT(SSTAT1, CLRPHASECHG);
1753
1754        if(CURRENT_SC) {
1755                if(!(CURRENT_SC->SCp.phase & not_issued))
1756                        printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1757
1758                DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1759
1760                DO_LOCK(flags);
1761                append_SC(&ISSUE_SC, CURRENT_SC);
1762                DO_UNLOCK(flags);
1763
1764                CURRENT_SC = NULL;
1765        }
1766
1767        if(!DISCONNECTED_SC) {
1768                DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1769                return;
1770        }
1771
1772        RECONN_TARGET=-1;
1773
1774        selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1775
1776        if (selid==0) {
1777                printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1778                return;
1779        }
1780
1781        for(target=7; !(selid & (1 << target)); target--)
1782                ;
1783
1784        if(selid & ~(1 << target)) {
1785                printk("aha152x%d: multiple targets reconnected (%02x)\n",
1786                       HOSTNO, selid);
1787        }
1788
1789
1790        SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1791        SETPORT(SCSISEQ, 0);
1792
1793        SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1794
1795        RECONN_TARGET=target;
1796        DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1797}
1798
1799/*
1800 * message in phase
1801 * - handle initial message after reconnection to identify
1802 *   reconnecting nexus
1803 * - queue command on DISCONNECTED_SC on DISCONNECT message
1804 * - set completed flag on COMMAND COMPLETE
1805 *   (other completition code moved to busfree_run)
1806 * - handle response to SDTR
1807 * - clear synchronous transfer agreements on BUS RESET
1808 *
1809 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1810 *
1811 */
1812static void msgi_run(struct Scsi_Host *shpnt)
1813{
1814        for(;;) {
1815                int sstat1 = GETPORT(SSTAT1);
1816
1817                if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1818                        return;
1819
1820                if(TESTLO(SSTAT0,SPIORDY)) {
1821                        DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1822                        return;
1823                }       
1824
1825                ADDMSGI(GETPORT(SCSIDAT));
1826
1827#if defined(AHA152X_DEBUG)
1828                if (HOSTDATA(shpnt)->debug & debug_msgi) {
1829                        printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1830                        spi_print_msg(&MSGI(0));
1831                        printk("\n");
1832                }
1833#endif
1834
1835                if(!CURRENT_SC) {
1836                        if(LASTSTATE!=seldi) {
1837                                printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1838                        }
1839
1840                        /*
1841                         * Handle reselection
1842                         */
1843                        if(!(MSGI(0) & IDENTIFY_BASE)) {
1844                                printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1845                                continue;
1846                        }
1847
1848                        CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1849
1850                        if (!CURRENT_SC) {
1851                                show_queues(shpnt);
1852                                printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1853                                continue;
1854                        }
1855
1856                        DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1857
1858                        CURRENT_SC->SCp.Message = MSGI(0);
1859                        CURRENT_SC->SCp.phase &= ~disconnected;
1860
1861                        MSGILEN=0;
1862
1863                        /* next message if any */
1864                        continue;
1865                } 
1866
1867                CURRENT_SC->SCp.Message = MSGI(0);
1868
1869                switch (MSGI(0)) {
1870                case DISCONNECT:
1871                        if (!RECONNECT)
1872                                printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1873
1874                        CURRENT_SC->SCp.phase |= disconnected;
1875                        break;
1876
1877                case COMMAND_COMPLETE:
1878                        if(CURRENT_SC->SCp.phase & completed)
1879                                DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1880
1881                        CURRENT_SC->SCp.phase |= completed;
1882                        break;
1883
1884                case MESSAGE_REJECT:
1885                        if (SYNCNEG==1) {
1886                                printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1887                                SYNCNEG=2;      /* negotiation completed */
1888                        } else
1889                                printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1890                        break;
1891
1892                case SAVE_POINTERS:
1893                        break;
1894
1895                case RESTORE_POINTERS:
1896                        break;
1897
1898                case EXTENDED_MESSAGE:
1899                        if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1900                                /* not yet completed */
1901                                continue;
1902                        }
1903
1904                        switch (MSGI(2)) {
1905                        case EXTENDED_SDTR:
1906                                {
1907                                        long ticks;
1908
1909                                        if (MSGI(1) != 3) {
1910                                                printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1911                                                break;
1912                                        }
1913
1914                                        if (!HOSTDATA(shpnt)->synchronous)
1915                                                break;
1916
1917                                        printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1918                                        spi_print_msg(&MSGI(0));
1919                                        printk("\n");
1920
1921                                        ticks = (MSGI(3) * 4 + 49) / 50;
1922
1923                                        if (syncneg) {
1924                                                /* negotiation in progress */
1925                                                if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1926                                                        ADDMSGO(MESSAGE_REJECT);
1927                                                        printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1928                                                        break;
1929                                                }
1930                                                
1931                                                SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1932                                        } else if (ticks <= 9 && MSGI(4) >= 1) {
1933                                                ADDMSGO(EXTENDED_MESSAGE);
1934                                                ADDMSGO(3);
1935                                                ADDMSGO(EXTENDED_SDTR);
1936                                                if (ticks < 4) {
1937                                                        ticks = 4;
1938                                                        ADDMSGO(50);
1939                                                } else
1940                                                        ADDMSGO(MSGI(3));
1941
1942                                                if (MSGI(4) > 8)
1943                                                        MSGI(4) = 8;
1944
1945                                                ADDMSGO(MSGI(4));
1946
1947                                                SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1948                                        } else {
1949                                                /* requested SDTR is too slow, do it asynchronously */
1950                                                printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1951                                                ADDMSGO(MESSAGE_REJECT);
1952                                        }
1953
1954                                        SYNCNEG=2;              /* negotiation completed */
1955                                        SETRATE(SYNCRATE);
1956                                }
1957                                break;
1958
1959                        case BUS_DEVICE_RESET:
1960                                {
1961                                        int i;
1962
1963                                        for(i=0; i<8; i++) {
1964                                                HOSTDATA(shpnt)->syncrate[i]=0;
1965                                                HOSTDATA(shpnt)->syncneg[i]=0;
1966                                        }
1967
1968                                }
1969                                break;
1970
1971                        case EXTENDED_MODIFY_DATA_POINTER:
1972                        case EXTENDED_EXTENDED_IDENTIFY:
1973                        case EXTENDED_WDTR:
1974                        default:
1975                                ADDMSGO(MESSAGE_REJECT);
1976                                break;
1977                        }
1978                        break;
1979                }
1980
1981                MSGILEN=0;
1982        }
1983}
1984
1985static void msgi_end(struct Scsi_Host *shpnt)
1986{
1987        if(MSGILEN>0)
1988                printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
1989
1990        if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
1991                DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
1992                SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1993        } 
1994}
1995
1996/*
1997 * message out phase
1998 *
1999 */
2000static void msgo_init(struct Scsi_Host *shpnt)
2001{
2002        if(MSGOLEN==0) {
2003                if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2004                        ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2005                } else {
2006                        printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2007                        ADDMSGO(MESSAGE_REJECT);
2008                }
2009        }
2010
2011#if defined(AHA152X_DEBUG)
2012        if(HOSTDATA(shpnt)->debug & debug_msgo) {
2013                int i;
2014
2015                printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2016                for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2017                        ;
2018                printk(")\n");
2019        }
2020#endif
2021}
2022
2023/*
2024 * message out phase
2025 *
2026 */
2027static void msgo_run(struct Scsi_Host *shpnt)
2028{
2029        if(MSGO_I==MSGOLEN)
2030                DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2031
2032        while(MSGO_I<MSGOLEN) {
2033                DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2034
2035                if(TESTLO(SSTAT0, SPIORDY)) {
2036                        DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2037                        return;
2038                }
2039
2040                if (MSGO_I==MSGOLEN-1) {
2041                        /* Leave MESSAGE OUT after transfer */
2042                        SETPORT(SSTAT1, CLRATNO);
2043                }
2044
2045
2046                if (MSGO(MSGO_I) & IDENTIFY_BASE)
2047                        CURRENT_SC->SCp.phase |= identified;
2048
2049                if (MSGO(MSGO_I)==ABORT)
2050                        CURRENT_SC->SCp.phase |= aborted;
2051
2052                if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2053                        CURRENT_SC->SCp.phase |= resetted;
2054
2055                SETPORT(SCSIDAT, MSGO(MSGO_I++));
2056        }
2057}
2058
2059static void msgo_end(struct Scsi_Host *shpnt)
2060{
2061        if(MSGO_I<MSGOLEN) {
2062                printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2063                if(SYNCNEG==1) {
2064                        printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2065                        SYNCNEG=2;
2066                }
2067        }
2068                
2069        MSGO_I  = 0;
2070        MSGOLEN = 0;
2071}
2072
2073/* 
2074 * command phase
2075 *
2076 */
2077static void cmd_init(struct Scsi_Host *shpnt)
2078{
2079        if (CURRENT_SC->SCp.sent_command) {
2080                printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2081                done(shpnt, DID_ERROR << 16);
2082                return;
2083        }
2084
2085#if defined(AHA152X_DEBUG)
2086        if (HOSTDATA(shpnt)->debug & debug_cmd) {
2087                printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2088                __scsi_print_command(CURRENT_SC->cmnd);
2089        }
2090#endif
2091
2092        CMD_I=0;
2093}
2094
2095/*
2096 * command phase
2097 *
2098 */
2099static void cmd_run(struct Scsi_Host *shpnt)
2100{
2101        if(CMD_I==CURRENT_SC->cmd_len) {
2102                DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2103                disp_ports(shpnt);
2104        }
2105
2106        while(CMD_I<CURRENT_SC->cmd_len) {
2107                DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len);
2108
2109                if(TESTLO(SSTAT0, SPIORDY)) {
2110                        DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2111                        return;
2112                }
2113
2114                SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2115        }
2116}
2117
2118static void cmd_end(struct Scsi_Host *shpnt)
2119{
2120        if(CMD_I<CURRENT_SC->cmd_len)
2121                printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2122        else
2123                CURRENT_SC->SCp.sent_command++;
2124}
2125
2126/*
2127 * status phase
2128 *
2129 */
2130static void status_run(struct Scsi_Host *shpnt)
2131{
2132        if(TESTLO(SSTAT0,SPIORDY)) {
2133                DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2134                return;
2135        }
2136
2137        CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2138
2139#if defined(AHA152X_DEBUG)
2140        if (HOSTDATA(shpnt)->debug & debug_status) {
2141                printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2142                scsi_print_status(CURRENT_SC->SCp.Status);
2143                printk("\n");
2144        }
2145#endif
2146}
2147
2148/*
2149 * data in phase
2150 *
2151 */
2152static void datai_init(struct Scsi_Host *shpnt)
2153{
2154        SETPORT(DMACNTRL0, RSTFIFO);
2155        SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2156
2157        SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2158        SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2159
2160        SETPORT(SIMODE0, 0);
2161        SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2162
2163        DATA_LEN=0;
2164        DPRINTK(debug_datai,
2165                DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2166                CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2167                scsi_get_resid(CURRENT_SC));
2168}
2169
2170static void datai_run(struct Scsi_Host *shpnt)
2171{
2172        unsigned long the_time;
2173        int fifodata, data_count;
2174
2175        /*
2176         * loop while the phase persists or the fifos are not empty
2177         *
2178         */
2179        while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2180                /* FIXME: maybe this should be done by setting up
2181                 * STCNT to trigger ENSWRAP interrupt, instead of
2182                 * polling for DFIFOFULL
2183                 */
2184                the_time=jiffies + 100*HZ;
2185                while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2186                        barrier();
2187
2188                if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2189                        printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2190                        disp_ports(shpnt);
2191                        break;
2192                }
2193
2194                if(TESTHI(DMASTAT, DFIFOFULL)) {
2195                        fifodata = 128;
2196                } else {
2197                        the_time=jiffies + 100*HZ;
2198                        while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2199                                barrier();
2200
2201                        if(TESTLO(SSTAT2, SEMPTY)) {
2202                                printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2203                                disp_ports(shpnt);
2204                                break;
2205                        }
2206
2207                        fifodata = GETPORT(FIFOSTAT);
2208                }
2209
2210                if(CURRENT_SC->SCp.this_residual>0) {
2211                        while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2212                                data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2213                                                CURRENT_SC->SCp.this_residual :
2214                                                fifodata;
2215                                fifodata -= data_count;
2216
2217                                if(data_count & 1) {
2218                                        DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2219                                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
2220                                        *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2221                                        CURRENT_SC->SCp.this_residual--;
2222                                        DATA_LEN++;
2223                                        SETPORT(DMACNTRL0, ENDMA);
2224                                }
2225        
2226                                if(data_count > 1) {
2227                                        DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2228                                        data_count >>= 1;
2229                                        insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2230                                        CURRENT_SC->SCp.ptr           += 2 * data_count;
2231                                        CURRENT_SC->SCp.this_residual -= 2 * data_count;
2232                                        DATA_LEN                      += 2 * data_count;
2233                                }
2234        
2235                                if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2236                                        /* advance to next buffer */
2237                                        CURRENT_SC->SCp.buffers_residual--;
2238                                        CURRENT_SC->SCp.buffer++;
2239                                        CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2240                                        CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2241                                } 
2242                        }
2243                } else if(fifodata>0) { 
2244                        printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2245                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
2246                        while(fifodata>0) {
2247                                int data;
2248                                data=GETPORT(DATAPORT);
2249                                DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2250                                fifodata--;
2251                                DATA_LEN++;
2252                        }
2253                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
2254                }
2255        }
2256
2257        if(TESTLO(DMASTAT, INTSTAT) ||
2258           TESTLO(DMASTAT, DFIFOEMP) ||
2259           TESTLO(SSTAT2, SEMPTY) ||
2260           GETPORT(FIFOSTAT)>0) {
2261                /*
2262                 * something went wrong, if there's something left in the fifos
2263                 * or the phase didn't change
2264                 */
2265                printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2266                disp_ports(shpnt);
2267        }
2268
2269        if(DATA_LEN!=GETSTCNT()) {
2270                printk(ERR_LEAD
2271                       "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2272                       CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2273                disp_ports(shpnt);
2274                mdelay(10000);
2275        }
2276}
2277
2278static void datai_end(struct Scsi_Host *shpnt)
2279{
2280        CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2281
2282        DPRINTK(debug_datai,
2283                DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2284                CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2285                scsi_get_resid(CURRENT_SC), GETSTCNT());
2286
2287        SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2288        SETPORT(DMACNTRL0, 0);
2289}
2290
2291/*
2292 * data out phase
2293 *
2294 */
2295static void datao_init(struct Scsi_Host *shpnt)
2296{
2297        SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2298        SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2299
2300        SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2301        SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2302
2303        SETPORT(SIMODE0, 0);
2304        SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2305
2306        DATA_LEN = scsi_get_resid(CURRENT_SC);
2307
2308        DPRINTK(debug_datao,
2309                DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2310                CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2311                scsi_get_resid(CURRENT_SC));
2312}
2313
2314static void datao_run(struct Scsi_Host *shpnt)
2315{
2316        unsigned long the_time;
2317        int data_count;
2318
2319        /* until phase changes or all data sent */
2320        while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2321                data_count = 128;
2322                if(data_count > CURRENT_SC->SCp.this_residual)
2323                        data_count=CURRENT_SC->SCp.this_residual;
2324
2325                if(TESTLO(DMASTAT, DFIFOEMP)) {
2326                        printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2327                        disp_ports(shpnt);
2328                        break;
2329                }
2330
2331                if(data_count & 1) {
2332                        SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2333                        SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2334                        CURRENT_SC->SCp.this_residual--;
2335                        CMD_INC_RESID(CURRENT_SC, -1);
2336                        SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2337                }
2338
2339                if(data_count > 1) {
2340                        data_count >>= 1;
2341                        outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2342                        CURRENT_SC->SCp.ptr           += 2 * data_count;
2343                        CURRENT_SC->SCp.this_residual -= 2 * data_count;
2344                        CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2345                }
2346
2347                if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2348                        /* advance to next buffer */
2349                        CURRENT_SC->SCp.buffers_residual--;
2350                        CURRENT_SC->SCp.buffer++;
2351                        CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2352                        CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2353                }
2354
2355                the_time=jiffies + 100*HZ;
2356                while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2357                        barrier();
2358
2359                if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2360                        printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2361                        disp_ports(shpnt);
2362                        break;
2363                }
2364        }
2365}
2366
2367static void datao_end(struct Scsi_Host *shpnt)
2368{
2369        if(TESTLO(DMASTAT, DFIFOEMP)) {
2370                int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2371                                                                    GETSTCNT();
2372
2373                DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2374                        CMDINFO(CURRENT_SC),
2375                        data_count,
2376                        DATA_LEN - scsi_get_resid(CURRENT_SC),
2377                        GETSTCNT());
2378
2379                CMD_INC_RESID(CURRENT_SC, data_count);
2380
2381                data_count -= CURRENT_SC->SCp.ptr -
2382                                             SG_ADDRESS(CURRENT_SC->SCp.buffer);
2383                while(data_count>0) {
2384                        CURRENT_SC->SCp.buffer--;
2385                        CURRENT_SC->SCp.buffers_residual++;
2386                        data_count -= CURRENT_SC->SCp.buffer->length;
2387                }
2388                CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2389                                                                     data_count;
2390                CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2391                                                                     data_count;
2392        }
2393
2394        DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2395                CMDINFO(CURRENT_SC),
2396                scsi_bufflen(CURRENT_SC),
2397                scsi_get_resid(CURRENT_SC),
2398                GETSTCNT());
2399
2400        SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2401        SETPORT(SXFRCTL0, CH1);
2402
2403        SETPORT(DMACNTRL0, 0);
2404}
2405
2406/*
2407 * figure out what state we're in
2408 *
2409 */
2410static int update_state(struct Scsi_Host *shpnt)
2411{
2412        int dataphase=0;
2413        unsigned int stat0 = GETPORT(SSTAT0);
2414        unsigned int stat1 = GETPORT(SSTAT1);
2415
2416        PREVSTATE = STATE;
2417        STATE=unknown;
2418
2419        if(stat1 & SCSIRSTI) {
2420                STATE=rsti;
2421                SETPORT(SCSISEQ,0);
2422                SETPORT(SSTAT1,SCSIRSTI);
2423        } else if(stat0 & SELDI && PREVSTATE==busfree) {
2424                STATE=seldi;
2425        } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2426                STATE=seldo;
2427        } else if(stat1 & SELTO) {
2428                STATE=selto;
2429        } else if(stat1 & BUSFREE) {
2430                STATE=busfree;
2431                SETPORT(SSTAT1,BUSFREE);
2432        } else if(stat1 & SCSIPERR) {
2433                STATE=parerr;
2434                SETPORT(SSTAT1,SCSIPERR);
2435        } else if(stat1 & REQINIT) {
2436                switch(GETPORT(SCSISIG) & P_MASK) {
2437                case P_MSGI:    STATE=msgi;     break;
2438                case P_MSGO:    STATE=msgo;     break;
2439                case P_DATAO:   STATE=datao;    break;
2440                case P_DATAI:   STATE=datai;    break;
2441                case P_STATUS:  STATE=status;   break;
2442                case P_CMD:     STATE=cmd;      break;
2443                }
2444                dataphase=1;
2445        }
2446
2447        if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2448                printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2449                disp_ports(shpnt);
2450        }
2451
2452        if(STATE!=PREVSTATE) {
2453                LASTSTATE=PREVSTATE;
2454        }
2455
2456        return dataphase;
2457}
2458
2459/*
2460 * handle parity error
2461 *
2462 * FIXME: in which phase?
2463 *
2464 */
2465static void parerr_run(struct Scsi_Host *shpnt)
2466{
2467        printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2468        done(shpnt, DID_PARITY << 16);
2469}
2470
2471/*
2472 * handle reset in
2473 *
2474 */
2475static void rsti_run(struct Scsi_Host *shpnt)
2476{
2477        Scsi_Cmnd *ptr;
2478
2479        printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2480        
2481        ptr=DISCONNECTED_SC;
2482        while(ptr) {
2483                Scsi_Cmnd *next = SCNEXT(ptr);
2484
2485                if (!ptr->device->soft_reset) {
2486                        remove_SC(&DISCONNECTED_SC, ptr);
2487
2488                        kfree(ptr->host_scribble);
2489                        ptr->host_scribble=NULL;
2490
2491                        ptr->result =  DID_RESET << 16;
2492                        ptr->scsi_done(ptr);
2493                }
2494
2495                ptr = next;
2496        }
2497
2498        if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2499                done(shpnt, DID_RESET << 16 );
2500}
2501
2502
2503/*
2504 * bottom-half handler
2505 *
2506 */
2507static void is_complete(struct Scsi_Host *shpnt)
2508{
2509        int dataphase;
2510        unsigned long flags;
2511        int pending;
2512
2513        if(!shpnt)
2514                return;
2515
2516        DO_LOCK(flags);
2517
2518        if( HOSTDATA(shpnt)->service==0 )  {
2519                DO_UNLOCK(flags);
2520                return;
2521        }
2522
2523        HOSTDATA(shpnt)->service = 0;
2524
2525        if(HOSTDATA(shpnt)->in_intr) {
2526                DO_UNLOCK(flags);
2527                /* aha152x_error never returns.. */
2528                aha152x_error(shpnt, "bottom-half already running!?");
2529        }
2530        HOSTDATA(shpnt)->in_intr++;
2531
2532        /*
2533         * loop while there are interrupt conditions pending
2534         *
2535         */
2536        do {
2537                unsigned long start = jiffies;
2538                DO_UNLOCK(flags);
2539
2540                dataphase=update_state(shpnt);
2541
2542                DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2543
2544                /*
2545                 * end previous state
2546                 *
2547                 */
2548                if(PREVSTATE!=STATE && states[PREVSTATE].end)
2549                        states[PREVSTATE].end(shpnt);
2550
2551                /*
2552                 * disable SPIO mode if previous phase used it
2553                 * and this one doesn't
2554                 *
2555                 */
2556                if(states[PREVSTATE].spio && !states[STATE].spio) {
2557                        SETPORT(SXFRCTL0, CH1);
2558                        SETPORT(DMACNTRL0, 0);
2559                        if(CURRENT_SC)
2560                                CURRENT_SC->SCp.phase &= ~spiordy;
2561                }
2562
2563                /*
2564                 * accept current dataphase phase
2565                 *
2566                 */
2567                if(dataphase) {
2568                        SETPORT(SSTAT0, REQINIT);
2569                        SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2570                        SETPORT(SSTAT1, PHASECHG);  
2571                }
2572                
2573                /*
2574                 * enable SPIO mode if previous didn't use it
2575                 * and this one does
2576                 *
2577                 */
2578                if(!states[PREVSTATE].spio && states[STATE].spio) {
2579                        SETPORT(DMACNTRL0, 0);
2580                        SETPORT(SXFRCTL0, CH1|SPIOEN);
2581                        if(CURRENT_SC)
2582                                CURRENT_SC->SCp.phase |= spiordy;
2583                }
2584                
2585                /*
2586                 * initialize for new state
2587                 *
2588                 */
2589                if(PREVSTATE!=STATE && states[STATE].init)
2590                        states[STATE].init(shpnt);
2591                
2592                /*
2593                 * handle current state
2594                 *
2595                 */
2596                if(states[STATE].run)
2597                        states[STATE].run(shpnt);
2598                else
2599                        printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2600                
2601                /*
2602                 * setup controller to interrupt on
2603                 * the next expected condition and
2604                 * loop if it's already there
2605                 *
2606                 */
2607                DO_LOCK(flags);
2608                pending=setup_expected_interrupts(shpnt);
2609#if defined(AHA152X_STAT)
2610                HOSTDATA(shpnt)->count[STATE]++;
2611                if(PREVSTATE!=STATE)
2612                        HOSTDATA(shpnt)->count_trans[STATE]++;
2613                HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2614#endif
2615
2616                DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2617        } while(pending);
2618
2619        /*
2620         * enable interrupts and leave bottom-half
2621         *
2622         */
2623        HOSTDATA(shpnt)->in_intr--;
2624        SETBITS(DMACNTRL0, INTEN);
2625        DO_UNLOCK(flags);
2626}
2627
2628
2629/* 
2630 * Dump the current driver status and panic
2631 */
2632static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2633{
2634        printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2635        show_queues(shpnt);
2636        panic("aha152x panic\n");
2637}
2638
2639/*
2640 * Display registers of AIC-6260
2641 */
2642static void disp_ports(struct Scsi_Host *shpnt)
2643{
2644#if defined(AHA152X_DEBUG)
2645        int s;
2646
2647        printk("\n%s: %s(%s) ",
2648                CURRENT_SC ? "busy" : "waiting",
2649                states[STATE].name,
2650                states[PREVSTATE].name);
2651
2652        s = GETPORT(SCSISEQ);
2653        printk("SCSISEQ( ");
2654        if (s & TEMODEO)
2655                printk("TARGET MODE ");
2656        if (s & ENSELO)
2657                printk("SELO ");
2658        if (s & ENSELI)
2659                printk("SELI ");
2660        if (s & ENRESELI)
2661                printk("RESELI ");
2662        if (s & ENAUTOATNO)
2663                printk("AUTOATNO ");
2664        if (s & ENAUTOATNI)
2665                printk("AUTOATNI ");
2666        if (s & ENAUTOATNP)
2667                printk("AUTOATNP ");
2668        if (s & SCSIRSTO)
2669                printk("SCSIRSTO ");
2670        printk(");");
2671
2672        printk(" SCSISIG(");
2673        s = GETPORT(SCSISIG);
2674        switch (s & P_MASK) {
2675        case P_DATAO:
2676                printk("DATA OUT");
2677                break;
2678        case P_DATAI:
2679                printk("DATA IN");
2680                break;
2681        case P_CMD:
2682                printk("COMMAND");
2683                break;
2684        case P_STATUS:
2685                printk("STATUS");
2686                break;
2687        case P_MSGO:
2688                printk("MESSAGE OUT");
2689                break;
2690        case P_MSGI:
2691                printk("MESSAGE IN");
2692                break;
2693        default:
2694                printk("*invalid*");
2695                break;
2696        }
2697
2698        printk("); ");
2699
2700        printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2701
2702        printk("SSTAT( ");
2703        s = GETPORT(SSTAT0);
2704        if (s & TARGET)
2705                printk("TARGET ");
2706        if (s & SELDO)
2707                printk("SELDO ");
2708        if (s & SELDI)
2709                printk("SELDI ");
2710        if (s & SELINGO)
2711                printk("SELINGO ");
2712        if (s & SWRAP)
2713                printk("SWRAP ");
2714        if (s & SDONE)
2715                printk("SDONE ");
2716        if (s & SPIORDY)
2717                printk("SPIORDY ");
2718        if (s & DMADONE)
2719                printk("DMADONE ");
2720
2721        s = GETPORT(SSTAT1);
2722        if (s & SELTO)
2723                printk("SELTO ");
2724        if (s & ATNTARG)
2725                printk("ATNTARG ");
2726        if (s & SCSIRSTI)
2727                printk("SCSIRSTI ");
2728        if (s & PHASEMIS)
2729                printk("PHASEMIS ");
2730        if (s & BUSFREE)
2731                printk("BUSFREE ");
2732        if (s & SCSIPERR)
2733                printk("SCSIPERR ");
2734        if (s & PHASECHG)
2735                printk("PHASECHG ");
2736        if (s & REQINIT)
2737                printk("REQINIT ");
2738        printk("); ");
2739
2740
2741        printk("SSTAT( ");
2742
2743        s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2744
2745        if (s & TARGET)
2746                printk("TARGET ");
2747        if (s & SELDO)
2748                printk("SELDO ");
2749        if (s & SELDI)
2750                printk("SELDI ");
2751        if (s & SELINGO)
2752                printk("SELINGO ");
2753        if (s & SWRAP)
2754                printk("SWRAP ");
2755        if (s & SDONE)
2756                printk("SDONE ");
2757        if (s & SPIORDY)
2758                printk("SPIORDY ");
2759        if (s & DMADONE)
2760                printk("DMADONE ");
2761
2762        s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2763
2764        if (s & SELTO)
2765                printk("SELTO ");
2766        if (s & ATNTARG)
2767                printk("ATNTARG ");
2768        if (s & SCSIRSTI)
2769                printk("SCSIRSTI ");
2770        if (s & PHASEMIS)
2771                printk("PHASEMIS ");
2772        if (s & BUSFREE)
2773                printk("BUSFREE ");
2774        if (s & SCSIPERR)
2775                printk("SCSIPERR ");
2776        if (s & PHASECHG)
2777                printk("PHASECHG ");
2778        if (s & REQINIT)
2779                printk("REQINIT ");
2780        printk("); ");
2781
2782        printk("SXFRCTL0( ");
2783
2784        s = GETPORT(SXFRCTL0);
2785        if (s & SCSIEN)
2786                printk("SCSIEN ");
2787        if (s & DMAEN)
2788                printk("DMAEN ");
2789        if (s & CH1)
2790                printk("CH1 ");
2791        if (s & CLRSTCNT)
2792                printk("CLRSTCNT ");
2793        if (s & SPIOEN)
2794                printk("SPIOEN ");
2795        if (s & CLRCH1)
2796                printk("CLRCH1 ");
2797        printk("); ");
2798
2799        printk("SIGNAL( ");
2800
2801        s = GETPORT(SCSISIG);
2802        if (s & SIG_ATNI)
2803                printk("ATNI ");
2804        if (s & SIG_SELI)
2805                printk("SELI ");
2806        if (s & SIG_BSYI)
2807                printk("BSYI ");
2808        if (s & SIG_REQI)
2809                printk("REQI ");
2810        if (s & SIG_ACKI)
2811                printk("ACKI ");
2812        printk("); ");
2813
2814        printk("SELID (%02x), ", GETPORT(SELID));
2815
2816        printk("STCNT (%d), ", GETSTCNT());
2817        
2818        printk("SSTAT2( ");
2819
2820        s = GETPORT(SSTAT2);
2821        if (s & SOFFSET)
2822                printk("SOFFSET ");
2823        if (s & SEMPTY)
2824                printk("SEMPTY ");
2825        if (s & SFULL)
2826                printk("SFULL ");
2827        printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2828
2829        s = GETPORT(SSTAT3);
2830        printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2831
2832        printk("SSTAT4( ");
2833        s = GETPORT(SSTAT4);
2834        if (s & SYNCERR)
2835                printk("SYNCERR ");
2836        if (s & FWERR)
2837                printk("FWERR ");
2838        if (s & FRERR)
2839                printk("FRERR ");
2840        printk("); ");
2841
2842        printk("DMACNTRL0( ");
2843        s = GETPORT(DMACNTRL0);
2844        printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2845        printk("%s ", s & DMA ? "DMA" : "PIO");
2846        printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2847        if (s & ENDMA)
2848                printk("ENDMA ");
2849        if (s & INTEN)
2850                printk("INTEN ");
2851        if (s & RSTFIFO)
2852                printk("RSTFIFO ");
2853        if (s & SWINT)
2854                printk("SWINT ");
2855        printk("); ");
2856
2857        printk("DMASTAT( ");
2858        s = GETPORT(DMASTAT);
2859        if (s & ATDONE)
2860                printk("ATDONE ");
2861        if (s & WORDRDY)
2862                printk("WORDRDY ");
2863        if (s & DFIFOFULL)
2864                printk("DFIFOFULL ");
2865        if (s & DFIFOEMP)
2866                printk("DFIFOEMP ");
2867        printk(")\n");
2868#endif
2869}
2870
2871/*
2872 * display enabled interrupts
2873 */
2874static void disp_enintr(struct Scsi_Host *shpnt)
2875{
2876        int s;
2877
2878        printk(KERN_DEBUG "enabled interrupts ( ");
2879
2880        s = GETPORT(SIMODE0);
2881        if (s & ENSELDO)
2882                printk("ENSELDO ");
2883        if (s & ENSELDI)
2884                printk("ENSELDI ");
2885        if (s & ENSELINGO)
2886                printk("ENSELINGO ");
2887        if (s & ENSWRAP)
2888                printk("ENSWRAP ");
2889        if (s & ENSDONE)
2890                printk("ENSDONE ");
2891        if (s & ENSPIORDY)
2892                printk("ENSPIORDY ");
2893        if (s & ENDMADONE)
2894                printk("ENDMADONE ");
2895
2896        s = GETPORT(SIMODE1);
2897        if (s & ENSELTIMO)
2898                printk("ENSELTIMO ");
2899        if (s & ENATNTARG)
2900                printk("ENATNTARG ");
2901        if (s & ENPHASEMIS)
2902                printk("ENPHASEMIS ");
2903        if (s & ENBUSFREE)
2904                printk("ENBUSFREE ");
2905        if (s & ENSCSIPERR)
2906                printk("ENSCSIPERR ");
2907        if (s & ENPHASECHG)
2908                printk("ENPHASECHG ");
2909        if (s & ENREQINIT)
2910                printk("ENREQINIT ");
2911        printk(")\n");
2912}
2913
2914/*
2915 * Show the command data of a command
2916 */
2917static void show_command(Scsi_Cmnd *ptr)
2918{
2919        scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2920
2921        __scsi_print_command(ptr->cmnd);
2922
2923        printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2924               scsi_bufflen(ptr), scsi_get_resid(ptr));
2925
2926        if (ptr->SCp.phase & not_issued)
2927                printk("not issued|");
2928        if (ptr->SCp.phase & selecting)
2929                printk("selecting|");
2930        if (ptr->SCp.phase & identified)
2931                printk("identified|");
2932        if (ptr->SCp.phase & disconnected)
2933                printk("disconnected|");
2934        if (ptr->SCp.phase & completed)
2935                printk("completed|");
2936        if (ptr->SCp.phase & spiordy)
2937                printk("spiordy|");
2938        if (ptr->SCp.phase & syncneg)
2939                printk("syncneg|");
2940        if (ptr->SCp.phase & aborted)
2941                printk("aborted|");
2942        if (ptr->SCp.phase & resetted)
2943                printk("resetted|");
2944        if( SCDATA(ptr) ) {
2945                printk("; next=0x%p\n", SCNEXT(ptr));
2946        } else {
2947                printk("; next=(host scribble NULL)\n");
2948        }
2949}
2950
2951/*
2952 * Dump the queued data
2953 */
2954static void show_queues(struct Scsi_Host *shpnt)
2955{
2956        Scsi_Cmnd *ptr;
2957        unsigned long flags;
2958
2959        DO_LOCK(flags);
2960        printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2961        for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2962                show_command(ptr);
2963        DO_UNLOCK(flags);
2964
2965        printk(KERN_DEBUG "current_SC:\n");
2966        if (CURRENT_SC)
2967                show_command(CURRENT_SC);
2968        else
2969                printk(KERN_DEBUG "none\n");
2970
2971        printk(KERN_DEBUG "disconnected_SC:\n");
2972        for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2973                show_command(ptr);
2974
2975        disp_ports(shpnt);
2976        disp_enintr(shpnt);
2977}
2978
2979#undef SPRINTF
2980#define SPRINTF(args...) pos += sprintf(pos, ## args)
2981
2982static int get_command(char *pos, Scsi_Cmnd * ptr)
2983{
2984        char *start = pos;
2985        int i;
2986
2987        SPRINTF("%p: target=%d; lun=%d; cmnd=( ",
2988                ptr, ptr->device->id, ptr->device->lun);
2989
2990        for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2991                SPRINTF("0x%02x ", ptr->cmnd[i]);
2992
2993        SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2994                scsi_get_resid(ptr), ptr->SCp.this_residual,
2995                ptr->SCp.buffers_residual);
2996
2997        if (ptr->SCp.phase & not_issued)
2998                SPRINTF("not issued|");
2999        if (ptr->SCp.phase & selecting)
3000                SPRINTF("selecting|");
3001        if (ptr->SCp.phase & disconnected)
3002                SPRINTF("disconnected|");
3003        if (ptr->SCp.phase & aborted)
3004                SPRINTF("aborted|");
3005        if (ptr->SCp.phase & identified)
3006                SPRINTF("identified|");
3007        if (ptr->SCp.phase & completed)
3008                SPRINTF("completed|");
3009        if (ptr->SCp.phase & spiordy)
3010                SPRINTF("spiordy|");
3011        if (ptr->SCp.phase & syncneg)
3012                SPRINTF("syncneg|");
3013        SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3014
3015        return (pos - start);
3016}
3017
3018static int get_ports(struct Scsi_Host *shpnt, char *pos)
3019{
3020        char *start = pos;
3021        int s;
3022
3023        SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3024
3025        s = GETPORT(SCSISEQ);
3026        SPRINTF("SCSISEQ( ");
3027        if (s & TEMODEO)
3028                SPRINTF("TARGET MODE ");
3029        if (s & ENSELO)
3030                SPRINTF("SELO ");
3031        if (s & ENSELI)
3032                SPRINTF("SELI ");
3033        if (s & ENRESELI)
3034                SPRINTF("RESELI ");
3035        if (s & ENAUTOATNO)
3036                SPRINTF("AUTOATNO ");
3037        if (s & ENAUTOATNI)
3038                SPRINTF("AUTOATNI ");
3039        if (s & ENAUTOATNP)
3040                SPRINTF("AUTOATNP ");
3041        if (s & SCSIRSTO)
3042                SPRINTF("SCSIRSTO ");
3043        SPRINTF(");");
3044
3045        SPRINTF(" SCSISIG(");
3046        s = GETPORT(SCSISIG);
3047        switch (s & P_MASK) {
3048        case P_DATAO:
3049                SPRINTF("DATA OUT");
3050                break;
3051        case P_DATAI:
3052                SPRINTF("DATA IN");
3053                break;
3054        case P_CMD:
3055                SPRINTF("COMMAND");
3056                break;
3057        case P_STATUS:
3058                SPRINTF("STATUS");
3059                break;
3060        case P_MSGO:
3061                SPRINTF("MESSAGE OUT");
3062                break;
3063        case P_MSGI:
3064                SPRINTF("MESSAGE IN");
3065                break;
3066        default:
3067                SPRINTF("*invalid*");
3068                break;
3069        }
3070
3071        SPRINTF("); ");
3072
3073        SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3074
3075        SPRINTF("SSTAT( ");
3076        s = GETPORT(SSTAT0);
3077        if (s & TARGET)
3078                SPRINTF("TARGET ");
3079        if (s & SELDO)
3080                SPRINTF("SELDO ");
3081        if (s & SELDI)
3082                SPRINTF("SELDI ");
3083        if (s & SELINGO)
3084                SPRINTF("SELINGO ");
3085        if (s & SWRAP)
3086                SPRINTF("SWRAP ");
3087        if (s & SDONE)
3088                SPRINTF("SDONE ");
3089        if (s & SPIORDY)
3090                SPRINTF("SPIORDY ");
3091        if (s & DMADONE)
3092                SPRINTF("DMADONE ");
3093
3094        s = GETPORT(SSTAT1);
3095        if (s & SELTO)
3096                SPRINTF("SELTO ");
3097        if (s & ATNTARG)
3098                SPRINTF("ATNTARG ");
3099        if (s & SCSIRSTI)
3100                SPRINTF("SCSIRSTI ");
3101        if (s & PHASEMIS)
3102                SPRINTF("PHASEMIS ");
3103        if (s & BUSFREE)
3104                SPRINTF("BUSFREE ");
3105        if (s & SCSIPERR)
3106                SPRINTF("SCSIPERR ");
3107        if (s & PHASECHG)
3108                SPRINTF("PHASECHG ");
3109        if (s & REQINIT)
3110                SPRINTF("REQINIT ");
3111        SPRINTF("); ");
3112
3113
3114        SPRINTF("SSTAT( ");
3115
3116        s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3117
3118        if (s & TARGET)
3119                SPRINTF("TARGET ");
3120        if (s & SELDO)
3121                SPRINTF("SELDO ");
3122        if (s & SELDI)
3123                SPRINTF("SELDI ");
3124        if (s & SELINGO)
3125                SPRINTF("SELINGO ");
3126        if (s & SWRAP)
3127                SPRINTF("SWRAP ");
3128        if (s & SDONE)
3129                SPRINTF("SDONE ");
3130        if (s & SPIORDY)
3131                SPRINTF("SPIORDY ");
3132        if (s & DMADONE)
3133                SPRINTF("DMADONE ");
3134
3135        s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3136
3137        if (s & SELTO)
3138                SPRINTF("SELTO ");
3139        if (s & ATNTARG)
3140                SPRINTF("ATNTARG ");
3141        if (s & SCSIRSTI)
3142                SPRINTF("SCSIRSTI ");
3143        if (s & PHASEMIS)
3144                SPRINTF("PHASEMIS ");
3145        if (s & BUSFREE)
3146                SPRINTF("BUSFREE ");
3147        if (s & SCSIPERR)
3148                SPRINTF("SCSIPERR ");
3149        if (s & PHASECHG)
3150                SPRINTF("PHASECHG ");
3151        if (s & REQINIT)
3152                SPRINTF("REQINIT ");
3153        SPRINTF("); ");
3154
3155        SPRINTF("SXFRCTL0( ");
3156
3157        s = GETPORT(SXFRCTL0);
3158        if (s & SCSIEN)
3159                SPRINTF("SCSIEN ");
3160        if (s & DMAEN)
3161                SPRINTF("DMAEN ");
3162        if (s & CH1)
3163                SPRINTF("CH1 ");
3164        if (s & CLRSTCNT)
3165                SPRINTF("CLRSTCNT ");
3166        if (s & SPIOEN)
3167                SPRINTF("SPIOEN ");
3168        if (s & CLRCH1)
3169                SPRINTF("CLRCH1 ");
3170        SPRINTF("); ");
3171
3172        SPRINTF("SIGNAL( ");
3173
3174        s = GETPORT(SCSISIG);
3175        if (s & SIG_ATNI)
3176                SPRINTF("ATNI ");
3177        if (s & SIG_SELI)
3178                SPRINTF("SELI ");
3179        if (s & SIG_BSYI)
3180                SPRINTF("BSYI ");
3181        if (s & SIG_REQI)
3182                SPRINTF("REQI ");
3183        if (s & SIG_ACKI)
3184                SPRINTF("ACKI ");
3185        SPRINTF("); ");
3186
3187        SPRINTF("SELID(%02x), ", GETPORT(SELID));
3188
3189        SPRINTF("STCNT(%d), ", GETSTCNT());
3190
3191        SPRINTF("SSTAT2( ");
3192
3193        s = GETPORT(SSTAT2);
3194        if (s & SOFFSET)
3195                SPRINTF("SOFFSET ");
3196        if (s & SEMPTY)
3197                SPRINTF("SEMPTY ");
3198        if (s & SFULL)
3199                SPRINTF("SFULL ");
3200        SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3201
3202        s = GETPORT(SSTAT3);
3203        SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3204
3205        SPRINTF("SSTAT4( ");
3206        s = GETPORT(SSTAT4);
3207        if (s & SYNCERR)
3208                SPRINTF("SYNCERR ");
3209        if (s & FWERR)
3210                SPRINTF("FWERR ");
3211        if (s & FRERR)
3212                SPRINTF("FRERR ");
3213        SPRINTF("); ");
3214
3215        SPRINTF("DMACNTRL0( ");
3216        s = GETPORT(DMACNTRL0);
3217        SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3218        SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3219        SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3220        if (s & ENDMA)
3221                SPRINTF("ENDMA ");
3222        if (s & INTEN)
3223                SPRINTF("INTEN ");
3224        if (s & RSTFIFO)
3225                SPRINTF("RSTFIFO ");
3226        if (s & SWINT)
3227                SPRINTF("SWINT ");
3228        SPRINTF("); ");
3229
3230        SPRINTF("DMASTAT( ");
3231        s = GETPORT(DMASTAT);
3232        if (s & ATDONE)
3233                SPRINTF("ATDONE ");
3234        if (s & WORDRDY)
3235                SPRINTF("WORDRDY ");
3236        if (s & DFIFOFULL)
3237                SPRINTF("DFIFOFULL ");
3238        if (s & DFIFOEMP)
3239                SPRINTF("DFIFOEMP ");
3240        SPRINTF(")\n");
3241
3242        SPRINTF("enabled interrupts( ");
3243
3244        s = GETPORT(SIMODE0);
3245        if (s & ENSELDO)
3246                SPRINTF("ENSELDO ");
3247        if (s & ENSELDI)
3248                SPRINTF("ENSELDI ");
3249        if (s & ENSELINGO)
3250                SPRINTF("ENSELINGO ");
3251        if (s & ENSWRAP)
3252                SPRINTF("ENSWRAP ");
3253        if (s & ENSDONE)
3254                SPRINTF("ENSDONE ");
3255        if (s & ENSPIORDY)
3256                SPRINTF("ENSPIORDY ");
3257        if (s & ENDMADONE)
3258                SPRINTF("ENDMADONE ");
3259
3260        s = GETPORT(SIMODE1);
3261        if (s & ENSELTIMO)
3262                SPRINTF("ENSELTIMO ");
3263        if (s & ENATNTARG)
3264                SPRINTF("ENATNTARG ");
3265        if (s & ENPHASEMIS)
3266                SPRINTF("ENPHASEMIS ");
3267        if (s & ENBUSFREE)
3268                SPRINTF("ENBUSFREE ");
3269        if (s & ENSCSIPERR)
3270                SPRINTF("ENSCSIPERR ");
3271        if (s & ENPHASECHG)
3272                SPRINTF("ENPHASECHG ");
3273        if (s & ENREQINIT)
3274                SPRINTF("ENREQINIT ");
3275        SPRINTF(")\n");
3276
3277        return (pos - start);
3278}
3279
3280static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3281{
3282        if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3283                return -EINVAL;
3284
3285#if defined(AHA152X_DEBUG)
3286        if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3287                int debug = HOSTDATA(shpnt)->debug;
3288
3289                HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3290
3291                printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3292        } else
3293#endif
3294#if defined(AHA152X_STAT)
3295        if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3296                int i;
3297
3298                HOSTDATA(shpnt)->total_commands=0;
3299                HOSTDATA(shpnt)->disconnections=0;
3300                HOSTDATA(shpnt)->busfree_without_any_action=0;
3301                HOSTDATA(shpnt)->busfree_without_old_command=0;
3302                HOSTDATA(shpnt)->busfree_without_new_command=0;
3303                HOSTDATA(shpnt)->busfree_without_done_command=0;
3304                HOSTDATA(shpnt)->busfree_with_check_condition=0;
3305                for (i = idle; i<maxstate; i++) {
3306                        HOSTDATA(shpnt)->count[i]=0;
3307                        HOSTDATA(shpnt)->count_trans[i]=0;
3308                        HOSTDATA(shpnt)->time[i]=0;
3309                }
3310
3311                printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3312
3313        } else
3314#endif
3315        {
3316                return -EINVAL;
3317        }
3318
3319
3320        return length;
3321}
3322
3323#undef SPRINTF
3324#define SPRINTF(args...) \
3325        do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3326
3327static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3328                      off_t offset, int length, int inout)
3329{
3330        int i;
3331        char *pos = buffer;
3332        Scsi_Cmnd *ptr;
3333        unsigned long flags;
3334        int thislength;
3335
3336        DPRINTK(debug_procinfo, 
3337               KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3338               buffer, offset, length, shpnt->host_no, inout);
3339
3340
3341        if (inout)
3342                return aha152x_set_info(buffer, length, shpnt);
3343
3344        SPRINTF(AHA152X_REVID "\n");
3345
3346        SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3347                shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3348        SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3349        SPRINTF("disconnection/reconnection %s\n",
3350                RECONNECT ? "enabled" : "disabled");
3351        SPRINTF("parity checking %s\n",
3352                PARITY ? "enabled" : "disabled");
3353        SPRINTF("synchronous transfers %s\n",
3354                SYNCHRONOUS ? "enabled" : "disabled");
3355        SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3356
3357        if(SYNCHRONOUS) {
3358                SPRINTF("synchronously operating targets (tick=50 ns):\n");
3359                for (i = 0; i < 8; i++)
3360                        if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3361                                SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3362                                        i,
3363                                        (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3364                                        (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3365                                    HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3366        }
3367#if defined(AHA152X_DEBUG)
3368#define PDEBUG(flags,txt) \
3369        if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3370
3371        SPRINTF("enabled debugging options: ");
3372
3373        PDEBUG(debug_procinfo, "procinfo");
3374        PDEBUG(debug_queue, "queue");
3375        PDEBUG(debug_intr, "interrupt");
3376        PDEBUG(debug_selection, "selection");
3377        PDEBUG(debug_msgo, "message out");
3378        PDEBUG(debug_msgi, "message in");
3379        PDEBUG(debug_status, "status");
3380        PDEBUG(debug_cmd, "command");
3381        PDEBUG(debug_datai, "data in");
3382        PDEBUG(debug_datao, "data out");
3383        PDEBUG(debug_eh, "eh");
3384        PDEBUG(debug_locking, "locks");
3385        PDEBUG(debug_phases, "phases");
3386
3387        SPRINTF("\n");
3388#endif
3389
3390        SPRINTF("\nqueue status:\n");
3391        DO_LOCK(flags);
3392        if (ISSUE_SC) {
3393                SPRINTF("not yet issued commands:\n");
3394                for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3395                        pos += get_command(pos, ptr);
3396        } else
3397                SPRINTF("no not yet issued commands\n");
3398        DO_UNLOCK(flags);
3399
3400        if (CURRENT_SC) {
3401                SPRINTF("current command:\n");
3402                pos += get_command(pos, CURRENT_SC);
3403        } else
3404                SPRINTF("no current command\n");
3405
3406        if (DISCONNECTED_SC) {
3407                SPRINTF("disconnected commands:\n");
3408                for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3409                        pos += get_command(pos, ptr);
3410        } else
3411                SPRINTF("no disconnected commands\n");
3412
3413        pos += get_ports(shpnt, pos);
3414
3415#if defined(AHA152X_STAT)
3416        SPRINTF("statistics:\n"
3417                "total commands:               %d\n"
3418                "disconnections:               %d\n"
3419                "busfree with check condition: %d\n"
3420                "busfree without old command:  %d\n"
3421                "busfree without new command:  %d\n"
3422                "busfree without done command: %d\n"
3423                "busfree without any action:   %d\n"
3424                "state      "
3425                "transitions  "
3426                "count        "
3427                "time\n",
3428                HOSTDATA(shpnt)->total_commands,
3429                HOSTDATA(shpnt)->disconnections,
3430                HOSTDATA(shpnt)->busfree_with_check_condition,
3431                HOSTDATA(shpnt)->busfree_without_old_command,
3432                HOSTDATA(shpnt)->busfree_without_new_command,
3433                HOSTDATA(shpnt)->busfree_without_done_command,
3434                HOSTDATA(shpnt)->busfree_without_any_action);
3435        for(i=0; i<maxstate; i++) {
3436                SPRINTF("%-10s %-12d %-12d %-12ld\n",
3437                        states[i].name,
3438                        HOSTDATA(shpnt)->count_trans[i],
3439                        HOSTDATA(shpnt)->count[i],
3440                        HOSTDATA(shpnt)->time[i]);
3441        }
3442#endif
3443
3444        DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3445
3446        thislength = pos - (buffer + offset);
3447        DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3448
3449        if(thislength<0) {
3450                DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3451                *start = NULL;
3452                return 0;
3453        }
3454
3455        thislength = thislength<length ? thislength : length;
3456
3457        DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3458
3459        *start = buffer + offset;
3460        return thislength < length ? thislength : length;
3461}
3462
3463static int aha152x_adjust_queue(struct scsi_device *device)
3464{
3465        blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3466        return 0;
3467}
3468
3469static struct scsi_host_template aha152x_driver_template = {
3470        .module                         = THIS_MODULE,
3471        .name                           = AHA152X_REVID,
3472        .proc_name                      = "aha152x",
3473        .proc_info                      = aha152x_proc_info,
3474        .queuecommand                   = aha152x_queue,
3475        .eh_abort_handler               = aha152x_abort,
3476        .eh_device_reset_handler        = aha152x_device_reset,
3477        .eh_bus_reset_handler           = aha152x_bus_reset,
3478        .eh_host_reset_handler          = aha152x_host_reset,
3479        .bios_param                     = aha152x_biosparam,
3480        .can_queue                      = 1,
3481        .this_id                        = 7,
3482        .sg_tablesize                   = SG_ALL,
3483        .cmd_per_lun                    = 1,
3484        .use_clustering                 = DISABLE_CLUSTERING,
3485        .slave_alloc                    = aha152x_adjust_queue,
3486};
3487
3488#if !defined(PCMCIA)
3489static int setup_count;
3490static struct aha152x_setup setup[2];
3491
3492/* possible i/o addresses for the AIC-6260; default first */
3493static unsigned short ports[] = { 0x340, 0x140 };
3494
3495#if !defined(SKIP_BIOSTEST)
3496/* possible locations for the Adaptec BIOS; defaults first */
3497static unsigned int addresses[] =
3498{
3499        0xdc000,                /* default first */
3500        0xc8000,
3501        0xcc000,
3502        0xd0000,
3503        0xd4000,
3504        0xd8000,
3505        0xe0000,
3506        0xeb800,                /* VTech Platinum SMP */
3507        0xf0000,
3508};
3509
3510/* signatures for various AIC-6[23]60 based controllers.
3511   The point in detecting signatures is to avoid useless and maybe
3512   harmful probes on ports. I'm not sure that all listed boards pass
3513   auto-configuration. For those which fail the BIOS signature is
3514   obsolete, because user intervention to supply the configuration is
3515   needed anyway.  May be an information whether or not the BIOS supports
3516   extended translation could be also useful here. */
3517static struct signature {
3518        unsigned char *signature;
3519        int sig_offset;
3520        int sig_length;
3521} signatures[] =
3522{
3523        { "Adaptec AHA-1520 BIOS",      0x102e, 21 },
3524                /* Adaptec 152x */
3525        { "Adaptec AHA-1520B",          0x000b, 17 },
3526                /* Adaptec 152x rev B */
3527        { "Adaptec AHA-1520B",          0x0026, 17 },
3528                /* Iomega Jaz Jet ISA (AIC6370Q) */
3529        { "Adaptec ASW-B626 BIOS",      0x1029, 21 },
3530                /* on-board controller */
3531        { "Adaptec BIOS: ASW-B626",     0x000f, 22 },
3532                /* on-board controller */
3533        { "Adaptec ASW-B626 S2",        0x2e6c, 19 },
3534                /* on-board controller */
3535        { "Adaptec BIOS:AIC-6360",      0x000c, 21 },
3536                /* on-board controller */
3537        { "ScsiPro SP-360 BIOS",        0x2873, 19 },
3538                /* ScsiPro-Controller  */
3539        { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3540                /* Gigabyte Local-Bus-SCSI */
3541        { "Adaptec BIOS:AVA-282X",      0x000c, 21 },
3542                /* Adaptec 282x */
3543        { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
3544                /* IBM Thinkpad Dock II */
3545        { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
3546                /* IBM Thinkpad Dock II SCSI */
3547        { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3548                /* DTC 3520A ISA SCSI */
3549};
3550#endif /* !SKIP_BIOSTEST */
3551
3552/*
3553 * Test, if port_base is valid.
3554 *
3555 */
3556static int aha152x_porttest(int io_port)
3557{
3558        int i;
3559
3560        SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
3561        for (i = 0; i < 16; i++)
3562                SETPORT(io_port + O_STACK, i);
3563
3564        SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
3565        for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3566                ;
3567
3568        return (i == 16);
3569}
3570
3571static int tc1550_porttest(int io_port)
3572{
3573        int i;
3574
3575        SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3576        for (i = 0; i < 16; i++)
3577                SETPORT(io_port + O_STACK, i);
3578
3579        SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3580        for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3581                ;
3582
3583        return (i == 16);
3584}
3585
3586
3587static int checksetup(struct aha152x_setup *setup)
3588{
3589        int i;
3590        for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3591                ;
3592
3593        if (i == ARRAY_SIZE(ports))
3594                return 0;
3595
3596        if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3597                printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3598                return 0;
3599        }
3600
3601        if( aha152x_porttest(setup->io_port) ) {
3602                setup->tc1550=0;
3603        } else if( tc1550_porttest(setup->io_port) ) {
3604                setup->tc1550=1;
3605        } else {
3606                release_region(setup->io_port, IO_RANGE);
3607                return 0;
3608        }
3609
3610        release_region(setup->io_port, IO_RANGE);
3611
3612        if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3613                return 0;
3614
3615        if ((setup->scsiid < 0) || (setup->scsiid > 7))
3616                return 0;
3617
3618        if ((setup->reconnect < 0) || (setup->reconnect > 1))
3619                return 0;
3620
3621        if ((setup->parity < 0) || (setup->parity > 1))
3622                return 0;
3623
3624        if ((setup->synchronous < 0) || (setup->synchronous > 1))
3625                return 0;
3626
3627        if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3628                return 0;
3629
3630
3631        return 1;
3632}
3633
3634
3635static int __init aha152x_init(void)
3636{
3637        int i, j, ok;
3638#if defined(AUTOCONF)
3639        aha152x_config conf;
3640#endif
3641#ifdef __ISAPNP__
3642        struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3643#endif
3644
3645        if ( setup_count ) {
3646                printk(KERN_INFO "aha152x: processing commandline: ");
3647
3648                for (i = 0; i<setup_count; i++) {
3649                        if (!checksetup(&setup[i])) {
3650                                printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3651                                printk(KERN_ERR "aha152x: invalid line\n");
3652                        }
3653                }
3654                printk("ok\n");
3655        }
3656
3657#if defined(SETUP0)
3658        if (setup_count < ARRAY_SIZE(setup)) {
3659                struct aha152x_setup override = SETUP0;
3660
3661                if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3662                        if (!checksetup(&override)) {
3663                                printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3664                                       override.io_port,
3665                                       override.irq,
3666                                       override.scsiid,
3667                                       override.reconnect,
3668                                       override.parity,
3669                                       override.synchronous,
3670                                       override.delay,
3671                                       override.ext_trans);
3672                        } else
3673                                setup[setup_count++] = override;
3674                }
3675        }
3676#endif
3677
3678#if defined(SETUP1)
3679        if (setup_count < ARRAY_SIZE(setup)) {
3680                struct aha152x_setup override = SETUP1;
3681
3682                if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3683                        if (!checksetup(&override)) {
3684                                printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3685                                       override.io_port,
3686                                       override.irq,
3687                                       override.scsiid,
3688                                       override.reconnect,
3689                                       override.parity,
3690                                       override.synchronous,
3691                                       override.delay,
3692                                       override.ext_trans);
3693                        } else
3694                                setup[setup_count++] = override;
3695                }
3696        }
3697#endif
3698
3699#if defined(MODULE)
3700        if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3701                if(aha152x[0]!=0) {
3702                        setup[setup_count].conf        = "";
3703                        setup[setup_count].io_port     = aha152x[0];
3704                        setup[setup_count].irq         = aha152x[1];
3705                        setup[setup_count].scsiid      = aha152x[2];
3706                        setup[setup_count].reconnect   = aha152x[3];
3707                        setup[setup_count].parity      = aha152x[4];
3708                        setup[setup_count].synchronous = aha152x[5];
3709                        setup[setup_count].delay       = aha152x[6];
3710                        setup[setup_count].ext_trans   = aha152x[7];
3711#if defined(AHA152X_DEBUG)
3712                        setup[setup_count].debug       = aha152x[8];
3713#endif
3714                } else if(io[0]!=0 || irq[0]!=0) {
3715                        if(io[0]!=0)  setup[setup_count].io_port = io[0];
3716                        if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3717
3718                        setup[setup_count].scsiid      = scsiid[0];
3719                        setup[setup_count].reconnect   = reconnect[0];
3720                        setup[setup_count].parity      = parity[0];
3721                        setup[setup_count].synchronous = sync[0];
3722                        setup[setup_count].delay       = delay[0];
3723                        setup[setup_count].ext_trans   = exttrans[0];
3724#if defined(AHA152X_DEBUG)
3725                        setup[setup_count].debug       = debug[0];
3726#endif
3727                }
3728
3729                if (checksetup(&setup[setup_count]))
3730                        setup_count++;
3731                else
3732                        printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3733                               setup[setup_count].io_port,
3734                               setup[setup_count].irq,
3735                               setup[setup_count].scsiid,
3736                               setup[setup_count].reconnect,
3737                               setup[setup_count].parity,
3738                               setup[setup_count].synchronous,
3739                               setup[setup_count].delay,
3740                               setup[setup_count].ext_trans);
3741        }
3742
3743        if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3744                if(aha152x1[0]!=0) {
3745                        setup[setup_count].conf        = "";
3746                        setup[setup_count].io_port     = aha152x1[0];
3747                        setup[setup_count].irq         = aha152x1[1];
3748                        setup[setup_count].scsiid      = aha152x1[2];
3749                        setup[setup_count].reconnect   = aha152x1[3];
3750                        setup[setup_count].parity      = aha152x1[4];
3751                        setup[setup_count].synchronous = aha152x1[5];
3752                        setup[setup_count].delay       = aha152x1[6];
3753                        setup[setup_count].ext_trans   = aha152x1[7];
3754#if defined(AHA152X_DEBUG)
3755                        setup[setup_count].debug       = aha152x1[8];
3756#endif
3757                } else if(io[1]!=0 || irq[1]!=0) {
3758                        if(io[1]!=0)  setup[setup_count].io_port = io[1];
3759                        if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3760
3761                        setup[setup_count].scsiid      = scsiid[1];
3762                        setup[setup_count].reconnect   = reconnect[1];
3763                        setup[setup_count].parity      = parity[1];
3764                        setup[setup_count].synchronous = sync[1];
3765                        setup[setup_count].delay       = delay[1];
3766                        setup[setup_count].ext_trans   = exttrans[1];
3767#if defined(AHA152X_DEBUG)
3768                        setup[setup_count].debug       = debug[1];
3769#endif
3770                }
3771                if (checksetup(&setup[setup_count]))
3772                        setup_count++;
3773                else
3774                        printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3775                               setup[setup_count].io_port,
3776                               setup[setup_count].irq,
3777                               setup[setup_count].scsiid,
3778                               setup[setup_count].reconnect,
3779                               setup[setup_count].parity,
3780                               setup[setup_count].synchronous,
3781                               setup[setup_count].delay,
3782                               setup[setup_count].ext_trans);
3783        }
3784#endif
3785
3786#ifdef __ISAPNP__
3787        for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3788                while ( setup_count<ARRAY_SIZE(setup) &&
3789                        (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3790                        if (pnp_device_attach(dev) < 0)
3791                                continue;
3792
3793                        if (pnp_activate_dev(dev) < 0) {
3794                                pnp_device_detach(dev);
3795                                continue;
3796                        }
3797
3798                        if (!pnp_port_valid(dev, 0)) {
3799                                pnp_device_detach(dev);
3800                                continue;
3801                        }
3802
3803                        if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3804                                pnp_device_detach(dev);
3805                                continue;
3806                        }
3807
3808                        setup[setup_count].io_port     = pnp_port_start(dev, 0);
3809                        setup[setup_count].irq         = pnp_irq(dev, 0);
3810                        setup[setup_count].scsiid      = 7;
3811                        setup[setup_count].reconnect   = 1;
3812                        setup[setup_count].parity      = 1;
3813                        setup[setup_count].synchronous = 1;
3814                        setup[setup_count].delay       = DELAY_DEFAULT;
3815                        setup[setup_count].ext_trans   = 0;
3816#if defined(AHA152X_DEBUG)
3817                        setup[setup_count].debug       = DEBUG_DEFAULT;
3818#endif
3819#if defined(__ISAPNP__)
3820                        pnpdev[setup_count]            = dev;
3821#endif
3822                        printk (KERN_INFO
3823                                "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3824                                setup[setup_count].io_port, setup[setup_count].irq);
3825                        setup_count++;
3826                }
3827        }
3828#endif
3829
3830#if defined(AUTOCONF)
3831        if (setup_count<ARRAY_SIZE(setup)) {
3832#if !defined(SKIP_BIOSTEST)
3833                ok = 0;
3834                for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3835                        void __iomem *p = ioremap(addresses[i], 0x4000);
3836                        if (!p)
3837                                continue;
3838                        for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3839                                ok = check_signature(p + signatures[j].sig_offset,
3840                                                                signatures[j].signature, signatures[j].sig_length);
3841                        iounmap(p);
3842                }
3843                if (!ok && setup_count == 0)
3844                        return -ENODEV;
3845
3846                printk(KERN_INFO "aha152x: BIOS test: passed, ");
3847#else
3848                printk(KERN_INFO "aha152x: ");
3849#endif                          /* !SKIP_BIOSTEST */
3850
3851                ok = 0;
3852                for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3853                        if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3854                                continue;
3855
3856                        if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3857                                printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3858                                continue;
3859                        }
3860
3861                        if (aha152x_porttest(ports[i])) {
3862                                setup[setup_count].tc1550  = 0;
3863
3864                                conf.cf_port =
3865                                    (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3866                        } else if (tc1550_porttest(ports[i])) {
3867                                setup[setup_count].tc1550  = 1;
3868
3869                                conf.cf_port =
3870                                    (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3871                        } else {
3872                                release_region(ports[i], IO_RANGE);
3873                                continue;
3874                        }
3875
3876                        release_region(ports[i], IO_RANGE);
3877
3878                        ok++;
3879                        setup[setup_count].io_port = ports[i];
3880                        setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3881                        setup[setup_count].scsiid = conf.cf_id;
3882                        setup[setup_count].reconnect = conf.cf_tardisc;
3883                        setup[setup_count].parity = !conf.cf_parity;
3884                        setup[setup_count].synchronous = conf.cf_syncneg;
3885                        setup[setup_count].delay = DELAY_DEFAULT;
3886                        setup[setup_count].ext_trans = 0;
3887#if defined(AHA152X_DEBUG)
3888                        setup[setup_count].debug = DEBUG_DEFAULT;
3889#endif
3890                        setup_count++;
3891
3892                }
3893
3894                if (ok)
3895                        printk("auto configuration: ok, ");
3896        }
3897#endif
3898
3899        printk("%d controller(s) configured\n", setup_count);
3900
3901        for (i=0; i<setup_count; i++) {
3902                if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3903                        struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3904
3905                        if( !shpnt ) {
3906                                release_region(setup[i].io_port, IO_RANGE);
3907#if defined(__ISAPNP__)
3908                        } else if( pnpdev[i] ) {
3909                                HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3910                                pnpdev[i]=NULL;
3911#endif
3912                        }
3913                } else {
3914                        printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3915                }
3916
3917#if defined(__ISAPNP__)
3918                if( pnpdev[i] )
3919                        pnp_device_detach(pnpdev[i]);
3920#endif
3921        }
3922
3923        return 0;
3924}
3925
3926static void __exit aha152x_exit(void)
3927{
3928        struct aha152x_hostdata *hd, *tmp;
3929
3930        list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3931                struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3932
3933                aha152x_release(shost);
3934        }
3935}
3936
3937module_init(aha152x_init);
3938module_exit(aha152x_exit);
3939
3940#if !defined(MODULE)
3941static int __init aha152x_setup(char *str)
3942{
3943#if defined(AHA152X_DEBUG)
3944        int ints[11];
3945#else
3946        int ints[10];
3947#endif
3948        get_options(str, ARRAY_SIZE(ints), ints);
3949
3950        if(setup_count>=ARRAY_SIZE(setup)) {
3951                printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3952                return 1;
3953        }
3954
3955        setup[setup_count].conf        = str;
3956        setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3957        setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3958        setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3959        setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3960        setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3961        setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3962        setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3963        setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3964#if defined(AHA152X_DEBUG)
3965        setup[setup_count].debug       = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3966        if (ints[0] > 9) {
3967                printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3968                       "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3969#else
3970        if (ints[0] > 8) {                                                /*}*/
3971                printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3972                       "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3973#endif
3974        } else {
3975                setup_count++;
3976                return 0;
3977        }
3978
3979        return 1;
3980}
3981__setup("aha152x=", aha152x_setup);
3982#endif
3983
3984#endif /* !PCMCIA */
3985
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.