linux/drivers/scsi/aha152x.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* aha152x.c -- Adaptec AHA-152x driver
   3 * Author: Jürgen E. Fischer, fischer@norbit.de
   4 * Copyright 1993-2004 Jürgen E. Fischer
   5 *
   6 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
   7 *
   8 * $Log: aha152x.c,v $
   9 * Revision 2.7  2004/01/24 11:42:59  fischer
  10 * - gather code that is not used by PCMCIA at the end
  11 * - move request_region for !PCMCIA case to detection
  12 * - migration to new scsi host api (remove legacy code)
  13 * - free host scribble before scsi_done
  14 * - fix error handling
  15 * - one isapnp device added to id_table
  16 *
  17 * Revision 2.6  2003/10/30 20:52:47  fischer
  18 * - interfaces changes for kernel 2.6
  19 * - aha152x_probe_one introduced for pcmcia stub
  20 * - fixed pnpdev handling
  21 * - instead of allocation a new one, reuse command for request sense after check condition and reset
  22 * - fixes race in is_complete
  23 *
  24 * Revision 2.5  2002/04/14 11:24:53  fischer
  25 * - isapnp support
  26 * - abort fixed
  27 * - 2.5 support
  28 *
  29 * Revision 2.4  2000/12/16 12:53:56  fischer
  30 * - allow REQUEST SENSE to be queued
  31 * - handle shared PCI interrupts
  32 *
  33 * Revision 2.3  2000/11/04 16:40:26  fischer
  34 * - handle data overruns
  35 * - extend timeout for data phases
  36 *
  37 * Revision 2.2  2000/08/08 19:54:53  fischer
  38 * - minor changes
  39 *
  40 * Revision 2.1  2000/05/17 16:23:17  fischer
  41 * - signature update
  42 * - fix for data out w/o scatter gather
  43 *
  44 * Revision 2.0  1999/12/25 15:07:32  fischer
  45 * - interrupt routine completly reworked
  46 * - basic support for new eh code
  47 *
  48 * Revision 1.21  1999/11/10 23:46:36  fischer
  49 * - default to synchronous operation
  50 * - synchronous negotiation fixed
  51 * - added timeout to loops
  52 * - debugging output can be controlled through procfs
  53 *
  54 * Revision 1.20  1999/11/07 18:37:31  fischer
  55 * - synchronous operation works
  56 * - resid support for sg driver
  57 *
  58 * Revision 1.19  1999/11/02 22:39:59  fischer
  59 * - moved leading comments to README.aha152x
  60 * - new additional module parameters
  61 * - updates for 2.3
  62 * - support for the Tripace TC1550 controller
  63 * - interrupt handling changed
  64 *
  65 * Revision 1.18  1996/09/07 20:10:40  fischer
  66 * - fixed can_queue handling (multiple outstanding commands working again)
  67 *
  68 * Revision 1.17  1996/08/17 16:05:14  fischer
  69 * - biosparam improved
  70 * - interrupt verification
  71 * - updated documentation
  72 * - cleanups
  73 *
  74 * Revision 1.16  1996/06/09 00:04:56  root
  75 * - added configuration symbols for insmod (aha152x/aha152x1)
  76 *
  77 * Revision 1.15  1996/04/30 14:52:06  fischer
  78 * - proc info fixed
  79 * - support for extended translation for >1GB disks
  80 *
  81 * Revision 1.14  1996/01/17  15:11:20  fischer
  82 * - fixed lockup in MESSAGE IN phase after reconnection
  83 *
  84 * Revision 1.13  1996/01/09  02:15:53  fischer
  85 * - some cleanups
  86 * - moved request_irq behind controller initialization
  87 *   (to avoid spurious interrupts)
  88 *
  89 * Revision 1.12  1995/12/16  12:26:07  fischer
  90 * - barrier()s added
  91 * - configurable RESET delay added
  92 *
  93 * Revision 1.11  1995/12/06  21:18:35  fischer
  94 * - some minor updates
  95 *
  96 * Revision 1.10  1995/07/22  19:18:45  fischer
  97 * - support for 2 controllers
  98 * - started synchronous data transfers (not working yet)
  99 *
 100 * Revision 1.9  1995/03/18  09:20:24  root
 101 * - patches for PCMCIA and modules
 102 *
 103 * Revision 1.8  1995/01/21  22:07:19  root
 104 * - snarf_region => request_region
 105 * - aha152x_intr interface change
 106 *
 107 * Revision 1.7  1995/01/02  23:19:36  root
 108 * - updated COMMAND_SIZE to cmd_len
 109 * - changed sti() to restore_flags()
 110 * - fixed some #ifdef which generated warnings
 111 *
 112 * Revision 1.6  1994/11/24  20:35:27  root
 113 * - problem with odd number of bytes in fifo fixed
 114 *
 115 * Revision 1.5  1994/10/30  14:39:56  root
 116 * - abort code fixed
 117 * - debugging improved
 118 *
 119 * Revision 1.4  1994/09/12  11:33:01  root
 120 * - irqaction to request_irq
 121 * - abortion updated
 122 *
 123 * Revision 1.3  1994/08/04  13:53:05  root
 124 * - updates for mid-level-driver changes
 125 * - accept unexpected BUSFREE phase as error condition
 126 * - parity check now configurable
 127 *
 128 * Revision 1.2  1994/07/03  12:56:36  root
 129 * - cleaned up debugging code
 130 * - more tweaking on reset delays
 131 * - updated abort/reset code (pretty untested...)
 132 *
 133 * Revision 1.1  1994/05/28  21:18:49  root
 134 * - update for mid-level interface change (abort-reset)
 135 * - delays after resets adjusted for some slow devices
 136 *
 137 * Revision 1.0  1994/03/25  12:52:00  root
 138 * - Fixed "more data than expected" problem
 139 * - added new BIOS signatures
 140 *
 141 * Revision 0.102  1994/01/31  20:44:12  root
 142 * - minor changes in insw/outsw handling
 143 *
 144 * Revision 0.101  1993/12/13  01:16:27  root
 145 * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
 146 *   fixes problems with CD-ROM sector size detection & media change)
 147 *
 148 * Revision 0.100  1993/12/10  16:58:47  root
 149 * - fix for unsuccessful selections in case of non-continuous id assignments
 150 *   on the scsi bus.
 151 *
 152 * Revision 0.99  1993/10/24  16:19:59  root
 153 * - fixed DATA IN (rare read errors gone)
 154 *
 155 * Revision 0.98  1993/10/17  12:54:44  root
 156 * - fixed some recent fixes (shame on me)
 157 * - moved initialization of scratch area to aha152x_queue
 158 *
 159 * Revision 0.97  1993/10/09  18:53:53  root
 160 * - DATA IN fixed. Rarely left data in the fifo.
 161 *
 162 * Revision 0.96  1993/10/03  00:53:59  root
 163 * - minor changes on DATA IN
 164 *
 165 * Revision 0.95  1993/09/24  10:36:01  root
 166 * - change handling of MSGI after reselection
 167 * - fixed sti/cli
 168 * - minor changes
 169 *
 170 * Revision 0.94  1993/09/18  14:08:22  root
 171 * - fixed bug in multiple outstanding command code
 172 * - changed detection
 173 * - support for kernel command line configuration
 174 * - reset corrected
 175 * - changed message handling
 176 *
 177 * Revision 0.93  1993/09/15  20:41:19  root
 178 * - fixed bugs with multiple outstanding commands
 179 *
 180 * Revision 0.92  1993/09/13  02:46:33  root
 181 * - multiple outstanding commands work (no problems with IBM drive)
 182 *
 183 * Revision 0.91  1993/09/12  20:51:46  root
 184 * added multiple outstanding commands
 185 * (some problem with this $%&? IBM device remain)
 186 *
 187 * Revision 0.9  1993/09/12  11:11:22  root
 188 * - corrected auto-configuration
 189 * - changed the auto-configuration (added some '#define's)
 190 * - added support for dis-/reconnection
 191 *
 192 * Revision 0.8  1993/09/06  23:09:39  root
 193 * - added support for the drive activity light
 194 * - minor changes
 195 *
 196 * Revision 0.7  1993/09/05  14:30:15  root
 197 * - improved phase detection
 198 * - now using the new snarf_region code of 0.99pl13
 199 *
 200 * Revision 0.6  1993/09/02  11:01:38  root
 201 * first public release; added some signatures and biosparam()
 202 *
 203 * Revision 0.5  1993/08/30  10:23:30  root
 204 * fixed timing problems with my IBM drive
 205 *
 206 * Revision 0.4  1993/08/29  14:06:52  root
 207 * fixed some problems with timeouts due incomplete commands
 208 *
 209 * Revision 0.3  1993/08/28  15:55:03  root
 210 * writing data works too.  mounted and worked on a dos partition
 211 *
 212 * Revision 0.2  1993/08/27  22:42:07  root
 213 * reading data works.  Mounted a msdos partition.
 214 *
 215 * Revision 0.1  1993/08/25  13:38:30  root
 216 * first "damn thing doesn't work" version
 217 *
 218 * Revision 0.0  1993/08/14  19:54:25  root
 219 * empty function bodies; detect() works.
 220 *
 221 **************************************************************************
 222
 223 see Documentation/scsi/aha152x.rst for configuration details
 224
 225 **************************************************************************/
 226
 227#include <linux/module.h>
 228#include <asm/irq.h>
 229#include <linux/io.h>
 230#include <linux/blkdev.h>
 231#include <linux/completion.h>
 232#include <linux/errno.h>
 233#include <linux/string.h>
 234#include <linux/wait.h>
 235#include <linux/ioport.h>
 236#include <linux/delay.h>
 237#include <linux/proc_fs.h>
 238#include <linux/interrupt.h>
 239#include <linux/init.h>
 240#include <linux/kernel.h>
 241#include <linux/isapnp.h>
 242#include <linux/spinlock.h>
 243#include <linux/workqueue.h>
 244#include <linux/list.h>
 245#include <linux/slab.h>
 246#include <scsi/scsicam.h>
 247
 248#include "scsi.h"
 249#include <scsi/scsi_dbg.h>
 250#include <scsi/scsi_host.h>
 251#include <scsi/scsi_transport_spi.h>
 252#include <scsi/scsi_eh.h>
 253#include "aha152x.h"
 254
 255static LIST_HEAD(aha152x_host_list);
 256
 257
 258/* DEFINES */
 259
 260/* For PCMCIA cards, always use AUTOCONF */
 261#if defined(AHA152X_PCMCIA) || defined(MODULE)
 262#if !defined(AUTOCONF)
 263#define AUTOCONF
 264#endif
 265#endif
 266
 267#if !defined(AUTOCONF) && !defined(SETUP0)
 268#error define AUTOCONF or SETUP0
 269#endif
 270
 271#define DO_LOCK(flags)          spin_lock_irqsave(&QLOCK,flags)
 272#define DO_UNLOCK(flags)        spin_unlock_irqrestore(&QLOCK,flags)
 273
 274#define LEAD            "(scsi%d:%d:%d) "
 275#define INFO_LEAD       KERN_INFO       LEAD
 276#define CMDINFO(cmd) \
 277                        (cmd) ? ((cmd)->device->host->host_no) : -1, \
 278                        (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
 279                        (cmd) ? ((u8)(cmd)->device->lun & 0x07) : -1
 280
 281static inline void
 282CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 283{
 284        scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
 285}
 286
 287#define DELAY_DEFAULT 1000
 288
 289#if defined(AHA152X_PCMCIA)
 290#define IRQ_MIN 0
 291#define IRQ_MAX 16
 292#else
 293#define IRQ_MIN 9
 294#if defined(__PPC)
 295#define IRQ_MAX (nr_irqs-1)
 296#else
 297#define IRQ_MAX 12
 298#endif
 299#endif
 300
 301enum {
 302        not_issued      = 0x0001,       /* command not yet issued */
 303        selecting       = 0x0002,       /* target is being selected */
 304        identified      = 0x0004,       /* IDENTIFY was sent */
 305        disconnected    = 0x0008,       /* target disconnected */
 306        completed       = 0x0010,       /* target sent COMMAND COMPLETE */
 307        aborted         = 0x0020,       /* ABORT was sent */
 308        resetted        = 0x0040,       /* BUS DEVICE RESET was sent */
 309        spiordy         = 0x0080,       /* waiting for SPIORDY to raise */
 310        syncneg         = 0x0100,       /* synchronous negotiation in progress */
 311        aborting        = 0x0200,       /* ABORT is pending */
 312        resetting       = 0x0400,       /* BUS DEVICE RESET is pending */
 313        check_condition = 0x0800,       /* requesting sense after CHECK CONDITION */
 314};
 315
 316MODULE_AUTHOR("Jürgen Fischer");
 317MODULE_DESCRIPTION(AHA152X_REVID);
 318MODULE_LICENSE("GPL");
 319
 320#if !defined(AHA152X_PCMCIA)
 321#if defined(MODULE)
 322static int io[] = {0, 0};
 323module_param_hw_array(io, int, ioport, NULL, 0);
 324MODULE_PARM_DESC(io,"base io address of controller");
 325
 326static int irq[] = {0, 0};
 327module_param_hw_array(irq, int, irq, NULL, 0);
 328MODULE_PARM_DESC(irq,"interrupt for controller");
 329
 330static int scsiid[] = {7, 7};
 331module_param_array(scsiid, int, NULL, 0);
 332MODULE_PARM_DESC(scsiid,"scsi id of controller");
 333
 334static int reconnect[] = {1, 1};
 335module_param_array(reconnect, int, NULL, 0);
 336MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
 337
 338static int parity[] = {1, 1};
 339module_param_array(parity, int, NULL, 0);
 340MODULE_PARM_DESC(parity,"use scsi parity");
 341
 342static int sync[] = {1, 1};
 343module_param_array(sync, int, NULL, 0);
 344MODULE_PARM_DESC(sync,"use synchronous transfers");
 345
 346static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
 347module_param_array(delay, int, NULL, 0);
 348MODULE_PARM_DESC(delay,"scsi reset delay");
 349
 350static int exttrans[] = {0, 0};
 351module_param_array(exttrans, int, NULL, 0);
 352MODULE_PARM_DESC(exttrans,"use extended translation");
 353
 354static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 355module_param_array(aha152x, int, NULL, 0);
 356MODULE_PARM_DESC(aha152x, "parameters for first controller");
 357
 358static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
 359module_param_array(aha152x1, int, NULL, 0);
 360MODULE_PARM_DESC(aha152x1, "parameters for second controller");
 361#endif /* MODULE */
 362
 363#ifdef __ISAPNP__
 364static struct isapnp_device_id id_table[] = {
 365        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
 366        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
 367        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
 368        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
 369        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
 370        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
 371        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
 372        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
 373        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
 374        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
 375        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
 376        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
 377        { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
 378        { ISAPNP_DEVICE_SINGLE_END, }
 379};
 380MODULE_DEVICE_TABLE(isapnp, id_table);
 381#endif /* ISAPNP */
 382
 383#endif /* !AHA152X_PCMCIA */
 384
 385static struct scsi_host_template aha152x_driver_template;
 386
 387/*
 388 * internal states of the host
 389 *
 390 */
 391enum aha152x_state {
 392        idle=0,
 393        unknown,
 394        seldo,
 395        seldi,
 396        selto,
 397        busfree,
 398        msgo,
 399        cmd,
 400        msgi,
 401        status,
 402        datai,
 403        datao,
 404        parerr,
 405        rsti,
 406        maxstate
 407};
 408
 409/*
 410 * current state information of the host
 411 *
 412 */
 413struct aha152x_hostdata {
 414        struct scsi_cmnd *issue_SC;
 415                /* pending commands to issue */
 416
 417        struct scsi_cmnd *current_SC;
 418                /* current command on the bus */
 419
 420        struct scsi_cmnd *disconnected_SC;
 421                /* commands that disconnected */
 422
 423        struct scsi_cmnd *done_SC;
 424                /* command that was completed */
 425
 426        spinlock_t lock;
 427                /* host lock */
 428
 429#if defined(AHA152X_STAT)
 430        int           total_commands;
 431        int           disconnections;
 432        int           busfree_without_any_action;
 433        int           busfree_without_old_command;
 434        int           busfree_without_new_command;
 435        int           busfree_without_done_command;
 436        int           busfree_with_check_condition;
 437        int           count[maxstate];
 438        int           count_trans[maxstate];
 439        unsigned long time[maxstate];
 440#endif
 441
 442        int commands;           /* current number of commands */
 443
 444        int reconnect;          /* disconnection allowed */
 445        int parity;             /* parity checking enabled */
 446        int synchronous;        /* synchronous transferes enabled */
 447        int delay;              /* reset out delay */
 448        int ext_trans;          /* extended translation enabled */
 449
 450        int swint;              /* software-interrupt was fired during detect() */
 451        int service;            /* bh needs to be run */
 452        int in_intr;            /* bh is running */
 453
 454        /* current state,
 455           previous state,
 456           last state different from current state */
 457        enum aha152x_state state, prevstate, laststate;
 458
 459        int target;
 460                /* reconnecting target */
 461
 462        unsigned char syncrate[8];
 463                /* current synchronous transfer agreements */
 464
 465        unsigned char syncneg[8];
 466                /* 0: no negotiation;
 467                 * 1: negotiation in progress;
 468                 * 2: negotiation completed
 469                 */
 470
 471        int cmd_i;
 472                /* number of sent bytes of current command */
 473
 474        int msgi_len;
 475                /* number of received message bytes */
 476        unsigned char msgi[256];
 477                /* received message bytes */
 478
 479        int msgo_i, msgo_len;
 480                /* number of sent bytes and length of current messages */
 481        unsigned char msgo[256];
 482                /* pending messages */
 483
 484        int data_len;
 485                /* number of sent/received bytes in dataphase */
 486
 487        unsigned long io_port0;
 488        unsigned long io_port1;
 489
 490#ifdef __ISAPNP__
 491        struct pnp_dev *pnpdev;
 492#endif
 493        struct list_head host_list;
 494};
 495
 496
 497/*
 498 * host specific command extension
 499 *
 500 */
 501struct aha152x_scdata {
 502        struct scsi_cmnd *next; /* next sc in queue */
 503        struct completion *done;/* semaphore to block on */
 504        struct scsi_eh_save ses;
 505};
 506
 507/* access macros for hostdata */
 508
 509#define HOSTDATA(shpnt)         ((struct aha152x_hostdata *) &shpnt->hostdata)
 510
 511#define HOSTNO                  ((shpnt)->host_no)
 512
 513#define CURRENT_SC              (HOSTDATA(shpnt)->current_SC)
 514#define DONE_SC                 (HOSTDATA(shpnt)->done_SC)
 515#define ISSUE_SC                (HOSTDATA(shpnt)->issue_SC)
 516#define DISCONNECTED_SC         (HOSTDATA(shpnt)->disconnected_SC)
 517#define QLOCK                   (HOSTDATA(shpnt)->lock)
 518#define QLOCKER                 (HOSTDATA(shpnt)->locker)
 519#define QLOCKERL                (HOSTDATA(shpnt)->lockerl)
 520
 521#define STATE                   (HOSTDATA(shpnt)->state)
 522#define PREVSTATE               (HOSTDATA(shpnt)->prevstate)
 523#define LASTSTATE               (HOSTDATA(shpnt)->laststate)
 524
 525#define RECONN_TARGET           (HOSTDATA(shpnt)->target)
 526
 527#define CMD_I                   (HOSTDATA(shpnt)->cmd_i)
 528
 529#define MSGO(i)                 (HOSTDATA(shpnt)->msgo[i])
 530#define MSGO_I                  (HOSTDATA(shpnt)->msgo_i)
 531#define MSGOLEN                 (HOSTDATA(shpnt)->msgo_len)
 532#define ADDMSGO(x)              (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
 533
 534#define MSGI(i)                 (HOSTDATA(shpnt)->msgi[i])
 535#define MSGILEN                 (HOSTDATA(shpnt)->msgi_len)
 536#define ADDMSGI(x)              (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
 537
 538#define DATA_LEN                (HOSTDATA(shpnt)->data_len)
 539
 540#define SYNCRATE                (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
 541#define SYNCNEG                 (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
 542
 543#define DELAY                   (HOSTDATA(shpnt)->delay)
 544#define EXT_TRANS               (HOSTDATA(shpnt)->ext_trans)
 545#define TC1550                  (HOSTDATA(shpnt)->tc1550)
 546#define RECONNECT               (HOSTDATA(shpnt)->reconnect)
 547#define PARITY                  (HOSTDATA(shpnt)->parity)
 548#define SYNCHRONOUS             (HOSTDATA(shpnt)->synchronous)
 549
 550#define HOSTIOPORT0             (HOSTDATA(shpnt)->io_port0)
 551#define HOSTIOPORT1             (HOSTDATA(shpnt)->io_port1)
 552
 553#define SCDATA(SCpnt)           ((struct aha152x_scdata *) (SCpnt)->host_scribble)
 554#define SCNEXT(SCpnt)           SCDATA(SCpnt)->next
 555#define SCSEM(SCpnt)            SCDATA(SCpnt)->done
 556
 557#define SG_ADDRESS(buffer)      ((char *) sg_virt((buffer)))
 558
 559/* state handling */
 560static void seldi_run(struct Scsi_Host *shpnt);
 561static void seldo_run(struct Scsi_Host *shpnt);
 562static void selto_run(struct Scsi_Host *shpnt);
 563static void busfree_run(struct Scsi_Host *shpnt);
 564
 565static void msgo_init(struct Scsi_Host *shpnt);
 566static void msgo_run(struct Scsi_Host *shpnt);
 567static void msgo_end(struct Scsi_Host *shpnt);
 568
 569static void cmd_init(struct Scsi_Host *shpnt);
 570static void cmd_run(struct Scsi_Host *shpnt);
 571static void cmd_end(struct Scsi_Host *shpnt);
 572
 573static void datai_init(struct Scsi_Host *shpnt);
 574static void datai_run(struct Scsi_Host *shpnt);
 575static void datai_end(struct Scsi_Host *shpnt);
 576
 577static void datao_init(struct Scsi_Host *shpnt);
 578static void datao_run(struct Scsi_Host *shpnt);
 579static void datao_end(struct Scsi_Host *shpnt);
 580
 581static void status_run(struct Scsi_Host *shpnt);
 582
 583static void msgi_run(struct Scsi_Host *shpnt);
 584static void msgi_end(struct Scsi_Host *shpnt);
 585
 586static void parerr_run(struct Scsi_Host *shpnt);
 587static void rsti_run(struct Scsi_Host *shpnt);
 588
 589static void is_complete(struct Scsi_Host *shpnt);
 590
 591/*
 592 * driver states
 593 *
 594 */
 595static struct {
 596        char            *name;
 597        void            (*init)(struct Scsi_Host *);
 598        void            (*run)(struct Scsi_Host *);
 599        void            (*end)(struct Scsi_Host *);
 600        int             spio;
 601} states[] = {
 602        { "idle",       NULL,           NULL,           NULL,           0},
 603        { "unknown",    NULL,           NULL,           NULL,           0},
 604        { "seldo",      NULL,           seldo_run,      NULL,           0},
 605        { "seldi",      NULL,           seldi_run,      NULL,           0},
 606        { "selto",      NULL,           selto_run,      NULL,           0},
 607        { "busfree",    NULL,           busfree_run,    NULL,           0},
 608        { "msgo",       msgo_init,      msgo_run,       msgo_end,       1},
 609        { "cmd",        cmd_init,       cmd_run,        cmd_end,        1},
 610        { "msgi",       NULL,           msgi_run,       msgi_end,       1},
 611        { "status",     NULL,           status_run,     NULL,           1},
 612        { "datai",      datai_init,     datai_run,      datai_end,      0},
 613        { "datao",      datao_init,     datao_run,      datao_end,      0},
 614        { "parerr",     NULL,           parerr_run,     NULL,           0},
 615        { "rsti",       NULL,           rsti_run,       NULL,           0},
 616};
 617
 618/* setup & interrupt */
 619static irqreturn_t intr(int irq, void *dev_id);
 620static void reset_ports(struct Scsi_Host *shpnt);
 621static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
 622static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
 623                 unsigned char host_byte);
 624
 625/* diagnostics */
 626static void show_command(struct scsi_cmnd * ptr);
 627static void show_queues(struct Scsi_Host *shpnt);
 628static void disp_enintr(struct Scsi_Host *shpnt);
 629
 630
 631/*
 632 *  queue services:
 633 *
 634 */
 635static inline void append_SC(struct scsi_cmnd **SC, struct scsi_cmnd *new_SC)
 636{
 637        struct scsi_cmnd *end;
 638
 639        SCNEXT(new_SC) = NULL;
 640        if (!*SC)
 641                *SC = new_SC;
 642        else {
 643                for (end = *SC; SCNEXT(end); end = SCNEXT(end))
 644                        ;
 645                SCNEXT(end) = new_SC;
 646        }
 647}
 648
 649static inline struct scsi_cmnd *remove_first_SC(struct scsi_cmnd ** SC)
 650{
 651        struct scsi_cmnd *ptr;
 652
 653        ptr = *SC;
 654        if (ptr) {
 655                *SC = SCNEXT(*SC);
 656                SCNEXT(ptr)=NULL;
 657        }
 658        return ptr;
 659}
 660
 661static inline struct scsi_cmnd *remove_lun_SC(struct scsi_cmnd ** SC,
 662                                              int target, int lun)
 663{
 664        struct scsi_cmnd *ptr, *prev;
 665
 666        for (ptr = *SC, prev = NULL;
 667             ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
 668             prev = ptr, ptr = SCNEXT(ptr))
 669             ;
 670
 671        if (ptr) {
 672                if (prev)
 673                        SCNEXT(prev) = SCNEXT(ptr);
 674                else
 675                        *SC = SCNEXT(ptr);
 676
 677                SCNEXT(ptr)=NULL;
 678        }
 679
 680        return ptr;
 681}
 682
 683static inline struct scsi_cmnd *remove_SC(struct scsi_cmnd **SC,
 684                                          struct scsi_cmnd *SCp)
 685{
 686        struct scsi_cmnd *ptr, *prev;
 687
 688        for (ptr = *SC, prev = NULL;
 689             ptr && SCp!=ptr;
 690             prev = ptr, ptr = SCNEXT(ptr))
 691             ;
 692
 693        if (ptr) {
 694                if (prev)
 695                        SCNEXT(prev) = SCNEXT(ptr);
 696                else
 697                        *SC = SCNEXT(ptr);
 698
 699                SCNEXT(ptr)=NULL;
 700        }
 701
 702        return ptr;
 703}
 704
 705static irqreturn_t swintr(int irqno, void *dev_id)
 706{
 707        struct Scsi_Host *shpnt = dev_id;
 708
 709        HOSTDATA(shpnt)->swint++;
 710
 711        SETPORT(DMACNTRL0, INTEN);
 712        return IRQ_HANDLED;
 713}
 714
 715struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
 716{
 717        struct Scsi_Host *shpnt;
 718
 719        shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
 720        if (!shpnt) {
 721                printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
 722                return NULL;
 723        }
 724
 725        memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
 726        INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
 727
 728        /* need to have host registered before triggering any interrupt */
 729        list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
 730
 731        shpnt->io_port   = setup->io_port;
 732        shpnt->n_io_port = IO_RANGE;
 733        shpnt->irq       = setup->irq;
 734
 735        if (!setup->tc1550) {
 736                HOSTIOPORT0 = setup->io_port;
 737                HOSTIOPORT1 = setup->io_port;
 738        } else {
 739                HOSTIOPORT0 = setup->io_port+0x10;
 740                HOSTIOPORT1 = setup->io_port-0x10;
 741        }
 742
 743        spin_lock_init(&QLOCK);
 744        RECONNECT   = setup->reconnect;
 745        SYNCHRONOUS = setup->synchronous;
 746        PARITY      = setup->parity;
 747        DELAY       = setup->delay;
 748        EXT_TRANS   = setup->ext_trans;
 749
 750        SETPORT(SCSIID, setup->scsiid << 4);
 751        shpnt->this_id = setup->scsiid;
 752
 753        if (setup->reconnect)
 754                shpnt->can_queue = AHA152X_MAXQUEUE;
 755
 756        /* RESET OUT */
 757        printk("aha152x: resetting bus...\n");
 758        SETPORT(SCSISEQ, SCSIRSTO);
 759        mdelay(256);
 760        SETPORT(SCSISEQ, 0);
 761        mdelay(DELAY);
 762
 763        reset_ports(shpnt);
 764
 765        printk(KERN_INFO
 766               "aha152x%d%s: "
 767               "vital data: rev=%x, "
 768               "io=0x%03lx (0x%03lx/0x%03lx), "
 769               "irq=%d, "
 770               "scsiid=%d, "
 771               "reconnect=%s, "
 772               "parity=%s, "
 773               "synchronous=%s, "
 774               "delay=%d, "
 775               "extended translation=%s\n",
 776               shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
 777               GETPORT(REV) & 0x7,
 778               shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
 779               shpnt->irq,
 780               shpnt->this_id,
 781               RECONNECT ? "enabled" : "disabled",
 782               PARITY ? "enabled" : "disabled",
 783               SYNCHRONOUS ? "enabled" : "disabled",
 784               DELAY,
 785               EXT_TRANS ? "enabled" : "disabled");
 786
 787        /* not expecting any interrupts */
 788        SETPORT(SIMODE0, 0);
 789        SETPORT(SIMODE1, 0);
 790
 791        if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
 792                printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
 793                goto out_host_put;
 794        }
 795
 796        HOSTDATA(shpnt)->swint = 0;
 797
 798        printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
 799
 800        mb();
 801        SETPORT(DMACNTRL0, SWINT|INTEN);
 802        mdelay(1000);
 803        free_irq(shpnt->irq, shpnt);
 804
 805        if (!HOSTDATA(shpnt)->swint) {
 806                if (TESTHI(DMASTAT, INTSTAT)) {
 807                        printk("lost.\n");
 808                } else {
 809                        printk("failed.\n");
 810                }
 811
 812                SETPORT(DMACNTRL0, INTEN);
 813
 814                printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
 815                                "Please verify.\n", shpnt->host_no, shpnt->irq);
 816                goto out_host_put;
 817        }
 818        printk("ok.\n");
 819
 820
 821        /* clear interrupts */
 822        SETPORT(SSTAT0, 0x7f);
 823        SETPORT(SSTAT1, 0xef);
 824
 825        if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
 826                printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
 827                goto out_host_put;
 828        }
 829
 830        if( scsi_add_host(shpnt, NULL) ) {
 831                free_irq(shpnt->irq, shpnt);
 832                printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
 833                goto out_host_put;
 834        }
 835
 836        scsi_scan_host(shpnt);
 837
 838        return shpnt;
 839
 840out_host_put:
 841        list_del(&HOSTDATA(shpnt)->host_list);
 842        scsi_host_put(shpnt);
 843
 844        return NULL;
 845}
 846
 847void aha152x_release(struct Scsi_Host *shpnt)
 848{
 849        if (!shpnt)
 850                return;
 851
 852        scsi_remove_host(shpnt);
 853        if (shpnt->irq)
 854                free_irq(shpnt->irq, shpnt);
 855
 856#if !defined(AHA152X_PCMCIA)
 857        if (shpnt->io_port)
 858                release_region(shpnt->io_port, IO_RANGE);
 859#endif
 860
 861#ifdef __ISAPNP__
 862        if (HOSTDATA(shpnt)->pnpdev)
 863                pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
 864#endif
 865
 866        list_del(&HOSTDATA(shpnt)->host_list);
 867        scsi_host_put(shpnt);
 868}
 869
 870
 871/*
 872 * setup controller to generate interrupts depending
 873 * on current state (lock has to be acquired)
 874 *
 875 */
 876static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 877{
 878        if(CURRENT_SC) {
 879                CURRENT_SC->SCp.phase |= 1 << 16;
 880
 881                if(CURRENT_SC->SCp.phase & selecting) {
 882                        SETPORT(SSTAT1, SELTO);
 883                        SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
 884                        SETPORT(SIMODE1, ENSELTIMO);
 885                } else {
 886                        SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
 887                        SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
 888                }
 889        } else if(STATE==seldi) {
 890                SETPORT(SIMODE0, 0);
 891                SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
 892        } else {
 893                SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
 894                SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
 895        }
 896
 897        if(!HOSTDATA(shpnt)->in_intr)
 898                SETBITS(DMACNTRL0, INTEN);
 899
 900        return TESTHI(DMASTAT, INTSTAT);
 901}
 902
 903
 904/*
 905 *  Queue a command and setup interrupts for a free bus.
 906 */
 907static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
 908                                  struct completion *complete,
 909                                  int phase, void (*done)(struct scsi_cmnd *))
 910{
 911        struct Scsi_Host *shpnt = SCpnt->device->host;
 912        unsigned long flags;
 913
 914        SCpnt->scsi_done        = done;
 915        SCpnt->SCp.phase        = not_issued | phase;
 916        SCpnt->SCp.Status       = 0x1; /* Ilegal status by SCSI standard */
 917        SCpnt->SCp.Message      = 0;
 918        SCpnt->SCp.have_data_in = 0;
 919        SCpnt->SCp.sent_command = 0;
 920
 921        if(SCpnt->SCp.phase & (resetting|check_condition)) {
 922                if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
 923                        scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
 924                        return FAILED;
 925                }
 926        } else {
 927                SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
 928                if(!SCpnt->host_scribble) {
 929                        scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
 930                        return FAILED;
 931                }
 932        }
 933
 934        SCNEXT(SCpnt)           = NULL;
 935        SCSEM(SCpnt)            = complete;
 936
 937        /* setup scratch area
 938           SCp.ptr              : buffer pointer
 939           SCp.this_residual    : buffer length
 940           SCp.buffer           : next buffer
 941           SCp.phase            : current state of the command */
 942
 943        if ((phase & resetting) || !scsi_sglist(SCpnt)) {
 944                SCpnt->SCp.ptr           = NULL;
 945                SCpnt->SCp.this_residual = 0;
 946                scsi_set_resid(SCpnt, 0);
 947                SCpnt->SCp.buffer           = NULL;
 948        } else {
 949                scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
 950                SCpnt->SCp.buffer           = scsi_sglist(SCpnt);
 951                SCpnt->SCp.ptr              = SG_ADDRESS(SCpnt->SCp.buffer);
 952                SCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
 953        }
 954
 955        DO_LOCK(flags);
 956
 957#if defined(AHA152X_STAT)
 958        HOSTDATA(shpnt)->total_commands++;
 959#endif
 960
 961        /* Turn led on, when this is the first command. */
 962        HOSTDATA(shpnt)->commands++;
 963        if (HOSTDATA(shpnt)->commands==1)
 964                SETPORT(PORTA, 1);
 965
 966        append_SC(&ISSUE_SC, SCpnt);
 967
 968        if(!HOSTDATA(shpnt)->in_intr)
 969                setup_expected_interrupts(shpnt);
 970
 971        DO_UNLOCK(flags);
 972
 973        return 0;
 974}
 975
 976/*
 977 *  queue a command
 978 *
 979 */
 980static int aha152x_queue_lck(struct scsi_cmnd *SCpnt,
 981                             void (*done)(struct scsi_cmnd *))
 982{
 983        return aha152x_internal_queue(SCpnt, NULL, 0, done);
 984}
 985
 986static DEF_SCSI_QCMD(aha152x_queue)
 987
 988
 989/*
 990 *
 991 */
 992static void reset_done(struct scsi_cmnd *SCpnt)
 993{
 994        if(SCSEM(SCpnt)) {
 995                complete(SCSEM(SCpnt));
 996        } else {
 997                printk(KERN_ERR "aha152x: reset_done w/o completion\n");
 998        }
 999}
1000
1001/*
1002 *  Abort a command
1003 *
1004 */
1005static int aha152x_abort(struct scsi_cmnd *SCpnt)
1006{
1007        struct Scsi_Host *shpnt = SCpnt->device->host;
1008        struct scsi_cmnd *ptr;
1009        unsigned long flags;
1010
1011        DO_LOCK(flags);
1012
1013        ptr=remove_SC(&ISSUE_SC, SCpnt);
1014
1015        if(ptr) {
1016                HOSTDATA(shpnt)->commands--;
1017                if (!HOSTDATA(shpnt)->commands)
1018                        SETPORT(PORTA, 0);
1019                DO_UNLOCK(flags);
1020
1021                kfree(SCpnt->host_scribble);
1022                SCpnt->host_scribble=NULL;
1023
1024                return SUCCESS;
1025        }
1026
1027        DO_UNLOCK(flags);
1028
1029        /*
1030         * FIXME:
1031         * for current command: queue ABORT for message out and raise ATN
1032         * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1033         *
1034         */
1035
1036        scmd_printk(KERN_ERR, SCpnt,
1037                    "cannot abort running or disconnected command\n");
1038
1039        return FAILED;
1040}
1041
1042/*
1043 * Reset a device
1044 *
1045 */
1046static int aha152x_device_reset(struct scsi_cmnd * SCpnt)
1047{
1048        struct Scsi_Host *shpnt = SCpnt->device->host;
1049        DECLARE_COMPLETION(done);
1050        int ret, issued, disconnected;
1051        unsigned char old_cmd_len = SCpnt->cmd_len;
1052        unsigned long flags;
1053        unsigned long timeleft;
1054
1055        if(CURRENT_SC==SCpnt) {
1056                scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
1057                return FAILED;
1058        }
1059
1060        DO_LOCK(flags);
1061        issued       = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1062        disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1063        DO_UNLOCK(flags);
1064
1065        SCpnt->cmd_len         = 0;
1066
1067        aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1068
1069        timeleft = wait_for_completion_timeout(&done, 100*HZ);
1070        if (!timeleft) {
1071                /* remove command from issue queue */
1072                DO_LOCK(flags);
1073                remove_SC(&ISSUE_SC, SCpnt);
1074                DO_UNLOCK(flags);
1075        }
1076
1077        SCpnt->cmd_len         = old_cmd_len;
1078
1079        DO_LOCK(flags);
1080
1081        if(SCpnt->SCp.phase & resetted) {
1082                HOSTDATA(shpnt)->commands--;
1083                if (!HOSTDATA(shpnt)->commands)
1084                        SETPORT(PORTA, 0);
1085                kfree(SCpnt->host_scribble);
1086                SCpnt->host_scribble=NULL;
1087
1088                ret = SUCCESS;
1089        } else {
1090                /* requeue */
1091                if(!issued) {
1092                        append_SC(&ISSUE_SC, SCpnt);
1093                } else if(disconnected) {
1094                        append_SC(&DISCONNECTED_SC, SCpnt);
1095                }
1096
1097                ret = FAILED;
1098        }
1099
1100        DO_UNLOCK(flags);
1101        return ret;
1102}
1103
1104static void free_hard_reset_SCs(struct Scsi_Host *shpnt,
1105                                struct scsi_cmnd **SCs)
1106{
1107        struct scsi_cmnd *ptr;
1108
1109        ptr=*SCs;
1110        while(ptr) {
1111                struct scsi_cmnd *next;
1112
1113                if(SCDATA(ptr)) {
1114                        next = SCNEXT(ptr);
1115                } else {
1116                        scmd_printk(KERN_DEBUG, ptr,
1117                                    "queue corrupted at %p\n", ptr);
1118                        next = NULL;
1119                }
1120
1121                if (!ptr->device->soft_reset) {
1122                        remove_SC(SCs, ptr);
1123                        HOSTDATA(shpnt)->commands--;
1124                        kfree(ptr->host_scribble);
1125                        ptr->host_scribble=NULL;
1126                }
1127
1128                ptr = next;
1129        }
1130}
1131
1132/*
1133 * Reset the bus
1134 *
1135 * AIC-6260 has a hard reset (MRST signal), but apparently
1136 * one cannot trigger it via software. So live with
1137 * a soft reset; no-one seemed to have cared.
1138 */
1139static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1140{
1141        unsigned long flags;
1142
1143        DO_LOCK(flags);
1144
1145        free_hard_reset_SCs(shpnt, &ISSUE_SC);
1146        free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1147
1148        SETPORT(SCSISEQ, SCSIRSTO);
1149        mdelay(256);
1150        SETPORT(SCSISEQ, 0);
1151        mdelay(DELAY);
1152
1153        setup_expected_interrupts(shpnt);
1154        if(HOSTDATA(shpnt)->commands==0)
1155                SETPORT(PORTA, 0);
1156
1157        DO_UNLOCK(flags);
1158
1159        return SUCCESS;
1160}
1161
1162/*
1163 * Reset the bus
1164 *
1165 */
1166static int aha152x_bus_reset(struct scsi_cmnd *SCpnt)
1167{
1168        return aha152x_bus_reset_host(SCpnt->device->host);
1169}
1170
1171/*
1172 *  Restore default values to the AIC-6260 registers and reset the fifos
1173 *
1174 */
1175static void reset_ports(struct Scsi_Host *shpnt)
1176{
1177        unsigned long flags;
1178
1179        /* disable interrupts */
1180        SETPORT(DMACNTRL0, RSTFIFO);
1181
1182        SETPORT(SCSISEQ, 0);
1183
1184        SETPORT(SXFRCTL1, 0);
1185        SETPORT(SCSISIG, 0);
1186        SETRATE(0);
1187
1188        /* clear all interrupt conditions */
1189        SETPORT(SSTAT0, 0x7f);
1190        SETPORT(SSTAT1, 0xef);
1191
1192        SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1193
1194        SETPORT(DMACNTRL0, 0);
1195        SETPORT(DMACNTRL1, 0);
1196
1197        SETPORT(BRSTCNTRL, 0xf1);
1198
1199        /* clear SCSI fifos and transfer count */
1200        SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1201        SETPORT(SXFRCTL0, CH1);
1202
1203        DO_LOCK(flags);
1204        setup_expected_interrupts(shpnt);
1205        DO_UNLOCK(flags);
1206}
1207
1208/*
1209 * Reset the host (bus and controller)
1210 *
1211 */
1212int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1213{
1214        aha152x_bus_reset_host(shpnt);
1215        reset_ports(shpnt);
1216
1217        return SUCCESS;
1218}
1219
1220/*
1221 * Return the "logical geometry"
1222 *
1223 */
1224static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1225                sector_t capacity, int *info_array)
1226{
1227        struct Scsi_Host *shpnt = sdev->host;
1228
1229        /* try default translation */
1230        info_array[0] = 64;
1231        info_array[1] = 32;
1232        info_array[2] = (unsigned long)capacity / (64 * 32);
1233
1234        /* for disks >1GB do some guessing */
1235        if (info_array[2] >= 1024) {
1236                int info[3];
1237
1238                /* try to figure out the geometry from the partition table */
1239                if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1240                    !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1241                        if (EXT_TRANS) {
1242                                printk(KERN_NOTICE
1243                                       "aha152x: unable to verify geometry for disk with >1GB.\n"
1244                                       "         using extended translation.\n");
1245                                info_array[0] = 255;
1246                                info_array[1] = 63;
1247                                info_array[2] = (unsigned long)capacity / (255 * 63);
1248                        } else {
1249                                printk(KERN_NOTICE
1250                                       "aha152x: unable to verify geometry for disk with >1GB.\n"
1251                                       "         Using default translation. Please verify yourself.\n"
1252                                       "         Perhaps you need to enable extended translation in the driver.\n"
1253                                       "         See Documentation/scsi/aha152x.rst for details.\n");
1254                        }
1255                } else {
1256                        info_array[0] = info[0];
1257                        info_array[1] = info[1];
1258                        info_array[2] = info[2];
1259
1260                        if (info[0] == 255 && !EXT_TRANS) {
1261                                printk(KERN_NOTICE
1262                                       "aha152x: current partition table is using extended translation.\n"
1263                                       "         using it also, although it's not explicitly enabled.\n");
1264                        }
1265                }
1266        }
1267
1268        return 0;
1269}
1270
1271/*
1272 *  Internal done function
1273 *
1274 */
1275static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
1276                 unsigned char host_byte)
1277{
1278        if (CURRENT_SC) {
1279                if(DONE_SC)
1280                        scmd_printk(KERN_ERR, CURRENT_SC,
1281                                    "there's already a completed command %p "
1282                                    "- will cause abort\n", DONE_SC);
1283
1284                DONE_SC = CURRENT_SC;
1285                CURRENT_SC = NULL;
1286                set_status_byte(DONE_SC, status_byte);
1287                set_host_byte(DONE_SC, host_byte);
1288        } else
1289                printk(KERN_ERR "aha152x: done() called outside of command\n");
1290}
1291
1292static struct work_struct aha152x_tq;
1293
1294/*
1295 * Run service completions on the card with interrupts enabled.
1296 *
1297 */
1298static void run(struct work_struct *work)
1299{
1300        struct aha152x_hostdata *hd;
1301
1302        list_for_each_entry(hd, &aha152x_host_list, host_list) {
1303                struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1304
1305                is_complete(shost);
1306        }
1307}
1308
1309/*
1310 * Interrupt handler
1311 *
1312 */
1313static irqreturn_t intr(int irqno, void *dev_id)
1314{
1315        struct Scsi_Host *shpnt = dev_id;
1316        unsigned long flags;
1317        unsigned char rev, dmacntrl0;
1318
1319        /*
1320         * Read a couple of registers that are known to not be all 1's. If
1321         * we read all 1's (-1), that means that either:
1322         *
1323         * a. The host adapter chip has gone bad, and we cannot control it,
1324         *      OR
1325         * b. The host adapter is a PCMCIA card that has been ejected
1326         *
1327         * In either case, we cannot do anything with the host adapter at
1328         * this point in time. So just ignore the interrupt and return.
1329         * In the latter case, the interrupt might actually be meant for
1330         * someone else sharing this IRQ, and that driver will handle it.
1331         */
1332        rev = GETPORT(REV);
1333        dmacntrl0 = GETPORT(DMACNTRL0);
1334        if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1335                return IRQ_NONE;
1336
1337        if( TESTLO(DMASTAT, INTSTAT) )
1338                return IRQ_NONE;
1339
1340        /* no more interrupts from the controller, while we're busy.
1341           INTEN is restored by the BH handler */
1342        CLRBITS(DMACNTRL0, INTEN);
1343
1344        DO_LOCK(flags);
1345        if( HOSTDATA(shpnt)->service==0 ) {
1346                HOSTDATA(shpnt)->service=1;
1347
1348                /* Poke the BH handler */
1349                INIT_WORK(&aha152x_tq, run);
1350                schedule_work(&aha152x_tq);
1351        }
1352        DO_UNLOCK(flags);
1353
1354        return IRQ_HANDLED;
1355}
1356
1357/*
1358 * busfree phase
1359 * - handle completition/disconnection/error of current command
1360 * - start selection for next command (if any)
1361 */
1362static void busfree_run(struct Scsi_Host *shpnt)
1363{
1364        unsigned long flags;
1365#if defined(AHA152X_STAT)
1366        int action=0;
1367#endif
1368
1369        SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1370        SETPORT(SXFRCTL0, CH1);
1371
1372        SETPORT(SSTAT1, CLRBUSFREE);
1373
1374        if(CURRENT_SC) {
1375#if defined(AHA152X_STAT)
1376                action++;
1377#endif
1378                CURRENT_SC->SCp.phase &= ~syncneg;
1379
1380                if(CURRENT_SC->SCp.phase & completed) {
1381                        /* target sent COMMAND COMPLETE */
1382                        done(shpnt, CURRENT_SC->SCp.Status, DID_OK);
1383
1384                } else if(CURRENT_SC->SCp.phase & aborted) {
1385                        done(shpnt, CURRENT_SC->SCp.Status, DID_ABORT);
1386
1387                } else if(CURRENT_SC->SCp.phase & resetted) {
1388                        done(shpnt, CURRENT_SC->SCp.Status, DID_RESET);
1389
1390                } else if(CURRENT_SC->SCp.phase & disconnected) {
1391                        /* target sent DISCONNECT */
1392#if defined(AHA152X_STAT)
1393                        HOSTDATA(shpnt)->disconnections++;
1394#endif
1395                        append_SC(&DISCONNECTED_SC, CURRENT_SC);
1396                        CURRENT_SC->SCp.phase |= 1 << 16;
1397                        CURRENT_SC = NULL;
1398
1399                } else {
1400                        done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1401                }
1402#if defined(AHA152X_STAT)
1403        } else {
1404                HOSTDATA(shpnt)->busfree_without_old_command++;
1405#endif
1406        }
1407
1408        DO_LOCK(flags);
1409
1410        if(DONE_SC) {
1411#if defined(AHA152X_STAT)
1412                action++;
1413#endif
1414
1415                if(DONE_SC->SCp.phase & check_condition) {
1416                        struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1417                        struct aha152x_scdata *sc = SCDATA(cmd);
1418
1419                        scsi_eh_restore_cmnd(cmd, &sc->ses);
1420
1421                        cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1422
1423                        HOSTDATA(shpnt)->commands--;
1424                        if (!HOSTDATA(shpnt)->commands)
1425                                SETPORT(PORTA, 0);      /* turn led off */
1426                } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1427#if defined(AHA152X_STAT)
1428                        HOSTDATA(shpnt)->busfree_with_check_condition++;
1429#endif
1430
1431                        if(!(DONE_SC->SCp.phase & not_issued)) {
1432                                struct aha152x_scdata *sc;
1433                                struct scsi_cmnd *ptr = DONE_SC;
1434                                DONE_SC=NULL;
1435
1436                                sc = SCDATA(ptr);
1437                                /* It was allocated in aha152x_internal_queue? */
1438                                BUG_ON(!sc);
1439                                scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1440
1441                                DO_UNLOCK(flags);
1442                                aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1443                                DO_LOCK(flags);
1444                        }
1445                }
1446
1447                if(DONE_SC && DONE_SC->scsi_done) {
1448                        struct scsi_cmnd *ptr = DONE_SC;
1449                        DONE_SC=NULL;
1450
1451                        /* turn led off, when no commands are in the driver */
1452                        HOSTDATA(shpnt)->commands--;
1453                        if (!HOSTDATA(shpnt)->commands)
1454                                SETPORT(PORTA, 0);      /* turn led off */
1455
1456                        if(ptr->scsi_done != reset_done) {
1457                                kfree(ptr->host_scribble);
1458                                ptr->host_scribble=NULL;
1459                        }
1460
1461                        DO_UNLOCK(flags);
1462                        ptr->scsi_done(ptr);
1463                        DO_LOCK(flags);
1464                }
1465
1466                DONE_SC=NULL;
1467#if defined(AHA152X_STAT)
1468        } else {
1469                HOSTDATA(shpnt)->busfree_without_done_command++;
1470#endif
1471        }
1472
1473        if(ISSUE_SC)
1474                CURRENT_SC = remove_first_SC(&ISSUE_SC);
1475
1476        DO_UNLOCK(flags);
1477
1478        if(CURRENT_SC) {
1479#if defined(AHA152X_STAT)
1480                action++;
1481#endif
1482                CURRENT_SC->SCp.phase |= selecting;
1483
1484                /* clear selection timeout */
1485                SETPORT(SSTAT1, SELTO);
1486
1487                SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1488                SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1489                SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1490        } else {
1491#if defined(AHA152X_STAT)
1492                HOSTDATA(shpnt)->busfree_without_new_command++;
1493#endif
1494                SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1495        }
1496
1497#if defined(AHA152X_STAT)
1498        if(!action)
1499                HOSTDATA(shpnt)->busfree_without_any_action++;
1500#endif
1501}
1502
1503/*
1504 * Selection done (OUT)
1505 * - queue IDENTIFY message and SDTR to selected target for message out
1506 *   (ATN asserted automagically via ENAUTOATNO in busfree())
1507 */
1508static void seldo_run(struct Scsi_Host *shpnt)
1509{
1510        SETPORT(SCSISIG, 0);
1511        SETPORT(SSTAT1, CLRBUSFREE);
1512        SETPORT(SSTAT1, CLRPHASECHG);
1513
1514        CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1515
1516        SETPORT(SCSISEQ, 0);
1517
1518        if (TESTLO(SSTAT0, SELDO)) {
1519                scmd_printk(KERN_ERR, CURRENT_SC,
1520                            "aha152x: passing bus free condition\n");
1521                done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1522                return;
1523        }
1524
1525        SETPORT(SSTAT0, CLRSELDO);
1526
1527        ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1528
1529        if (CURRENT_SC->SCp.phase & aborting) {
1530                ADDMSGO(ABORT);
1531        } else if (CURRENT_SC->SCp.phase & resetting) {
1532                ADDMSGO(BUS_DEVICE_RESET);
1533        } else if (SYNCNEG==0 && SYNCHRONOUS) {
1534                CURRENT_SC->SCp.phase |= syncneg;
1535                MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1536                SYNCNEG=1;              /* negotiation in progress */
1537        }
1538
1539        SETRATE(SYNCRATE);
1540}
1541
1542/*
1543 * Selection timeout
1544 * - return command to mid-level with failure cause
1545 *
1546 */
1547static void selto_run(struct Scsi_Host *shpnt)
1548{
1549        SETPORT(SCSISEQ, 0);
1550        SETPORT(SSTAT1, CLRSELTIMO);
1551
1552        if (!CURRENT_SC)
1553                return;
1554
1555        CURRENT_SC->SCp.phase &= ~selecting;
1556
1557        if (CURRENT_SC->SCp.phase & aborted)
1558                done(shpnt, SAM_STAT_GOOD, DID_ABORT);
1559        else if (TESTLO(SSTAT0, SELINGO))
1560                done(shpnt, SAM_STAT_GOOD, DID_BUS_BUSY);
1561        else
1562                /* ARBITRATION won, but SELECTION failed */
1563                done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1564}
1565
1566/*
1567 * Selection in done
1568 * - put current command back to issue queue
1569 *   (reconnection of a disconnected nexus instead
1570 *    of successful selection out)
1571 *
1572 */
1573static void seldi_run(struct Scsi_Host *shpnt)
1574{
1575        int selid;
1576        int target;
1577        unsigned long flags;
1578
1579        SETPORT(SCSISIG, 0);
1580        SETPORT(SSTAT0, CLRSELDI);
1581        SETPORT(SSTAT1, CLRBUSFREE);
1582        SETPORT(SSTAT1, CLRPHASECHG);
1583
1584        if(CURRENT_SC) {
1585                if(!(CURRENT_SC->SCp.phase & not_issued))
1586                        scmd_printk(KERN_ERR, CURRENT_SC,
1587                                    "command should not have been issued yet\n");
1588
1589                DO_LOCK(flags);
1590                append_SC(&ISSUE_SC, CURRENT_SC);
1591                DO_UNLOCK(flags);
1592
1593                CURRENT_SC = NULL;
1594        }
1595
1596        if (!DISCONNECTED_SC)
1597                return;
1598
1599        RECONN_TARGET=-1;
1600
1601        selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1602
1603        if (selid==0) {
1604                shost_printk(KERN_INFO, shpnt,
1605                             "target id unknown (%02x)\n", selid);
1606                return;
1607        }
1608
1609        for(target=7; !(selid & (1 << target)); target--)
1610                ;
1611
1612        if(selid & ~(1 << target)) {
1613                shost_printk(KERN_INFO, shpnt,
1614                             "multiple targets reconnected (%02x)\n", selid);
1615        }
1616
1617
1618        SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1619        SETPORT(SCSISEQ, 0);
1620
1621        SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1622
1623        RECONN_TARGET=target;
1624}
1625
1626/*
1627 * message in phase
1628 * - handle initial message after reconnection to identify
1629 *   reconnecting nexus
1630 * - queue command on DISCONNECTED_SC on DISCONNECT message
1631 * - set completed flag on COMMAND COMPLETE
1632 *   (other completition code moved to busfree_run)
1633 * - handle response to SDTR
1634 * - clear synchronous transfer agreements on BUS RESET
1635 *
1636 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1637 *
1638 */
1639static void msgi_run(struct Scsi_Host *shpnt)
1640{
1641        for(;;) {
1642                int sstat1 = GETPORT(SSTAT1);
1643
1644                if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1645                        return;
1646
1647                if (TESTLO(SSTAT0, SPIORDY))
1648                        return;
1649
1650                ADDMSGI(GETPORT(SCSIDAT));
1651
1652                if(!CURRENT_SC) {
1653                        if(LASTSTATE!=seldi) {
1654                                shost_printk(KERN_ERR, shpnt,
1655                                             "message in w/o current command"
1656                                             " not after reselection\n");
1657                        }
1658
1659                        /*
1660                         * Handle reselection
1661                         */
1662                        if(!(MSGI(0) & IDENTIFY_BASE)) {
1663                                shost_printk(KERN_ERR, shpnt,
1664                                             "target didn't identify after reselection\n");
1665                                continue;
1666                        }
1667
1668                        CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1669
1670                        if (!CURRENT_SC) {
1671                                show_queues(shpnt);
1672                                shost_printk(KERN_ERR, shpnt,
1673                                             "no disconnected command"
1674                                             " for target %d/%d\n",
1675                                             RECONN_TARGET, MSGI(0) & 0x3f);
1676                                continue;
1677                        }
1678
1679                        CURRENT_SC->SCp.Message = MSGI(0);
1680                        CURRENT_SC->SCp.phase &= ~disconnected;
1681
1682                        MSGILEN=0;
1683
1684                        /* next message if any */
1685                        continue;
1686                }
1687
1688                CURRENT_SC->SCp.Message = MSGI(0);
1689
1690                switch (MSGI(0)) {
1691                case DISCONNECT:
1692                        if (!RECONNECT)
1693                                scmd_printk(KERN_WARNING, CURRENT_SC,
1694                                            "target was not allowed to disconnect\n");
1695
1696                        CURRENT_SC->SCp.phase |= disconnected;
1697                        break;
1698
1699                case COMMAND_COMPLETE:
1700                        CURRENT_SC->SCp.phase |= completed;
1701                        break;
1702
1703                case MESSAGE_REJECT:
1704                        if (SYNCNEG==1) {
1705                                scmd_printk(KERN_INFO, CURRENT_SC,
1706                                            "Synchronous Data Transfer Request"
1707                                            " was rejected\n");
1708                                SYNCNEG=2;      /* negotiation completed */
1709                        } else
1710                                scmd_printk(KERN_INFO, CURRENT_SC,
1711                                            "inbound message (MESSAGE REJECT)\n");
1712                        break;
1713
1714                case SAVE_POINTERS:
1715                        break;
1716
1717                case RESTORE_POINTERS:
1718                        break;
1719
1720                case EXTENDED_MESSAGE:
1721                        if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1722                                /* not yet completed */
1723                                continue;
1724                        }
1725
1726                        switch (MSGI(2)) {
1727                        case EXTENDED_SDTR:
1728                                {
1729                                        long ticks;
1730
1731                                        if (MSGI(1) != 3) {
1732                                                scmd_printk(KERN_ERR, CURRENT_SC,
1733                                                            "SDTR message length!=3\n");
1734                                                break;
1735                                        }
1736
1737                                        if (!HOSTDATA(shpnt)->synchronous)
1738                                                break;
1739
1740                                        printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1741                                        spi_print_msg(&MSGI(0));
1742                                        printk("\n");
1743
1744                                        ticks = (MSGI(3) * 4 + 49) / 50;
1745
1746                                        if (syncneg) {
1747                                                /* negotiation in progress */
1748                                                if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1749                                                        ADDMSGO(MESSAGE_REJECT);
1750                                                        scmd_printk(KERN_INFO,
1751                                                                    CURRENT_SC,
1752                                                                    "received Synchronous Data Transfer Request invalid - rejected\n");
1753                                                        break;
1754                                                }
1755
1756                                                SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1757                                        } else if (ticks <= 9 && MSGI(4) >= 1) {
1758                                                ADDMSGO(EXTENDED_MESSAGE);
1759                                                ADDMSGO(3);
1760                                                ADDMSGO(EXTENDED_SDTR);
1761                                                if (ticks < 4) {
1762                                                        ticks = 4;
1763                                                        ADDMSGO(50);
1764                                                } else
1765                                                        ADDMSGO(MSGI(3));
1766
1767                                                if (MSGI(4) > 8)
1768                                                        MSGI(4) = 8;
1769
1770                                                ADDMSGO(MSGI(4));
1771
1772                                                SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1773                                        } else {
1774                                                /* requested SDTR is too slow, do it asynchronously */
1775                                                scmd_printk(KERN_INFO,
1776                                                            CURRENT_SC,
1777                                                            "Synchronous Data Transfer Request too slow - Rejecting\n");
1778                                                ADDMSGO(MESSAGE_REJECT);
1779                                        }
1780
1781                                        /* negotiation completed */
1782                                        SYNCNEG=2;
1783                                        SETRATE(SYNCRATE);
1784                                }
1785                                break;
1786
1787                        case BUS_DEVICE_RESET:
1788                                {
1789                                        int i;
1790
1791                                        for(i=0; i<8; i++) {
1792                                                HOSTDATA(shpnt)->syncrate[i]=0;
1793                                                HOSTDATA(shpnt)->syncneg[i]=0;
1794                                        }
1795
1796                                }
1797                                break;
1798
1799                        case EXTENDED_MODIFY_DATA_POINTER:
1800                        case EXTENDED_EXTENDED_IDENTIFY:
1801                        case EXTENDED_WDTR:
1802                        default:
1803                                ADDMSGO(MESSAGE_REJECT);
1804                                break;
1805                        }
1806                        break;
1807                }
1808
1809                MSGILEN=0;
1810        }
1811}
1812
1813static void msgi_end(struct Scsi_Host *shpnt)
1814{
1815        if(MSGILEN>0)
1816                scmd_printk(KERN_WARNING, CURRENT_SC,
1817                            "target left before message completed (%d)\n",
1818                            MSGILEN);
1819
1820        if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
1821                SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1822}
1823
1824/*
1825 * message out phase
1826 *
1827 */
1828static void msgo_init(struct Scsi_Host *shpnt)
1829{
1830        if(MSGOLEN==0) {
1831                if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
1832                        ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1833                } else {
1834                        scmd_printk(KERN_INFO, CURRENT_SC,
1835                                    "unexpected MESSAGE OUT phase; rejecting\n");
1836                        ADDMSGO(MESSAGE_REJECT);
1837                }
1838        }
1839
1840}
1841
1842/*
1843 * message out phase
1844 *
1845 */
1846static void msgo_run(struct Scsi_Host *shpnt)
1847{
1848        while(MSGO_I<MSGOLEN) {
1849                if (TESTLO(SSTAT0, SPIORDY))
1850                        return;
1851
1852                if (MSGO_I==MSGOLEN-1) {
1853                        /* Leave MESSAGE OUT after transfer */
1854                        SETPORT(SSTAT1, CLRATNO);
1855                }
1856
1857
1858                if (MSGO(MSGO_I) & IDENTIFY_BASE)
1859                        CURRENT_SC->SCp.phase |= identified;
1860
1861                if (MSGO(MSGO_I)==ABORT)
1862                        CURRENT_SC->SCp.phase |= aborted;
1863
1864                if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
1865                        CURRENT_SC->SCp.phase |= resetted;
1866
1867                SETPORT(SCSIDAT, MSGO(MSGO_I++));
1868        }
1869}
1870
1871static void msgo_end(struct Scsi_Host *shpnt)
1872{
1873        if(MSGO_I<MSGOLEN) {
1874                scmd_printk(KERN_ERR, CURRENT_SC,
1875                            "message sent incompletely (%d/%d)\n",
1876                            MSGO_I, MSGOLEN);
1877                if(SYNCNEG==1) {
1878                        scmd_printk(KERN_INFO, CURRENT_SC,
1879                                    "Synchronous Data Transfer Request was rejected\n");
1880                        SYNCNEG=2;
1881                }
1882        }
1883
1884        MSGO_I  = 0;
1885        MSGOLEN = 0;
1886}
1887
1888/*
1889 * command phase
1890 *
1891 */
1892static void cmd_init(struct Scsi_Host *shpnt)
1893{
1894        if (CURRENT_SC->SCp.sent_command) {
1895                scmd_printk(KERN_ERR, CURRENT_SC,
1896                            "command already sent\n");
1897                done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1898                return;
1899        }
1900
1901        CMD_I=0;
1902}
1903
1904/*
1905 * command phase
1906 *
1907 */
1908static void cmd_run(struct Scsi_Host *shpnt)
1909{
1910        while(CMD_I<CURRENT_SC->cmd_len) {
1911                if (TESTLO(SSTAT0, SPIORDY))
1912                        return;
1913
1914                SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
1915        }
1916}
1917
1918static void cmd_end(struct Scsi_Host *shpnt)
1919{
1920        if(CMD_I<CURRENT_SC->cmd_len)
1921                scmd_printk(KERN_ERR, CURRENT_SC,
1922                            "command sent incompletely (%d/%d)\n",
1923                            CMD_I, CURRENT_SC->cmd_len);
1924        else
1925                CURRENT_SC->SCp.sent_command++;
1926}
1927
1928/*
1929 * status phase
1930 *
1931 */
1932static void status_run(struct Scsi_Host *shpnt)
1933{
1934        if (TESTLO(SSTAT0, SPIORDY))
1935                return;
1936
1937        CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
1938
1939}
1940
1941/*
1942 * data in phase
1943 *
1944 */
1945static void datai_init(struct Scsi_Host *shpnt)
1946{
1947        SETPORT(DMACNTRL0, RSTFIFO);
1948        SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
1949
1950        SETPORT(SXFRCTL0, CH1|CLRSTCNT);
1951        SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
1952
1953        SETPORT(SIMODE0, 0);
1954        SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
1955
1956        DATA_LEN=0;
1957}
1958
1959static void datai_run(struct Scsi_Host *shpnt)
1960{
1961        unsigned long the_time;
1962        int fifodata, data_count;
1963
1964        /*
1965         * loop while the phase persists or the fifos are not empty
1966         *
1967         */
1968        while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
1969                /* FIXME: maybe this should be done by setting up
1970                 * STCNT to trigger ENSWRAP interrupt, instead of
1971                 * polling for DFIFOFULL
1972                 */
1973                the_time=jiffies + 100*HZ;
1974                while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
1975                        barrier();
1976
1977                if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
1978                        scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
1979                        break;
1980                }
1981
1982                if(TESTHI(DMASTAT, DFIFOFULL)) {
1983                        fifodata = 128;
1984                } else {
1985                        the_time=jiffies + 100*HZ;
1986                        while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
1987                                barrier();
1988
1989                        if(TESTLO(SSTAT2, SEMPTY)) {
1990                                scmd_printk(KERN_ERR, CURRENT_SC,
1991                                            "datai sempty timeout");
1992                                break;
1993                        }
1994
1995                        fifodata = GETPORT(FIFOSTAT);
1996                }
1997
1998                if(CURRENT_SC->SCp.this_residual>0) {
1999                        while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2000                                data_count = fifodata > CURRENT_SC->SCp.this_residual ?
2001                                                CURRENT_SC->SCp.this_residual :
2002                                                fifodata;
2003                                fifodata -= data_count;
2004
2005                                if (data_count & 1) {
2006                                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
2007                                        *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2008                                        CURRENT_SC->SCp.this_residual--;
2009                                        DATA_LEN++;
2010                                        SETPORT(DMACNTRL0, ENDMA);
2011                                }
2012
2013                                if (data_count > 1) {
2014                                        data_count >>= 1;
2015                                        insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2016                                        CURRENT_SC->SCp.ptr += 2 * data_count;
2017                                        CURRENT_SC->SCp.this_residual -= 2 * data_count;
2018                                        DATA_LEN += 2 * data_count;
2019                                }
2020
2021                                if (CURRENT_SC->SCp.this_residual == 0 &&
2022                                    !sg_is_last(CURRENT_SC->SCp.buffer)) {
2023                                        /* advance to next buffer */
2024                                        CURRENT_SC->SCp.buffer = sg_next(CURRENT_SC->SCp.buffer);
2025                                        CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2026                                        CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2027                                }
2028                        }
2029                } else if (fifodata > 0) {
2030                        scmd_printk(KERN_ERR, CURRENT_SC,
2031                                    "no buffers left for %d(%d) bytes"
2032                                    " (data overrun!?)\n",
2033                                    fifodata, GETPORT(FIFOSTAT));
2034                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
2035                        while(fifodata>0) {
2036                                GETPORT(DATAPORT);
2037                                fifodata--;
2038                                DATA_LEN++;
2039                        }
2040                        SETPORT(DMACNTRL0, ENDMA|_8BIT);
2041                }
2042        }
2043
2044        if(TESTLO(DMASTAT, INTSTAT) ||
2045           TESTLO(DMASTAT, DFIFOEMP) ||
2046           TESTLO(SSTAT2, SEMPTY) ||
2047           GETPORT(FIFOSTAT)>0) {
2048                /*
2049                 * something went wrong, if there's something left in the fifos
2050                 * or the phase didn't change
2051                 */
2052                scmd_printk(KERN_ERR, CURRENT_SC,
2053                            "fifos should be empty and phase should have changed\n");
2054        }
2055
2056        if(DATA_LEN!=GETSTCNT()) {
2057                scmd_printk(KERN_ERR, CURRENT_SC,
2058                            "manual transfer count differs from automatic "
2059                            "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2060                            DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2061                            GETPORT(FIFOSTAT));
2062                mdelay(10000);
2063        }
2064}
2065
2066static void datai_end(struct Scsi_Host *shpnt)
2067{
2068        CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2069
2070        SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2071        SETPORT(DMACNTRL0, 0);
2072}
2073
2074/*
2075 * data out phase
2076 *
2077 */
2078static void datao_init(struct Scsi_Host *shpnt)
2079{
2080        SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2081        SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2082
2083        SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2084        SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2085
2086        SETPORT(SIMODE0, 0);
2087        SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2088
2089        DATA_LEN = scsi_get_resid(CURRENT_SC);
2090}
2091
2092static void datao_run(struct Scsi_Host *shpnt)
2093{
2094        unsigned long the_time;
2095        int data_count;
2096
2097        /* until phase changes or all data sent */
2098        while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2099                data_count = 128;
2100                if(data_count > CURRENT_SC->SCp.this_residual)
2101                        data_count=CURRENT_SC->SCp.this_residual;
2102
2103                if(TESTLO(DMASTAT, DFIFOEMP)) {
2104                        scmd_printk(KERN_ERR, CURRENT_SC,
2105                                    "datao fifo not empty (%d)",
2106                                    GETPORT(FIFOSTAT));
2107                        break;
2108                }
2109
2110                if(data_count & 1) {
2111                        SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2112                        SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2113                        CURRENT_SC->SCp.this_residual--;
2114                        CMD_INC_RESID(CURRENT_SC, -1);
2115                        SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2116                }
2117
2118                if(data_count > 1) {
2119                        data_count >>= 1;
2120                        outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2121                        CURRENT_SC->SCp.ptr           += 2 * data_count;
2122                        CURRENT_SC->SCp.this_residual -= 2 * data_count;
2123                        CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2124                }
2125
2126                if (CURRENT_SC->SCp.this_residual == 0 &&
2127                    !sg_is_last(CURRENT_SC->SCp.buffer)) {
2128                        /* advance to next buffer */
2129                        CURRENT_SC->SCp.buffer = sg_next(CURRENT_SC->SCp.buffer);
2130                        CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2131                        CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2132                }
2133
2134                the_time=jiffies + 100*HZ;
2135                while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2136                        barrier();
2137
2138                if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2139                        scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2140                        break;
2141                }
2142        }
2143}
2144
2145static void datao_end(struct Scsi_Host *shpnt)
2146{
2147        if(TESTLO(DMASTAT, DFIFOEMP)) {
2148                u32 datao_cnt = GETSTCNT();
2149                int datao_out = DATA_LEN - scsi_get_resid(CURRENT_SC);
2150                int done;
2151                struct scatterlist *sg = scsi_sglist(CURRENT_SC);
2152
2153                CMD_INC_RESID(CURRENT_SC, datao_out - datao_cnt);
2154
2155                done = scsi_bufflen(CURRENT_SC) - scsi_get_resid(CURRENT_SC);
2156                /* Locate the first SG entry not yet sent */
2157                while (done > 0 && !sg_is_last(sg)) {
2158                        if (done < sg->length)
2159                                break;
2160                        done -= sg->length;
2161                        sg = sg_next(sg);
2162                }
2163
2164                CURRENT_SC->SCp.buffer = sg;
2165                CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) + done;
2166                CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length -
2167                        done;
2168        }
2169
2170        SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2171        SETPORT(SXFRCTL0, CH1);
2172
2173        SETPORT(DMACNTRL0, 0);
2174}
2175
2176/*
2177 * figure out what state we're in
2178 *
2179 */
2180static int update_state(struct Scsi_Host *shpnt)
2181{
2182        int dataphase=0;
2183        unsigned int stat0 = GETPORT(SSTAT0);
2184        unsigned int stat1 = GETPORT(SSTAT1);
2185
2186        PREVSTATE = STATE;
2187        STATE=unknown;
2188
2189        if(stat1 & SCSIRSTI) {
2190                STATE=rsti;
2191                SETPORT(SCSISEQ,0);
2192                SETPORT(SSTAT1,SCSIRSTI);
2193        } else if (stat0 & SELDI && PREVSTATE == busfree) {
2194                STATE=seldi;
2195        } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2196                STATE=seldo;
2197        } else if(stat1 & SELTO) {
2198                STATE=selto;
2199        } else if(stat1 & BUSFREE) {
2200                STATE=busfree;
2201                SETPORT(SSTAT1,BUSFREE);
2202        } else if(stat1 & SCSIPERR) {
2203                STATE=parerr;
2204                SETPORT(SSTAT1,SCSIPERR);
2205        } else if(stat1 & REQINIT) {
2206                switch(GETPORT(SCSISIG) & P_MASK) {
2207                case P_MSGI:    STATE=msgi;     break;
2208                case P_MSGO:    STATE=msgo;     break;
2209                case P_DATAO:   STATE=datao;    break;
2210                case P_DATAI:   STATE=datai;    break;
2211                case P_STATUS:  STATE=status;   break;
2212                case P_CMD:     STATE=cmd;      break;
2213                }
2214                dataphase=1;
2215        }
2216
2217        if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2218                scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2219        }
2220
2221        if(STATE!=PREVSTATE) {
2222                LASTSTATE=PREVSTATE;
2223        }
2224
2225        return dataphase;
2226}
2227
2228/*
2229 * handle parity error
2230 *
2231 * FIXME: in which phase?
2232 *
2233 */
2234static void parerr_run(struct Scsi_Host *shpnt)
2235{
2236        scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2237        done(shpnt, SAM_STAT_GOOD, DID_PARITY);
2238}
2239
2240/*
2241 * handle reset in
2242 *
2243 */
2244static void rsti_run(struct Scsi_Host *shpnt)
2245{
2246        struct scsi_cmnd *ptr;
2247
2248        shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2249
2250        ptr=DISCONNECTED_SC;
2251        while(ptr) {
2252                struct scsi_cmnd *next = SCNEXT(ptr);
2253
2254                if (!ptr->device->soft_reset) {
2255                        remove_SC(&DISCONNECTED_SC, ptr);
2256
2257                        kfree(ptr->host_scribble);
2258                        ptr->host_scribble=NULL;
2259
2260                        set_host_byte(ptr, DID_RESET);
2261                        ptr->scsi_done(ptr);
2262                }
2263
2264                ptr = next;
2265        }
2266
2267        if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2268                done(shpnt, SAM_STAT_GOOD, DID_RESET);
2269}
2270
2271
2272/*
2273 * bottom-half handler
2274 *
2275 */
2276static void is_complete(struct Scsi_Host *shpnt)
2277{
2278        int dataphase;
2279        unsigned long flags;
2280        int pending;
2281
2282        if(!shpnt)
2283                return;
2284
2285        DO_LOCK(flags);
2286
2287        if( HOSTDATA(shpnt)->service==0 )  {
2288                DO_UNLOCK(flags);
2289                return;
2290        }
2291
2292        HOSTDATA(shpnt)->service = 0;
2293
2294        if(HOSTDATA(shpnt)->in_intr) {
2295                DO_UNLOCK(flags);
2296                /* aha152x_error never returns.. */
2297                aha152x_error(shpnt, "bottom-half already running!?");
2298        }
2299        HOSTDATA(shpnt)->in_intr++;
2300
2301        /*
2302         * loop while there are interrupt conditions pending
2303         *
2304         */
2305        do {
2306                unsigned long start = jiffies;
2307                DO_UNLOCK(flags);
2308
2309                dataphase=update_state(shpnt);
2310
2311                /*
2312                 * end previous state
2313                 *
2314                 */
2315                if(PREVSTATE!=STATE && states[PREVSTATE].end)
2316                        states[PREVSTATE].end(shpnt);
2317
2318                /*
2319                 * disable SPIO mode if previous phase used it
2320                 * and this one doesn't
2321                 *
2322                 */
2323                if(states[PREVSTATE].spio && !states[STATE].spio) {
2324                        SETPORT(SXFRCTL0, CH1);
2325                        SETPORT(DMACNTRL0, 0);
2326                        if(CURRENT_SC)
2327                                CURRENT_SC->SCp.phase &= ~spiordy;
2328                }
2329
2330                /*
2331                 * accept current dataphase phase
2332                 *
2333                 */
2334                if(dataphase) {
2335                        SETPORT(SSTAT0, REQINIT);
2336                        SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2337                        SETPORT(SSTAT1, PHASECHG);
2338                }
2339
2340                /*
2341                 * enable SPIO mode if previous didn't use it
2342                 * and this one does
2343                 *
2344                 */
2345                if(!states[PREVSTATE].spio && states[STATE].spio) {
2346                        SETPORT(DMACNTRL0, 0);
2347                        SETPORT(SXFRCTL0, CH1|SPIOEN);
2348                        if(CURRENT_SC)
2349                                CURRENT_SC->SCp.phase |= spiordy;
2350                }
2351
2352                /*
2353                 * initialize for new state
2354                 *
2355                 */
2356                if(PREVSTATE!=STATE && states[STATE].init)
2357                        states[STATE].init(shpnt);
2358
2359                /*
2360                 * handle current state
2361                 *
2362                 */
2363                if(states[STATE].run)
2364                        states[STATE].run(shpnt);
2365                else
2366                        scmd_printk(KERN_ERR, CURRENT_SC,
2367                                    "unexpected state (%x)\n", STATE);
2368
2369                /*
2370                 * setup controller to interrupt on
2371                 * the next expected condition and
2372                 * loop if it's already there
2373                 *
2374                 */
2375                DO_LOCK(flags);
2376                pending=setup_expected_interrupts(shpnt);
2377#if defined(AHA152X_STAT)
2378                HOSTDATA(shpnt)->count[STATE]++;
2379                if(PREVSTATE!=STATE)
2380                        HOSTDATA(shpnt)->count_trans[STATE]++;
2381                HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2382#endif
2383
2384        } while(pending);
2385
2386        /*
2387         * enable interrupts and leave bottom-half
2388         *
2389         */
2390        HOSTDATA(shpnt)->in_intr--;
2391        SETBITS(DMACNTRL0, INTEN);
2392        DO_UNLOCK(flags);
2393}
2394
2395
2396/*
2397 * Dump the current driver status and panic
2398 */
2399static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2400{
2401        shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2402        show_queues(shpnt);
2403        panic("aha152x panic\n");
2404}
2405
2406/*
2407 * display enabled interrupts
2408 */
2409static void disp_enintr(struct Scsi_Host *shpnt)
2410{
2411        int s0, s1;
2412
2413        s0 = GETPORT(SIMODE0);
2414        s1 = GETPORT(SIMODE1);
2415
2416        shost_printk(KERN_DEBUG, shpnt,
2417                     "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2418                     (s0 & ENSELDO) ? "ENSELDO " : "",
2419                     (s0 & ENSELDI) ? "ENSELDI " : "",
2420                     (s0 & ENSELINGO) ? "ENSELINGO " : "",
2421                     (s0 & ENSWRAP) ? "ENSWRAP " : "",
2422                     (s0 & ENSDONE) ? "ENSDONE " : "",
2423                     (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2424                     (s0 & ENDMADONE) ? "ENDMADONE " : "",
2425                     (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2426                     (s1 & ENATNTARG) ? "ENATNTARG " : "",
2427                     (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2428                     (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2429                     (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2430                     (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2431                     (s1 & ENREQINIT) ? "ENREQINIT " : "");
2432}
2433
2434/*
2435 * Show the command data of a command
2436 */
2437static void show_command(struct scsi_cmnd *ptr)
2438{
2439        scsi_print_command(ptr);
2440        scmd_printk(KERN_DEBUG, ptr,
2441                    "request_bufflen=%d; resid=%d; "
2442                    "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2443                    scsi_bufflen(ptr), scsi_get_resid(ptr),
2444                    (ptr->SCp.phase & not_issued) ? "not issued|" : "",
2445                    (ptr->SCp.phase & selecting) ? "selecting|" : "",
2446                    (ptr->SCp.phase & identified) ? "identified|" : "",
2447                    (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
2448                    (ptr->SCp.phase & completed) ? "completed|" : "",
2449                    (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
2450                    (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
2451                    (ptr->SCp.phase & aborted) ? "aborted|" : "",
2452                    (ptr->SCp.phase & resetted) ? "resetted|" : "",
2453                    (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
2454}
2455
2456/*
2457 * Dump the queued data
2458 */
2459static void show_queues(struct Scsi_Host *shpnt)
2460{
2461        struct scsi_cmnd *ptr;
2462        unsigned long flags;
2463
2464        DO_LOCK(flags);
2465        printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2466        for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2467                show_command(ptr);
2468        DO_UNLOCK(flags);
2469
2470        printk(KERN_DEBUG "current_SC:\n");
2471        if (CURRENT_SC)
2472                show_command(CURRENT_SC);
2473        else
2474                printk(KERN_DEBUG "none\n");
2475
2476        printk(KERN_DEBUG "disconnected_SC:\n");
2477        for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2478                show_command(ptr);
2479
2480        disp_enintr(shpnt);
2481}
2482
2483static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
2484{
2485        int i;
2486
2487        seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2488                ptr, ptr->device->id, (u8)ptr->device->lun);
2489
2490        for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2491                seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2492
2493        seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2494                scsi_get_resid(ptr), ptr->SCp.this_residual,
2495                sg_nents(ptr->SCp.buffer) - 1);
2496
2497        if (ptr->SCp.phase & not_issued)
2498                seq_puts(m, "not issued|");
2499        if (ptr->SCp.phase & selecting)
2500                seq_puts(m, "selecting|");
2501        if (ptr->SCp.phase & disconnected)
2502                seq_puts(m, "disconnected|");
2503        if (ptr->SCp.phase & aborted)
2504                seq_puts(m, "aborted|");
2505        if (ptr->SCp.phase & identified)
2506                seq_puts(m, "identified|");
2507        if (ptr->SCp.phase & completed)
2508                seq_puts(m, "completed|");
2509        if (ptr->SCp.phase & spiordy)
2510                seq_puts(m, "spiordy|");
2511        if (ptr->SCp.phase & syncneg)
2512                seq_puts(m, "syncneg|");
2513        seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2514}
2515
2516static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2517{
2518        int s;
2519
2520        seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2521
2522        s = GETPORT(SCSISEQ);
2523        seq_puts(m, "SCSISEQ( ");
2524        if (s & TEMODEO)
2525                seq_puts(m, "TARGET MODE ");
2526        if (s & ENSELO)
2527                seq_puts(m, "SELO ");
2528        if (s & ENSELI)
2529                seq_puts(m, "SELI ");
2530        if (s & ENRESELI)
2531                seq_puts(m, "RESELI ");
2532        if (s & ENAUTOATNO)
2533                seq_puts(m, "AUTOATNO ");
2534        if (s & ENAUTOATNI)
2535                seq_puts(m, "AUTOATNI ");
2536        if (s & ENAUTOATNP)
2537                seq_puts(m, "AUTOATNP ");
2538        if (s & SCSIRSTO)
2539                seq_puts(m, "SCSIRSTO ");
2540        seq_puts(m, ");");
2541
2542        seq_puts(m, " SCSISIG(");
2543        s = GETPORT(SCSISIG);
2544        switch (s & P_MASK) {
2545        case P_DATAO:
2546                seq_puts(m, "DATA OUT");
2547                break;
2548        case P_DATAI:
2549                seq_puts(m, "DATA IN");
2550                break;
2551        case P_CMD:
2552                seq_puts(m, "COMMAND");
2553                break;
2554        case P_STATUS:
2555                seq_puts(m, "STATUS");
2556                break;
2557        case P_MSGO:
2558                seq_puts(m, "MESSAGE OUT");
2559                break;
2560        case P_MSGI:
2561                seq_puts(m, "MESSAGE IN");
2562                break;
2563        default:
2564                seq_puts(m, "*invalid*");
2565                break;
2566        }
2567
2568        seq_puts(m, "); ");
2569
2570        seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2571
2572        seq_puts(m, "SSTAT( ");
2573        s = GETPORT(SSTAT0);
2574        if (s & TARGET)
2575                seq_puts(m, "TARGET ");
2576        if (s & SELDO)
2577                seq_puts(m, "SELDO ");
2578        if (s & SELDI)
2579                seq_puts(m, "SELDI ");
2580        if (s & SELINGO)
2581                seq_puts(m, "SELINGO ");
2582        if (s & SWRAP)
2583                seq_puts(m, "SWRAP ");
2584        if (s & SDONE)
2585                seq_puts(m, "SDONE ");
2586        if (s & SPIORDY)
2587                seq_puts(m, "SPIORDY ");
2588        if (s & DMADONE)
2589                seq_puts(m, "DMADONE ");
2590
2591        s = GETPORT(SSTAT1);
2592        if (s & SELTO)
2593                seq_puts(m, "SELTO ");
2594        if (s & ATNTARG)
2595                seq_puts(m, "ATNTARG ");
2596        if (s & SCSIRSTI)
2597                seq_puts(m, "SCSIRSTI ");
2598        if (s & PHASEMIS)
2599                seq_puts(m, "PHASEMIS ");
2600        if (s & BUSFREE)
2601                seq_puts(m, "BUSFREE ");
2602        if (s & SCSIPERR)
2603                seq_puts(m, "SCSIPERR ");
2604        if (s & PHASECHG)
2605                seq_puts(m, "PHASECHG ");
2606        if (s & REQINIT)
2607                seq_puts(m, "REQINIT ");
2608        seq_puts(m, "); ");
2609
2610
2611        seq_puts(m, "SSTAT( ");
2612
2613        s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2614
2615        if (s & TARGET)
2616                seq_puts(m, "TARGET ");
2617        if (s & SELDO)
2618                seq_puts(m, "SELDO ");
2619        if (s & SELDI)
2620                seq_puts(m, "SELDI ");
2621        if (s & SELINGO)
2622                seq_puts(m, "SELINGO ");
2623        if (s & SWRAP)
2624                seq_puts(m, "SWRAP ");
2625        if (s & SDONE)
2626                seq_puts(m, "SDONE ");
2627        if (s & SPIORDY)
2628                seq_puts(m, "SPIORDY ");
2629        if (s & DMADONE)
2630                seq_puts(m, "DMADONE ");
2631
2632        s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2633
2634        if (s & SELTO)
2635                seq_puts(m, "SELTO ");
2636        if (s & ATNTARG)
2637                seq_puts(m, "ATNTARG ");
2638        if (s & SCSIRSTI)
2639                seq_puts(m, "SCSIRSTI ");
2640        if (s & PHASEMIS)
2641                seq_puts(m, "PHASEMIS ");
2642        if (s & BUSFREE)
2643                seq_puts(m, "BUSFREE ");
2644        if (s & SCSIPERR)
2645                seq_puts(m, "SCSIPERR ");
2646        if (s & PHASECHG)
2647                seq_puts(m, "PHASECHG ");
2648        if (s & REQINIT)
2649                seq_puts(m, "REQINIT ");
2650        seq_puts(m, "); ");
2651
2652        seq_puts(m, "SXFRCTL0( ");
2653
2654        s = GETPORT(SXFRCTL0);
2655        if (s & SCSIEN)
2656                seq_puts(m, "SCSIEN ");
2657        if (s & DMAEN)
2658                seq_puts(m, "DMAEN ");
2659        if (s & CH1)
2660                seq_puts(m, "CH1 ");
2661        if (s & CLRSTCNT)
2662                seq_puts(m, "CLRSTCNT ");
2663        if (s & SPIOEN)
2664                seq_puts(m, "SPIOEN ");
2665        if (s & CLRCH1)
2666                seq_puts(m, "CLRCH1 ");
2667        seq_puts(m, "); ");
2668
2669        seq_puts(m, "SIGNAL( ");
2670
2671        s = GETPORT(SCSISIG);
2672        if (s & SIG_ATNI)
2673                seq_puts(m, "ATNI ");
2674        if (s & SIG_SELI)
2675                seq_puts(m, "SELI ");
2676        if (s & SIG_BSYI)
2677                seq_puts(m, "BSYI ");
2678        if (s & SIG_REQI)
2679                seq_puts(m, "REQI ");
2680        if (s & SIG_ACKI)
2681                seq_puts(m, "ACKI ");
2682        seq_puts(m, "); ");
2683
2684        seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2685
2686        seq_printf(m, "STCNT(%d), ", GETSTCNT());
2687
2688        seq_puts(m, "SSTAT2( ");
2689
2690        s = GETPORT(SSTAT2);
2691        if (s & SOFFSET)
2692                seq_puts(m, "SOFFSET ");
2693        if (s & SEMPTY)
2694                seq_puts(m, "SEMPTY ");
2695        if (s & SFULL)
2696                seq_puts(m, "SFULL ");
2697        seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2698
2699        s = GETPORT(SSTAT3);
2700        seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2701
2702        seq_puts(m, "SSTAT4( ");
2703        s = GETPORT(SSTAT4);
2704        if (s & SYNCERR)
2705                seq_puts(m, "SYNCERR ");
2706        if (s & FWERR)
2707                seq_puts(m, "FWERR ");
2708        if (s & FRERR)
2709                seq_puts(m, "FRERR ");
2710        seq_puts(m, "); ");
2711
2712        seq_puts(m, "DMACNTRL0( ");
2713        s = GETPORT(DMACNTRL0);
2714        seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2715        seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2716        seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2717        if (s & ENDMA)
2718                seq_puts(m, "ENDMA ");
2719        if (s & INTEN)
2720                seq_puts(m, "INTEN ");
2721        if (s & RSTFIFO)
2722                seq_puts(m, "RSTFIFO ");
2723        if (s & SWINT)
2724                seq_puts(m, "SWINT ");
2725        seq_puts(m, "); ");
2726
2727        seq_puts(m, "DMASTAT( ");
2728        s = GETPORT(DMASTAT);
2729        if (s & ATDONE)
2730                seq_puts(m, "ATDONE ");
2731        if (s & WORDRDY)
2732                seq_puts(m, "WORDRDY ");
2733        if (s & DFIFOFULL)
2734                seq_puts(m, "DFIFOFULL ");
2735        if (s & DFIFOEMP)
2736                seq_puts(m, "DFIFOEMP ");
2737        seq_puts(m, ")\n");
2738
2739        seq_puts(m, "enabled interrupts( ");
2740
2741        s = GETPORT(SIMODE0);
2742        if (s & ENSELDO)
2743                seq_puts(m, "ENSELDO ");
2744        if (s & ENSELDI)
2745                seq_puts(m, "ENSELDI ");
2746        if (s & ENSELINGO)
2747                seq_puts(m, "ENSELINGO ");
2748        if (s & ENSWRAP)
2749                seq_puts(m, "ENSWRAP ");
2750        if (s & ENSDONE)
2751                seq_puts(m, "ENSDONE ");
2752        if (s & ENSPIORDY)
2753                seq_puts(m, "ENSPIORDY ");
2754        if (s & ENDMADONE)
2755                seq_puts(m, "ENDMADONE ");
2756
2757        s = GETPORT(SIMODE1);
2758        if (s & ENSELTIMO)
2759                seq_puts(m, "ENSELTIMO ");
2760        if (s & ENATNTARG)
2761                seq_puts(m, "ENATNTARG ");
2762        if (s & ENPHASEMIS)
2763                seq_puts(m, "ENPHASEMIS ");
2764        if (s & ENBUSFREE)
2765                seq_puts(m, "ENBUSFREE ");
2766        if (s & ENSCSIPERR)
2767                seq_puts(m, "ENSCSIPERR ");
2768        if (s & ENPHASECHG)
2769                seq_puts(m, "ENPHASECHG ");
2770        if (s & ENREQINIT)
2771                seq_puts(m, "ENREQINIT ");
2772        seq_puts(m, ")\n");
2773}
2774
2775static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2776{
2777        if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2778                return -EINVAL;
2779
2780#if defined(AHA152X_STAT)
2781        if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2782                int i;
2783
2784                HOSTDATA(shpnt)->total_commands=0;
2785                HOSTDATA(shpnt)->disconnections=0;
2786                HOSTDATA(shpnt)->busfree_without_any_action=0;
2787                HOSTDATA(shpnt)->busfree_without_old_command=0;
2788                HOSTDATA(shpnt)->busfree_without_new_command=0;
2789                HOSTDATA(shpnt)->busfree_without_done_command=0;
2790                HOSTDATA(shpnt)->busfree_with_check_condition=0;
2791                for (i = idle; i<maxstate; i++) {
2792                        HOSTDATA(shpnt)->count[i]=0;
2793                        HOSTDATA(shpnt)->count_trans[i]=0;
2794                        HOSTDATA(shpnt)->time[i]=0;
2795                }
2796
2797                shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2798
2799        } else
2800#endif
2801        {
2802                return -EINVAL;
2803        }
2804
2805
2806        return length;
2807}
2808
2809static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2810{
2811        int i;
2812        struct scsi_cmnd *ptr;
2813        unsigned long flags;
2814
2815        seq_puts(m, AHA152X_REVID "\n");
2816
2817        seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2818                shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2819        seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2820        seq_printf(m, "disconnection/reconnection %s\n",
2821                RECONNECT ? "enabled" : "disabled");
2822        seq_printf(m, "parity checking %s\n",
2823                PARITY ? "enabled" : "disabled");
2824        seq_printf(m, "synchronous transfers %s\n",
2825                SYNCHRONOUS ? "enabled" : "disabled");
2826        seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2827
2828        if(SYNCHRONOUS) {
2829                seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2830                for (i = 0; i < 8; i++)
2831                        if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2832                                seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2833                                        i,
2834                                        (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2835                                        (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2836                                    HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2837        }
2838        seq_puts(m, "\nqueue status:\n");
2839        DO_LOCK(flags);
2840        if (ISSUE_SC) {
2841                seq_puts(m, "not yet issued commands:\n");
2842                for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2843                        get_command(m, ptr);
2844        } else
2845                seq_puts(m, "no not yet issued commands\n");
2846        DO_UNLOCK(flags);
2847
2848        if (CURRENT_SC) {
2849                seq_puts(m, "current command:\n");
2850                get_command(m, CURRENT_SC);
2851        } else
2852                seq_puts(m, "no current command\n");
2853
2854        if (DISCONNECTED_SC) {
2855                seq_puts(m, "disconnected commands:\n");
2856                for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2857                        get_command(m, ptr);
2858        } else
2859                seq_puts(m, "no disconnected commands\n");
2860
2861        get_ports(m, shpnt);
2862
2863#if defined(AHA152X_STAT)
2864        seq_printf(m, "statistics:\n"
2865                "total commands:               %d\n"
2866                "disconnections:               %d\n"
2867                "busfree with check condition: %d\n"
2868                "busfree without old command:  %d\n"
2869                "busfree without new command:  %d\n"
2870                "busfree without done command: %d\n"
2871                "busfree without any action:   %d\n"
2872                "state      "
2873                "transitions  "
2874                "count        "
2875                "time\n",
2876                HOSTDATA(shpnt)->total_commands,
2877                HOSTDATA(shpnt)->disconnections,
2878                HOSTDATA(shpnt)->busfree_with_check_condition,
2879                HOSTDATA(shpnt)->busfree_without_old_command,
2880                HOSTDATA(shpnt)->busfree_without_new_command,
2881                HOSTDATA(shpnt)->busfree_without_done_command,
2882                HOSTDATA(shpnt)->busfree_without_any_action);
2883        for(i=0; i<maxstate; i++) {
2884                seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2885                        states[i].name,
2886                        HOSTDATA(shpnt)->count_trans[i],
2887                        HOSTDATA(shpnt)->count[i],
2888                        HOSTDATA(shpnt)->time[i]);
2889        }
2890#endif
2891        return 0;
2892}
2893
2894static int aha152x_adjust_queue(struct scsi_device *device)
2895{
2896        blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2897        return 0;
2898}
2899
2900static struct scsi_host_template aha152x_driver_template = {
2901        .module                         = THIS_MODULE,
2902        .name                           = AHA152X_REVID,
2903        .proc_name                      = "aha152x",
2904        .show_info                      = aha152x_show_info,
2905        .write_info                     = aha152x_set_info,
2906        .queuecommand                   = aha152x_queue,
2907        .eh_abort_handler               = aha152x_abort,
2908        .eh_device_reset_handler        = aha152x_device_reset,
2909        .eh_bus_reset_handler           = aha152x_bus_reset,
2910        .bios_param                     = aha152x_biosparam,
2911        .can_queue                      = 1,
2912        .this_id                        = 7,
2913        .sg_tablesize                   = SG_ALL,
2914        .dma_boundary                   = PAGE_SIZE - 1,
2915        .slave_alloc                    = aha152x_adjust_queue,
2916};
2917
2918#if !defined(AHA152X_PCMCIA)
2919static int setup_count;
2920static struct aha152x_setup setup[2];
2921
2922/* possible i/o addresses for the AIC-6260; default first */
2923static unsigned short ports[] = { 0x340, 0x140 };
2924
2925#if !defined(SKIP_BIOSTEST)
2926/* possible locations for the Adaptec BIOS; defaults first */
2927static unsigned int addresses[] =
2928{
2929        0xdc000,                /* default first */
2930        0xc8000,
2931        0xcc000,
2932        0xd0000,
2933        0xd4000,
2934        0xd8000,
2935        0xe0000,
2936        0xeb800,                /* VTech Platinum SMP */
2937        0xf0000,
2938};
2939
2940/* signatures for various AIC-6[23]60 based controllers.
2941   The point in detecting signatures is to avoid useless and maybe
2942   harmful probes on ports. I'm not sure that all listed boards pass
2943   auto-configuration. For those which fail the BIOS signature is
2944   obsolete, because user intervention to supply the configuration is
2945   needed anyway.  May be an information whether or not the BIOS supports
2946   extended translation could be also useful here. */
2947static struct signature {
2948        unsigned char *signature;
2949        int sig_offset;
2950        int sig_length;
2951} signatures[] =
2952{
2953        { "Adaptec AHA-1520 BIOS",      0x102e, 21 },
2954                /* Adaptec 152x */
2955        { "Adaptec AHA-1520B",          0x000b, 17 },
2956                /* Adaptec 152x rev B */
2957        { "Adaptec AHA-1520B",          0x0026, 17 },
2958                /* Iomega Jaz Jet ISA (AIC6370Q) */
2959        { "Adaptec ASW-B626 BIOS",      0x1029, 21 },
2960                /* on-board controller */
2961        { "Adaptec BIOS: ASW-B626",     0x000f, 22 },
2962                /* on-board controller */
2963        { "Adaptec ASW-B626 S2",        0x2e6c, 19 },
2964                /* on-board controller */
2965        { "Adaptec BIOS:AIC-6360",      0x000c, 21 },
2966                /* on-board controller */
2967        { "ScsiPro SP-360 BIOS",        0x2873, 19 },
2968                /* ScsiPro-Controller  */
2969        { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
2970                /* Gigabyte Local-Bus-SCSI */
2971        { "Adaptec BIOS:AVA-282X",      0x000c, 21 },
2972                /* Adaptec 282x */
2973        { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
2974                /* IBM Thinkpad Dock II */
2975        { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
2976                /* IBM Thinkpad Dock II SCSI */
2977        { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
2978                /* DTC 3520A ISA SCSI */
2979};
2980#endif /* !SKIP_BIOSTEST */
2981
2982/*
2983 * Test, if port_base is valid.
2984 *
2985 */
2986static int aha152x_porttest(int io_port)
2987{
2988        int i;
2989
2990        SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
2991        for (i = 0; i < 16; i++)
2992                SETPORT(io_port + O_STACK, i);
2993
2994        SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
2995        for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
2996                ;
2997
2998        return (i == 16);
2999}
3000
3001static int tc1550_porttest(int io_port)
3002{
3003        int i;
3004
3005        SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3006        for (i = 0; i < 16; i++)
3007                SETPORT(io_port + O_STACK, i);
3008
3009        SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3010        for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3011                ;
3012
3013        return (i == 16);
3014}
3015
3016
3017static int checksetup(struct aha152x_setup *setup)
3018{
3019        int i;
3020        for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3021                ;
3022
3023        if (i == ARRAY_SIZE(ports))
3024                return 0;
3025
3026        if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3027                printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3028                return 0;
3029        }
3030
3031        if( aha152x_porttest(setup->io_port) ) {
3032                setup->tc1550=0;
3033        } else if( tc1550_porttest(setup->io_port) ) {
3034                setup->tc1550=1;
3035        } else {
3036                release_region(setup->io_port, IO_RANGE);
3037                return 0;
3038        }
3039
3040        release_region(setup->io_port, IO_RANGE);
3041
3042        if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3043                return 0;
3044
3045        if ((setup->scsiid < 0) || (setup->scsiid > 7))
3046                return 0;
3047
3048        if ((setup->reconnect < 0) || (setup->reconnect > 1))
3049                return 0;
3050
3051        if ((setup->parity < 0) || (setup->parity > 1))
3052                return 0;
3053
3054        if ((setup->synchronous < 0) || (setup->synchronous > 1))
3055                return 0;
3056
3057        if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3058                return 0;
3059
3060
3061        return 1;
3062}
3063
3064
3065static int __init aha152x_init(void)
3066{
3067        int i, j, ok;
3068#if defined(AUTOCONF)
3069        aha152x_config conf;
3070#endif
3071#ifdef __ISAPNP__
3072        struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3073#endif
3074
3075        if ( setup_count ) {
3076                printk(KERN_INFO "aha152x: processing commandline: ");
3077
3078                for (i = 0; i<setup_count; i++) {
3079                        if (!checksetup(&setup[i])) {
3080                                printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3081                                printk(KERN_ERR "aha152x: invalid line\n");
3082                        }
3083                }
3084                printk("ok\n");
3085        }
3086
3087#if defined(SETUP0)
3088        if (setup_count < ARRAY_SIZE(setup)) {
3089                struct aha152x_setup override = SETUP0;
3090
3091                if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3092                        if (!checksetup(&override)) {
3093                                printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3094                                       override.io_port,
3095                                       override.irq,
3096                                       override.scsiid,
3097                                       override.reconnect,
3098                                       override.parity,
3099                                       override.synchronous,
3100                                       override.delay,
3101                                       override.ext_trans);
3102                        } else
3103                                setup[setup_count++] = override;
3104                }
3105        }
3106#endif
3107
3108#if defined(SETUP1)
3109        if (setup_count < ARRAY_SIZE(setup)) {
3110                struct aha152x_setup override = SETUP1;
3111
3112                if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3113                        if (!checksetup(&override)) {
3114                                printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3115                                       override.io_port,
3116                                       override.irq,
3117                                       override.scsiid,
3118                                       override.reconnect,
3119                                       override.parity,
3120                                       override.synchronous,
3121                                       override.delay,
3122                                       override.ext_trans);
3123                        } else
3124                                setup[setup_count++] = override;
3125                }
3126        }
3127#endif
3128
3129#if defined(MODULE)
3130        if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3131                if(aha152x[0]!=0) {
3132                        setup[setup_count].conf        = "";
3133                        setup[setup_count].io_port     = aha152x[0];
3134                        setup[setup_count].irq         = aha152x[1];
3135                        setup[setup_count].scsiid      = aha152x[2];
3136                        setup[setup_count].reconnect   = aha152x[3];
3137                        setup[setup_count].parity      = aha152x[4];
3138                        setup[setup_count].synchronous = aha152x[5];
3139                        setup[setup_count].delay       = aha152x[6];
3140                        setup[setup_count].ext_trans   = aha152x[7];
3141                } else if (io[0] != 0 || irq[0] != 0) {
3142                        if(io[0]!=0)  setup[setup_count].io_port = io[0];
3143                        if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3144
3145                        setup[setup_count].scsiid      = scsiid[0];
3146                        setup[setup_count].reconnect   = reconnect[0];
3147                        setup[setup_count].parity      = parity[0];
3148                        setup[setup_count].synchronous = sync[0];
3149                        setup[setup_count].delay       = delay[0];
3150                        setup[setup_count].ext_trans   = exttrans[0];
3151                }
3152
3153                if (checksetup(&setup[setup_count]))
3154                        setup_count++;
3155                else
3156                        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",
3157                               setup[setup_count].io_port,
3158                               setup[setup_count].irq,
3159                               setup[setup_count].scsiid,
3160                               setup[setup_count].reconnect,
3161                               setup[setup_count].parity,
3162                               setup[setup_count].synchronous,
3163                               setup[setup_count].delay,
3164                               setup[setup_count].ext_trans);
3165        }
3166
3167        if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3168                if(aha152x1[0]!=0) {
3169                        setup[setup_count].conf        = "";
3170                        setup[setup_count].io_port     = aha152x1[0];
3171                        setup[setup_count].irq         = aha152x1[1];
3172                        setup[setup_count].scsiid      = aha152x1[2];
3173                        setup[setup_count].reconnect   = aha152x1[3];
3174                        setup[setup_count].parity      = aha152x1[4];
3175                        setup[setup_count].synchronous = aha152x1[5];
3176                        setup[setup_count].delay       = aha152x1[6];
3177                        setup[setup_count].ext_trans   = aha152x1[7];
3178                } else if (io[1] != 0 || irq[1] != 0) {
3179                        if(io[1]!=0)  setup[setup_count].io_port = io[1];
3180                        if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3181
3182                        setup[setup_count].scsiid      = scsiid[1];
3183                        setup[setup_count].reconnect   = reconnect[1];
3184                        setup[setup_count].parity      = parity[1];
3185                        setup[setup_count].synchronous = sync[1];
3186                        setup[setup_count].delay       = delay[1];
3187                        setup[setup_count].ext_trans   = exttrans[1];
3188                }
3189                if (checksetup(&setup[setup_count]))
3190                        setup_count++;
3191                else
3192                        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",
3193                               setup[setup_count].io_port,
3194                               setup[setup_count].irq,
3195                               setup[setup_count].scsiid,
3196                               setup[setup_count].reconnect,
3197                               setup[setup_count].parity,
3198                               setup[setup_count].synchronous,
3199                               setup[setup_count].delay,
3200                               setup[setup_count].ext_trans);
3201        }
3202#endif
3203
3204#ifdef __ISAPNP__
3205        for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3206                while ( setup_count<ARRAY_SIZE(setup) &&
3207                        (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3208                        if (pnp_device_attach(dev) < 0)
3209                                continue;
3210
3211                        if (pnp_activate_dev(dev) < 0) {
3212                                pnp_device_detach(dev);
3213                                continue;
3214                        }
3215
3216                        if (!pnp_port_valid(dev, 0)) {
3217                                pnp_device_detach(dev);
3218                                continue;
3219                        }
3220
3221                        if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3222                                pnp_device_detach(dev);
3223                                continue;
3224                        }
3225
3226                        setup[setup_count].io_port     = pnp_port_start(dev, 0);
3227                        setup[setup_count].irq         = pnp_irq(dev, 0);
3228                        setup[setup_count].scsiid      = 7;
3229                        setup[setup_count].reconnect   = 1;
3230                        setup[setup_count].parity      = 1;
3231                        setup[setup_count].synchronous = 1;
3232                        setup[setup_count].delay       = DELAY_DEFAULT;
3233                        setup[setup_count].ext_trans   = 0;
3234#if defined(__ISAPNP__)
3235                        pnpdev[setup_count]            = dev;
3236#endif
3237                        printk (KERN_INFO
3238                                "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3239                                setup[setup_count].io_port, setup[setup_count].irq);
3240                        setup_count++;
3241                }
3242        }
3243#endif
3244
3245#if defined(AUTOCONF)
3246        if (setup_count<ARRAY_SIZE(setup)) {
3247#if !defined(SKIP_BIOSTEST)
3248                ok = 0;
3249                for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3250                        void __iomem *p = ioremap(addresses[i], 0x4000);
3251                        if (!p)
3252                                continue;
3253                        for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3254                                ok = check_signature(p + signatures[j].sig_offset,
3255                                                                signatures[j].signature, signatures[j].sig_length);
3256                        iounmap(p);
3257                }
3258                if (!ok && setup_count == 0)
3259                        return -ENODEV;
3260
3261                printk(KERN_INFO "aha152x: BIOS test: passed, ");
3262#else
3263                printk(KERN_INFO "aha152x: ");
3264#endif                          /* !SKIP_BIOSTEST */
3265
3266                ok = 0;
3267                for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3268                        if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3269                                continue;
3270
3271                        if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3272                                printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3273                                continue;
3274                        }
3275
3276                        if (aha152x_porttest(ports[i])) {
3277                                setup[setup_count].tc1550  = 0;
3278
3279                                conf.cf_port =
3280                                    (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3281                        } else if (tc1550_porttest(ports[i])) {
3282                                setup[setup_count].tc1550  = 1;
3283
3284                                conf.cf_port =
3285                                    (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3286                        } else {
3287                                release_region(ports[i], IO_RANGE);
3288                                continue;
3289                        }
3290
3291                        release_region(ports[i], IO_RANGE);
3292
3293                        ok++;
3294                        setup[setup_count].io_port = ports[i];
3295                        setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3296                        setup[setup_count].scsiid = conf.cf_id;
3297                        setup[setup_count].reconnect = conf.cf_tardisc;
3298                        setup[setup_count].parity = !conf.cf_parity;
3299                        setup[setup_count].synchronous = conf.cf_syncneg;
3300                        setup[setup_count].delay = DELAY_DEFAULT;
3301                        setup[setup_count].ext_trans = 0;
3302                        setup_count++;
3303
3304                }
3305
3306                if (ok)
3307                        printk("auto configuration: ok, ");
3308        }
3309#endif
3310
3311        printk("%d controller(s) configured\n", setup_count);
3312
3313        for (i=0; i<setup_count; i++) {
3314                if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3315                        struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3316
3317                        if( !shpnt ) {
3318                                release_region(setup[i].io_port, IO_RANGE);
3319#if defined(__ISAPNP__)
3320                        } else if( pnpdev[i] ) {
3321                                HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3322                                pnpdev[i]=NULL;
3323#endif
3324                        }
3325                } else {
3326                        printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3327                }
3328
3329#if defined(__ISAPNP__)
3330                if( pnpdev[i] )
3331                        pnp_device_detach(pnpdev[i]);
3332#endif
3333        }
3334
3335        return 0;
3336}
3337
3338static void __exit aha152x_exit(void)
3339{
3340        struct aha152x_hostdata *hd, *tmp;
3341
3342        list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3343                struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3344
3345                aha152x_release(shost);
3346        }
3347}
3348
3349module_init(aha152x_init);
3350module_exit(aha152x_exit);
3351
3352#if !defined(MODULE)
3353static int __init aha152x_setup(char *str)
3354{
3355        int ints[10];
3356
3357        get_options(str, ARRAY_SIZE(ints), ints);
3358
3359        if(setup_count>=ARRAY_SIZE(setup)) {
3360                printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3361                return 1;
3362        }
3363
3364        setup[setup_count].conf        = str;
3365        setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3366        setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3367        setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3368        setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3369        setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3370        setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3371        setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3372        setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3373        if (ints[0] > 8) {                                                /*}*/
3374                printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3375                       "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3376        } else {
3377                setup_count++;
3378                return 0;
3379        }
3380
3381        return 1;
3382}
3383__setup("aha152x=", aha152x_setup);
3384#endif
3385
3386#endif /* !AHA152X_PCMCIA */
3387
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.