drivers/scsi/arm/acornscsi.c

   1 /*
   2  *  linux/drivers/acorn/scsi/acornscsi.c
   3  *
   4  *  Acorn SCSI 3 driver
   5  *  By R.M.King.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * Abandoned using the Select and Transfer command since there were
  12  * some nasty races between our software and the target devices that
  13  * were not easy to solve, and the device errata had a lot of entries
  14  * for this command, some of them quite nasty...
  15  *
  16  * Changelog:
  17  *  26-Sep-1997 RMK     Re-jigged to use the queue module.
  18  *                      Re-coded state machine to be based on driver
  19  *                      state not scsi state.  Should be easier to debug.
  20  *                      Added acornscsi_release to clean up properly.
  21  *                      Updated proc/scsi reporting.
  22  *  05-Oct-1997 RMK     Implemented writing to SCSI devices.
  23  *  06-Oct-1997 RMK     Corrected small (non-serious) bug with the connect/
  24  *                      reconnect race condition causing a warning message.
  25  *  12-Oct-1997 RMK     Added catch for re-entering interrupt routine.
  26  *  15-Oct-1997 RMK     Improved handling of commands.
  27  *  27-Jun-1998 RMK     Changed asm/delay.h to linux/delay.h.
  28  *  13-Dec-1998 RMK     Better abort code and command handling.  Extra state
  29  *                      transitions added to allow dodgy devices to work.
  30  */
  31 #define DEBUG_NO_WRITE  1
  32 #define DEBUG_QUEUES    2
  33 #define DEBUG_DMA       4
  34 #define DEBUG_ABORT     8
  35 #define DEBUG_DISCON    16
  36 #define DEBUG_CONNECT   32
  37 #define DEBUG_PHASES    64
  38 #define DEBUG_WRITE     128
  39 #define DEBUG_LINK      256
  40 #define DEBUG_MESSAGES  512
  41 #define DEBUG_RESET     1024
  42 #define DEBUG_ALL       (DEBUG_RESET|DEBUG_MESSAGES|DEBUG_LINK|DEBUG_WRITE|\
  43                          DEBUG_PHASES|DEBUG_CONNECT|DEBUG_DISCON|DEBUG_ABORT|\
  44                          DEBUG_DMA|DEBUG_QUEUES)
  45
  46 /* DRIVER CONFIGURATION
  47  *
  48  * SCSI-II Tagged queue support.
  49  *
  50  * I don't have any SCSI devices that support it, so it is totally untested
  51  * (except to make sure that it doesn't interfere with any non-tagging
  52  * devices).  It is not fully implemented either - what happens when a
  53  * tagging device reconnects???
  54  *
  55  * You can tell if you have a device that supports tagged queueing my
  56  * cating (eg) /proc/scsi/acornscsi/0 and see if the SCSI revision is reported
  57  * as '2 TAG'.
  58  *
  59  * Also note that CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE is normally set in the config
  60  * scripts, but disabled here.  Once debugged, remove the #undef, otherwise to debug,
  61  * comment out the undef.
  62  */
  63 #undef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
  64 /*
  65  * SCSI-II Linked command support.
  66  *
  67  * The higher level code doesn't support linked commands yet, and so the option
  68  * is undef'd here.
  69  */
  70 #undef CONFIG_SCSI_ACORNSCSI_LINK
  71 /*
  72  * SCSI-II Synchronous transfer support.
  73  *
  74  * Tried and tested...
  75  *
  76  * SDTR_SIZE      - maximum number of un-acknowledged bytes (0 = off, 12 = max)
  77  * SDTR_PERIOD    - period of REQ signal (min=125, max=1020)
  78  * DEFAULT_PERIOD - default REQ period.
  79  */
  80 #define SDTR_SIZE       12
  81 #define SDTR_PERIOD     125
  82 #define DEFAULT_PERIOD  500
  83
  84 /*
  85  * Debugging information
  86  *
  87  * DEBUG          - bit mask from list above
  88  * DEBUG_TARGET   - is defined to the target number if you want to debug
  89  *                  a specific target. [only recon/write/dma].
  90  */
  91 #define DEBUG (DEBUG_RESET|DEBUG_WRITE|DEBUG_NO_WRITE)
  92 /* only allow writing to SCSI device 0 */
  93 #define NO_WRITE 0xFE
  94 /*#define DEBUG_TARGET 2*/
  95 /*
  96  * Select timeout time (in 10ms units)
  97  *
  98  * This is the timeout used between the start of selection and the WD33C93
  99  * chip deciding that the device isn't responding.
 100  */
 101 #define TIMEOUT_TIME 10
 102 /*
 103  * Define this if you want to have verbose explaination of SCSI
 104  * status/messages.
 105  */
 106 #undef CONFIG_ACORNSCSI_CONSTANTS
 107 /*
 108  * Define this if you want to use the on board DMAC [don't remove this option]
 109  * If not set, then use PIO mode (not currently supported).
 110  */
 111 #define USE_DMAC
 112
 113 /*
 114  * ====================================================================================
 115  */
 116
 117 #ifdef DEBUG_TARGET
 118 #define DBG(cmd,xxx...) \
 119   if (cmd->device->id == DEBUG_TARGET) { \
 120     xxx; \
 121   }
 122 #else
 123 #define DBG(cmd,xxx...) xxx
 124 #endif
 125
 126 #ifndef STRINGIFY
 127 #define STRINGIFY(x) #x
 128 #endif
 129 #define STRx(x) STRINGIFY(x)
 130 #define NO_WRITE_STR STRx(NO_WRITE)
 131
 132 #include <linux/config.h>
 133 #include <linux/module.h>
 134 #include <linux/kernel.h>
 135 #include <linux/sched.h>
 136 #include <linux/string.h>
 137 #include <linux/signal.h>
 138 #include <linux/errno.h>
 139 #include <linux/proc_fs.h>
 140 #include <linux/ioport.h>
 141 #include <linux/blkdev.h>
 142 #include <linux/delay.h>
 143 #include <linux/interrupt.h>
 144 #include <linux/init.h>
 145 #include <linux/bitops.h>
 146
 147 #include <asm/system.h>
 148 #include <asm/io.h>
 149 #include <asm/irq.h>
 150 #include <asm/ecard.h>
 151
 152 #include "../scsi.h"
 153 #include <scsi/scsi_dbg.h>
 154 #include <scsi/scsi_host.h>
 155 #include <scsi/scsi_transport_spi.h>
 156 #include "acornscsi.h"
 157 #include "msgqueue.h"
 158 #include "scsi.h"
 159
 160 #include <scsi/scsicam.h>
 161
 162 #define VER_MAJOR 2
 163 #define VER_MINOR 0
 164 #define VER_PATCH 6
 165
 166 #ifndef ABORT_TAG
 167 #define ABORT_TAG 0xd
 168 #else
 169 #error "Yippee!  ABORT TAG is now defined!  Remove this error!"
 170 #endif
 171
 172 #ifdef CONFIG_SCSI_ACORNSCSI_LINK
 173 #error SCSI2 LINKed commands not supported (yet)!
 174 #endif
 175
 176 #ifdef USE_DMAC
 177 /*
 178  * DMAC setup parameters
 179  */
 180 #define INIT_DEVCON0    (DEVCON0_RQL|DEVCON0_EXW|DEVCON0_CMP)
 181 #define INIT_DEVCON1    (DEVCON1_BHLD)
 182 #define DMAC_READ       (MODECON_READ)
 183 #define DMAC_WRITE      (MODECON_WRITE)
 184 #define INIT_SBICDMA    (CTRL_DMABURST)
 185
 186 #define scsi_xferred    have_data_in
 187
 188 /*
 189  * Size of on-board DMA buffer
 190  */
 191 #define DMAC_BUFFER_SIZE        65536
 192 #endif
 193
 194 #define STATUS_BUFFER_TO_PRINT  24
 195
 196 unsigned int sdtr_period = SDTR_PERIOD;
 197 unsigned int sdtr_size   = SDTR_SIZE;
 198
 199 static void acornscsi_done(AS_Host *host, Scsi_Cmnd **SCpntp, unsigned int result);
 200 static int acornscsi_reconnect_finish(AS_Host *host);
 201 static void acornscsi_dma_cleanup(AS_Host *host);
 202 static void acornscsi_abortcmd(AS_Host *host, unsigned char tag);
 203
 204 /* ====================================================================================
 205  * Miscellaneous
 206  */
 207
 208 static inline void
 209 sbic_arm_write(unsigned int io_port, int reg, int value)
 210 {
 211     __raw_writeb(reg, io_port);
 212     __raw_writeb(value, io_port + 4);
 213 }
 214
 215 #define sbic_arm_writenext(io,val) \
 216         __raw_writeb((val), (io) + 4)
 217
 218 static inline
 219 int sbic_arm_read(unsigned int io_port, int reg)
 220 {
 221     if(reg == SBIC_ASR)
 222            return __raw_readl(io_port) & 255;
 223     __raw_writeb(reg, io_port);
 224     return __raw_readl(io_port + 4) & 255;
 225 }
 226
 227 #define sbic_arm_readnext(io) \
 228         __raw_readb((io) + 4)
 229
 230 #ifdef USE_DMAC
 231 #define dmac_read(io_port,reg) \
 232         inb((io_port) + (reg))
 233
 234 #define dmac_write(io_port,reg,value) \
 235         ({ outb((value), (io_port) + (reg)); })
 236
 237 #define dmac_clearintr(io_port) \
 238         ({ outb(0, (io_port)); })
 239
 240 static inline
 241 unsigned int dmac_address(unsigned int io_port)
 242 {
 243     return dmac_read(io_port, DMAC_TXADRHI) << 16 |
 244            dmac_read(io_port, DMAC_TXADRMD) << 8 |
 245            dmac_read(io_port, DMAC_TXADRLO);
 246 }
 247
 248 static
 249 void acornscsi_dumpdma(AS_Host *host, char *where)
 250 {
 251         unsigned int mode, addr, len;
 252
 253         mode = dmac_read(host->dma.io_port, DMAC_MODECON);
 254         addr = dmac_address(host->dma.io_port);
 255         len  = dmac_read(host->dma.io_port, DMAC_TXCNTHI) << 8 |
 256                dmac_read(host->dma.io_port, DMAC_TXCNTLO);
 257
 258         printk("scsi%d: %s: DMAC %02x @%06x+%04x msk %02x, ",
 259                 host->host->host_no, where,
 260                 mode, addr, (len + 1) & 0xffff,
 261                 dmac_read(host->dma.io_port, DMAC_MASKREG));
 262
 263         printk("DMA @%06x, ", host->dma.start_addr);
 264         printk("BH @%p +%04x, ", host->scsi.SCp.ptr,
 265                 host->scsi.SCp.this_residual);
 266         printk("DT @+%04x ST @+%04x", host->dma.transferred,
 267                 host->scsi.SCp.scsi_xferred);
 268         printk("\n");
 269 }
 270 #endif
 271
 272 static
 273 unsigned long acornscsi_sbic_xfcount(AS_Host *host)
 274 {
 275     unsigned long length;
 276
 277     length = sbic_arm_read(host->scsi.io_port, SBIC_TRANSCNTH) << 16;
 278     length |= sbic_arm_readnext(host->scsi.io_port) << 8;
 279     length |= sbic_arm_readnext(host->scsi.io_port);
 280
 281     return length;
 282 }
 283
 284 static int
 285 acornscsi_sbic_wait(AS_Host *host, int stat_mask, int stat, int timeout, char *msg)
 286 {
 287         int asr;
 288
 289         do {
 290                 asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
 291
 292                 if ((asr & stat_mask) == stat)
 293                         return 0;
 294
 295                 udelay(1);
 296         } while (--timeout);
 297
 298         printk("scsi%d: timeout while %s\n", host->host->host_no, msg);
 299
 300         return -1;
 301 }
 302
 303 static
 304 int acornscsi_sbic_issuecmd(AS_Host *host, int command)
 305 {
 306     if (acornscsi_sbic_wait(host, ASR_CIP, 0, 1000, "issuing command"))
 307         return -1;
 308
 309     sbic_arm_write(host->scsi.io_port, SBIC_CMND, command);
 310
 311     return 0;
 312 }
 313
 314 static void
 315 acornscsi_csdelay(unsigned int cs)
 316 {
 317     unsigned long target_jiffies, flags;
 318
 319     target_jiffies = jiffies + 1 + cs * HZ / 100;
 320
 321     local_save_flags(flags);
 322     local_irq_enable();
 323
 324     while (time_before(jiffies, target_jiffies)) barrier();
 325
 326     local_irq_restore(flags);
 327 }
 328
 329 static
 330 void acornscsi_resetcard(AS_Host *host)
 331 {
 332     unsigned int i, timeout;
 333
 334     /* assert reset line */
 335     host->card.page_reg = 0x80;
 336     outb(host->card.page_reg, host->card.io_page);
 337
 338     /* wait 3 cs.  SCSI standard says 25ms. */
 339     acornscsi_csdelay(3);
 340
 341     host->card.page_reg = 0;
 342     outb(host->card.page_reg, host->card.io_page);
 343
 344     /*
 345      * Should get a reset from the card
 346      */
 347     timeout = 1000;
 348     do {
 349         if (inb(host->card.io_intr) & 8)
 350             break;
 351         udelay(1);
 352     } while (--timeout);
 353
 354     if (timeout == 0)
 355         printk("scsi%d: timeout while resetting card\n",
 356                 host->host->host_no);
 357
 358     sbic_arm_read(host->scsi.io_port, SBIC_ASR);
 359     sbic_arm_read(host->scsi.io_port, SBIC_SSR);
 360
 361     /* setup sbic - WD33C93A */
 362     sbic_arm_write(host->scsi.io_port, SBIC_OWNID, OWNID_EAF | host->host->this_id);
 363     sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_RESET);
 364
 365     /*
 366      * Command should cause a reset interrupt
 367      */
 368     timeout = 1000;
 369     do {
 370         if (inb(host->card.io_intr) & 8)
 371             break;
 372         udelay(1);
 373     } while (--timeout);
 374
 375     if (timeout == 0)
 376         printk("scsi%d: timeout while resetting card\n",
 377                 host->host->host_no);
 378
 379     sbic_arm_read(host->scsi.io_port, SBIC_ASR);
 380     if (sbic_arm_read(host->scsi.io_port, SBIC_SSR) != 0x01)
 381         printk(KERN_CRIT "scsi%d: WD33C93A didn't give enhanced reset interrupt\n",
 382                 host->host->host_no);
 383
 384     sbic_arm_write(host->scsi.io_port, SBIC_CTRL, INIT_SBICDMA | CTRL_IDI);
 385     sbic_arm_write(host->scsi.io_port, SBIC_TIMEOUT, TIMEOUT_TIME);
 386     sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, SYNCHTRANSFER_2DBA);
 387     sbic_arm_write(host->scsi.io_port, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
 388
 389     host->card.page_reg = 0x40;
 390     outb(host->card.page_reg, host->card.io_page);
 391
 392     /* setup dmac - uPC71071 */
 393     dmac_write(host->dma.io_port, DMAC_INIT, 0);
 394 #ifdef USE_DMAC
 395     dmac_write(host->dma.io_port, DMAC_INIT, INIT_8BIT);
 396     dmac_write(host->dma.io_port, DMAC_CHANNEL, CHANNEL_0);
 397     dmac_write(host->dma.io_port, DMAC_DEVCON0, INIT_DEVCON0);
 398     dmac_write(host->dma.io_port, DMAC_DEVCON1, INIT_DEVCON1);
 399 #endif
 400
 401     host->SCpnt = NULL;
 402     host->scsi.phase = PHASE_IDLE;
 403     host->scsi.disconnectable = 0;
 404
 405     memset(host->busyluns, 0, sizeof(host->busyluns));
 406
 407     for (i = 0; i < 8; i++) {
 408         host->device[i].sync_state = SYNC_NEGOCIATE;
 409         host->device[i].disconnect_ok = 1;
 410     }
 411
 412     /* wait 25 cs.  SCSI standard says 250ms. */
 413     acornscsi_csdelay(25);
 414 }
 415
 416 /*=============================================================================================
 417  * Utility routines (eg. debug)
 418  */
 419 #ifdef CONFIG_ACORNSCSI_CONSTANTS
 420 static char *acornscsi_interrupttype[] = {
 421   "rst",  "suc",  "p/a",  "3",
 422   "term", "5",    "6",    "7",
 423   "serv", "9",    "a",    "b",
 424   "c",    "d",    "e",    "f"
 425 };
 426
 427 static signed char acornscsi_map[] = {
 428   0,  1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 429  -1,  2, -1, -1,  -1, -1,  3, -1,   4,  5,  6,  7,   8,  9, 10, 11,
 430  12, 13, 14, -1,  -1, -1, -1, -1,   4,  5,  6,  7,   8,  9, 10, 11,
 431  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 432  15, 16, 17, 18,  19, -1, -1, 20,   4,  5,  6,  7,   8,  9, 10, 11,
 433  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 434  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 435  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 436  21, 22, -1, -1,  -1, 23, -1, -1,   4,  5,  6,  7,   8,  9, 10, 11,
 437  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 438  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 439  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 440  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 441  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 442  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,
 443  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1,  -1, -1, -1, -1
 444 };
 445
 446 static char *acornscsi_interruptcode[] = {
 447     /* 0 */
 448     "reset - normal mode",      /* 00 */
 449     "reset - advanced mode",    /* 01 */
 450
 451     /* 2 */
 452     "sel",                      /* 11 */
 453     "sel+xfer",                 /* 16 */
 454     "data-out",                 /* 18 */
 455     "data-in",                  /* 19 */
 456     "cmd",                      /* 1A */
 457     "stat",                     /* 1B */
 458     "??-out",                   /* 1C */
 459     "??-in",                    /* 1D */
 460     "msg-out",                  /* 1E */
 461     "msg-in",                   /* 1F */
 462
 463     /* 12 */
 464     "/ACK asserted",            /* 20 */
 465     "save-data-ptr",            /* 21 */
 466     "{re}sel",                  /* 22 */
 467
 468     /* 15 */
 469     "inv cmd",                  /* 40 */
 470     "unexpected disconnect",    /* 41 */
 471     "sel timeout",              /* 42 */
 472     "P err",                    /* 43 */
 473     "P err+ATN",                /* 44 */
 474     "bad status byte",          /* 47 */
 475
 476     /* 21 */
 477     "resel, no id",             /* 80 */
 478     "resel",                    /* 81 */
 479     "discon",                   /* 85 */
 480 };
 481
 482 static
 483 void print_scsi_status(unsigned int ssr)
 484 {
 485     if (acornscsi_map[ssr] != -1)
 486         printk("%s:%s",
 487                 acornscsi_interrupttype[(ssr >> 4)],
 488                 acornscsi_interruptcode[acornscsi_map[ssr]]);
 489     else
 490         printk("%X:%X", ssr >> 4, ssr & 0x0f);
 491 }
 492 #endif
 493
 494 static
 495 void print_sbic_status(int asr, int ssr, int cmdphase)
 496 {
 497 #ifdef CONFIG_ACORNSCSI_CONSTANTS
 498     printk("sbic: %c%c%c%c%c%c ",
 499             asr & ASR_INT ? 'I' : 'i',
 500             asr & ASR_LCI ? 'L' : 'l',
 501             asr & ASR_BSY ? 'B' : 'b',
 502             asr & ASR_CIP ? 'C' : 'c',
 503             asr & ASR_PE  ? 'P' : 'p',
 504             asr & ASR_DBR ? 'D' : 'd');
 505     printk("scsi: ");
 506     print_scsi_status(ssr);
 507     printk(" ph %02X\n", cmdphase);
 508 #else
 509     printk("sbic: %02X scsi: %X:%X ph: %02X\n",
 510             asr, (ssr & 0xf0)>>4, ssr & 0x0f, cmdphase);
 511 #endif
 512 }
 513
 514 static void
 515 acornscsi_dumplogline(AS_Host *host, int target, int line)
 516 {
 517         unsigned long prev;
 518         signed int ptr;
 519
 520         ptr = host->status_ptr[target] - STATUS_BUFFER_TO_PRINT;
 521         if (ptr < 0)
 522                 ptr += STATUS_BUFFER_SIZE;
 523
 524         printk("%c: %3s:", target == 8 ? 'H' : '0' + target,
 525                 line == 0 ? "ph" : line == 1 ? "ssr" : "int");
 526
 527         prev = host->status[target][ptr].when;
 528
 529         for (; ptr != host->status_ptr[target]; ptr = (ptr + 1) & (STATUS_BUFFER_SIZE - 1)) {
 530                 unsigned long time_diff;
 531
 532                 if (!host->status[target][ptr].when)
 533                         continue;
 534
 535                 switch (line) {
 536                 case 0:
 537                         printk("%c%02X", host->status[target][ptr].irq ? '-' : ' ',
 538                                          host->status[target][ptr].ph);
 539                         break;
 540
 541                 case 1:
 542                         printk(" %02X", host->status[target][ptr].ssr);
 543                         break;
 544
 545                 case 2:
 546                         time_diff = host->status[target][ptr].when - prev;
 547                         prev = host->status[target][ptr].when;
 548                         if (time_diff == 0)
 549                                 printk("==^");
 550                         else if (time_diff >= 100)
 551                                 printk("   ");
 552                         else
 553                                 printk(" %02ld", time_diff);
 554                         break;
 555                 }
 556         }
 557
 558         printk("\n");
 559 }
 560
 561 static
 562 void acornscsi_dumplog(AS_Host *host, int target)
 563 {
 564     do {
 565         acornscsi_dumplogline(host, target, 0);
 566         acornscsi_dumplogline(host, target, 1);
 567         acornscsi_dumplogline(host, target, 2);
 568
 569         if (target == 8)
 570             break;
 571
 572         target = 8;
 573     } while (1);
 574 }
 575
 576 static
 577 char acornscsi_target(AS_Host *host)
 578 {
 579         if (host->SCpnt)
 580                 return '0' + host->SCpnt->device->id;
 581         return 'H';
 582 }
 583
 584 /*
 585  * Prototype: cmdtype_t acornscsi_cmdtype(int command)
 586  * Purpose  : differentiate READ from WRITE from other commands
 587  * Params   : command - command to interpret
 588  * Returns  : CMD_READ  - command reads data,
 589  *            CMD_WRITE - command writes data,
 590  *            CMD_MISC  - everything else
 591  */
 592 static inline
 593 cmdtype_t acornscsi_cmdtype(int command)
 594 {
 595     switch (command) {
 596     case WRITE_6:  case WRITE_10:  case WRITE_12:
 597         return CMD_WRITE;
 598     case READ_6:   case READ_10:   case READ_12:
 599         return CMD_READ;
 600     default:
 601         return CMD_MISC;
 602     }
 603 }
 604
 605 /*
 606  * Prototype: int acornscsi_datadirection(int command)
 607  * Purpose  : differentiate between commands that have a DATA IN phase
 608  *            and a DATA OUT phase
 609  * Params   : command - command to interpret
 610  * Returns  : DATADIR_OUT - data out phase expected
 611  *            DATADIR_IN  - data in phase expected
 612  */
 613 static
 614 datadir_t acornscsi_datadirection(int command)
 615 {
 616     switch (command) {
 617     case CHANGE_DEFINITION:     case COMPARE:           case COPY:
 618     case COPY_VERIFY:           case LOG_SELECT:        case MODE_SELECT:
 619     case MODE_SELECT_10:        case SEND_DIAGNOSTIC:   case WRITE_BUFFER:
 620     case FORMAT_UNIT:           case REASSIGN_BLOCKS:   case RESERVE:
 621     case SEARCH_EQUAL:          case SEARCH_HIGH:       case SEARCH_LOW:
 622     case WRITE_6:               case WRITE_10:          case WRITE_VERIFY:
 623     case UPDATE_BLOCK:          case WRITE_LONG:        case WRITE_SAME:
 624     case SEARCH_HIGH_12:        case SEARCH_EQUAL_12:   case SEARCH_LOW_12:
 625     case WRITE_12:              case WRITE_VERIFY_12:   case SET_WINDOW:
 626     case MEDIUM_SCAN:           case SEND_VOLUME_TAG:   case 0xea:
 627         return DATADIR_OUT;
 628     default:
 629         return DATADIR_IN;
 630     }
 631 }
 632
 633 /*
 634  * Purpose  : provide values for synchronous transfers with 33C93.
 635  * Copyright: Copyright (c) 1996 John Shifflett, GeoLog Consulting
 636  *      Modified by Russell King for 8MHz WD33C93A
 637  */
 638 static struct sync_xfer_tbl {
 639     unsigned int period_ns;
 640     unsigned char reg_value;
 641 } sync_xfer_table[] = {
 642     {   1, 0x20 },    { 249, 0x20 },    { 374, 0x30 },
 643     { 499, 0x40 },    { 624, 0x50 },    { 749, 0x60 },
 644     { 874, 0x70 },    { 999, 0x00 },    {   0,    0 }
 645 };
 646
 647 /*
 648  * Prototype: int acornscsi_getperiod(unsigned char syncxfer)
 649  * Purpose  : period for the synchronous transfer setting
 650  * Params   : syncxfer SYNCXFER register value
 651  * Returns  : period in ns.
 652  */
 653 static
 654 int acornscsi_getperiod(unsigned char syncxfer)
 655 {
 656     int i;
 657
 658     syncxfer &= 0xf0;
 659     if (syncxfer == 0x10)
 660         syncxfer = 0;
 661
 662     for (i = 1; sync_xfer_table[i].period_ns; i++)
 663         if (syncxfer == sync_xfer_table[i].reg_value)
 664             return sync_xfer_table[i].period_ns;
 665     return 0;
 666 }
 667
 668 /*
 669  * Prototype: int round_period(unsigned int period)
 670  * Purpose  : return index into above table for a required REQ period
 671  * Params   : period - time (ns) for REQ
 672  * Returns  : table index
 673  * Copyright: Copyright (c) 1996 John Shifflett, GeoLog Consulting
 674  */
 675 static inline
 676 int round_period(unsigned int period)
 677 {
 678     int i;
 679
 680     for (i = 1; sync_xfer_table[i].period_ns; i++) {
 681         if ((period <= sync_xfer_table[i].period_ns) &&
 682             (period > sync_xfer_table[i - 1].period_ns))
 683             return i;
 684     }
 685     return 7;
 686 }
 687
 688 /*
 689  * Prototype: unsigned char calc_sync_xfer(unsigned int period, unsigned int offset)
 690  * Purpose  : calculate value for 33c93s SYNC register
 691  * Params   : period - time (ns) for REQ
 692  *            offset - offset in bytes between REQ/ACK
 693  * Returns  : value for SYNC register
 694  * Copyright: Copyright (c) 1996 John Shifflett, GeoLog Consulting
 695  */
 696 static
 697 unsigned char calc_sync_xfer(unsigned int period, unsigned int offset)
 698 {
 699     return sync_xfer_table[round_period(period)].reg_value |
 700                 ((offset < SDTR_SIZE) ? offset : SDTR_SIZE);
 701 }
 702
 703 /* ====================================================================================
 704  * Command functions
 705  */
 706 /*
 707  * Function: acornscsi_kick(AS_Host *host)
 708  * Purpose : kick next command to interface
 709  * Params  : host - host to send command to
 710  * Returns : INTR_IDLE if idle, otherwise INTR_PROCESSING
 711  * Notes   : interrupts are always disabled!
 712  */
 713 static
 714 intr_ret_t acornscsi_kick(AS_Host *host)
 715 {
 716     int from_queue = 0;
 717     Scsi_Cmnd *SCpnt;
 718
 719     /* first check to see if a command is waiting to be executed */
 720     SCpnt = host->origSCpnt;
 721     host->origSCpnt = NULL;
 722
 723     /* retrieve next command */
 724     if (!SCpnt) {
 725         SCpnt = queue_remove_exclude(&host->queues.issue, host->busyluns);
 726         if (!SCpnt)
 727             return INTR_IDLE;
 728
 729         from_queue = 1;
 730     }
 731
 732     if (host->scsi.disconnectable && host->SCpnt) {
 733         queue_add_cmd_tail(&host->queues.disconnected, host->SCpnt);
 734         host->scsi.disconnectable = 0;
 735 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
 736         DBG(host->SCpnt, printk("scsi%d.%c: moved command to disconnected queue\n",
 737                 host->host->host_no, acornscsi_target(host)));
 738 #endif
 739         host->SCpnt = NULL;
 740     }
 741
 742     /*
 743      * If we have an interrupt pending, then we may have been reselected.
 744      * In this case, we don't want to write to the registers
 745      */
 746     if (!(sbic_arm_read(host->scsi.io_port, SBIC_ASR) & (ASR_INT|ASR_BSY|ASR_CIP))) {
 747         sbic_arm_write(host->scsi.io_port, SBIC_DESTID, SCpnt->device->id);
 748         sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_SELWITHATN);
 749     }
 750
 751     /*
 752      * claim host busy - all of these must happen atomically wrt
 753      * our interrupt routine.  Failure means command loss.
 754      */
 755     host->scsi.phase = PHASE_CONNECTING;
 756     host->SCpnt = SCpnt;
 757     host->scsi.SCp = SCpnt->SCp;
 758     host->dma.xfer_setup = 0;
 759     host->dma.xfer_required = 0;
 760     host->dma.xfer_done = 0;
 761
 762 #if (DEBUG & (DEBUG_ABORT|DEBUG_CONNECT))
 763     DBG(SCpnt,printk("scsi%d.%c: starting cmd %02X\n",
 764             host->host->host_no, '0' + SCpnt->device->id,
 765             SCpnt->cmnd[0]));
 766 #endif
 767
 768     if (from_queue) {
 769 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
 770         /*
 771          * tagged queueing - allocate a new tag to this command
 772          */
 773         if (SCpnt->device->simple_tags) {
 774             SCpnt->device->current_tag += 1;
 775             if (SCpnt->device->current_tag == 0)
 776                 SCpnt->device->current_tag = 1;
 777             SCpnt->tag = SCpnt->device->current_tag;
 778         } else
 779 #endif
 780             set_bit(SCpnt->device->id * 8 + SCpnt->device->lun, host->busyluns);
 781
 782         host->stats.removes += 1;
 783
 784         switch (acornscsi_cmdtype(SCpnt->cmnd[0])) {
 785         case CMD_WRITE:
 786             host->stats.writes += 1;
 787             break;
 788         case CMD_READ:
 789             host->stats.reads += 1;
 790             break;
 791         case CMD_MISC:
 792             host->stats.miscs += 1;
 793             break;
 794         }
 795     }
 796
 797     return INTR_PROCESSING;
 798 }
 799
 800 /*
 801  * Function: void acornscsi_done(AS_Host *host, Scsi_Cmnd **SCpntp, unsigned int result)
 802  * Purpose : complete processing for command
 803  * Params  : host   - interface that completed
 804  *           result - driver byte of result
 805  */
 806 static
 807 void acornscsi_done(AS_Host *host, Scsi_Cmnd **SCpntp, unsigned int result)
 808 {
 809     Scsi_Cmnd *SCpnt = *SCpntp;
 810
 811     /* clean up */
 812     sbic_arm_write(host->scsi.io_port, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
 813
 814     host->stats.fins += 1;
 815
 816     if (SCpnt) {
 817         *SCpntp = NULL;
 818
 819         acornscsi_dma_cleanup(host);
 820
 821         SCpnt->result = result << 16 | host->scsi.SCp.Message << 8 | host->scsi.SCp.Status;
 822
 823         /*
 824          * In theory, this should not happen.  In practice, it seems to.
 825          * Only trigger an error if the device attempts to report all happy
 826          * but with untransferred buffers...  If we don't do something, then
 827          * data loss will occur.  Should we check SCpnt->underflow here?
 828          * It doesn't appear to be set to something meaningful by the higher
 829          * levels all the time.
 830          */
 831         if (result == DID_OK) {
 832                 int xfer_warn = 0;
 833
 834                 if (SCpnt->underflow == 0) {
 835                         if (host->scsi.SCp.ptr &&
 836                             acornscsi_cmdtype(SCpnt->cmnd[0]) != CMD_MISC)
 837                                 xfer_warn = 1;
 838                 } else {
 839                         if (host->scsi.SCp.scsi_xferred < SCpnt->underflow ||
 840                             host->scsi.SCp.scsi_xferred != host->dma.transferred)
 841                                 xfer_warn = 1;
 842                 }
 843
 844                 /* ANSI standard says: (SCSI-2 Rev 10c Sect 5.6.6)
 845                  *  Targets which break data transfers into multiple
 846                  *  connections shall end each successful connection
 847                  *  (except possibly the last) with a SAVE DATA
 848                  *  POINTER - DISCONNECT message sequence.
 849                  *
 850                  * This makes it difficult to ensure that a transfer has
 851                  * completed.  If we reach the end of a transfer during
 852                  * the command, then we can only have finished the transfer.
 853                  * therefore, if we seem to have some data remaining, this
 854                  * is not a problem.
 855                  */
 856                 if (host->dma.xfer_done)
 857                         xfer_warn = 0;
 858
 859                 if (xfer_warn) {
 860                     switch (status_byte(SCpnt->result)) {
 861                     case CHECK_CONDITION:
 862                     case COMMAND_TERMINATED:
 863                     case BUSY:
 864                     case QUEUE_FULL:
 865                     case RESERVATION_CONFLICT:
 866                         break;
 867
 868                     default:
 869                         printk(KERN_ERR "scsi%d.H: incomplete data transfer detected: result=%08X command=",
 870                                 host->host->host_no, SCpnt->result);
 871                         __scsi_print_command(SCpnt->cmnd);
 872                         acornscsi_dumpdma(host, "done");
 873                         acornscsi_dumplog(host, SCpnt->device->id);
 874                         SCpnt->result &= 0xffff;
 875                         SCpnt->result |= DID_ERROR << 16;
 876                     }
 877                 }
 878         }
 879
 880         if (!SCpnt->scsi_done)
 881             panic("scsi%d.H: null scsi_done function in acornscsi_done", host->host->host_no);
 882
 883         clear_bit(SCpnt->device->id * 8 + SCpnt->device->lun, host->busyluns);
 884
 885         SCpnt->scsi_done(SCpnt);
 886     } else
 887         printk("scsi%d: null command in acornscsi_done", host->host->host_no);
 888
 889     host->scsi.phase = PHASE_IDLE;
 890 }
 891
 892 /* ====================================================================================
 893  * DMA routines
 894  */
 895 /*
 896  * Purpose  : update SCSI Data Pointer
 897  * Notes    : this will only be one SG entry or less
 898  */
 899 static
 900 void acornscsi_data_updateptr(AS_Host *host, struct scsi_pointer *SCp, unsigned int length)
 901 {
 902     SCp->ptr += length;
 903     SCp->this_residual -= length;
 904
 905     if (SCp->this_residual == 0 && next_SCp(SCp) == 0)
 906         host->dma.xfer_done = 1;
 907 }
 908
 909 /*
 910  * Prototype: void acornscsi_data_read(AS_Host *host, char *ptr,
 911  *                              unsigned int start_addr, unsigned int length)
 912  * Purpose  : read data from DMA RAM
 913  * Params   : host - host to transfer from
 914  *            ptr  - DRAM address
 915  *            start_addr - host mem address
 916  *            length - number of bytes to transfer
 917  * Notes    : this will only be one SG entry or less
 918  */
 919 static
 920 void acornscsi_data_read(AS_Host *host, char *ptr,
 921                                  unsigned int start_addr, unsigned int length)
 922 {
 923     extern void __acornscsi_in(int port, char *buf, int len);
 924     unsigned int page, offset, len = length;
 925
 926     page = (start_addr >> 12);
 927     offset = start_addr & ((1 << 12) - 1);
 928
 929     outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
 930
 931     while (len > 0) {
 932         unsigned int this_len;
 933
 934         if (len + offset > (1 << 12))
 935             this_len = (1 << 12) - offset;
 936         else
 937             this_len = len;
 938
 939         __acornscsi_in(host->card.io_ram + (offset << 1), ptr, this_len);
 940
 941         offset += this_len;
 942         ptr += this_len;
 943         len -= this_len;
 944
 945         if (offset == (1 << 12)) {
 946             offset = 0;
 947             page ++;
 948             outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
 949         }
 950     }
 951     outb(host->card.page_reg, host->card.io_page);
 952 }
 953
 954 /*
 955  * Prototype: void acornscsi_data_write(AS_Host *host, char *ptr,
 956  *                              unsigned int start_addr, unsigned int length)
 957  * Purpose  : write data to DMA RAM
 958  * Params   : host - host to transfer from
 959  *            ptr  - DRAM address
 960  *            start_addr - host mem address
 961  *            length - number of bytes to transfer
 962  * Notes    : this will only be one SG entry or less
 963  */
 964 static
 965 void acornscsi_data_write(AS_Host *host, char *ptr,
 966                                  unsigned int start_addr, unsigned int length)
 967 {
 968     extern void __acornscsi_out(int port, char *buf, int len);
 969     unsigned int page, offset, len = length;
 970
 971     page = (start_addr >> 12);
 972     offset = start_addr & ((1 << 12) - 1);
 973
 974     outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
 975
 976     while (len > 0) {
 977         unsigned int this_len;
 978
 979         if (len + offset > (1 << 12))
 980             this_len = (1 << 12) - offset;
 981         else
 982             this_len = len;
 983
 984         __acornscsi_out(host->card.io_ram + (offset << 1), ptr, this_len);
 985
 986         offset += this_len;
 987         ptr += this_len;
 988         len -= this_len;
 989
 990         if (offset == (1 << 12)) {
 991             offset = 0;
 992             page ++;
 993             outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
 994         }
 995     }
 996     outb(host->card.page_reg, host->card.io_page);
 997 }
 998
 999 /* =========================================================================================
1000  * On-board DMA routines
1001  */
1002 #ifdef USE_DMAC
1003 /*
1004  * Prototype: void acornscsi_dmastop(AS_Host *host)
1005  * Purpose  : stop all DMA
1006  * Params   : host - host on which to stop DMA
1007  * Notes    : This is called when leaving DATA IN/OUT phase,
1008  *            or when interface is RESET
1009  */
1010 static inline
1011 void acornscsi_dma_stop(AS_Host *host)
1012 {
1013     dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
1014     dmac_clearintr(host->dma.io_intr_clear);
1015
1016 #if (DEBUG & DEBUG_DMA)
1017     DBG(host->SCpnt, acornscsi_dumpdma(host, "stop"));
1018 #endif
1019 }
1020
1021 /*
1022  * Function: void acornscsi_dma_setup(AS_Host *host, dmadir_t direction)
1023  * Purpose : setup DMA controller for data transfer
1024  * Params  : host - host to setup
1025  *           direction - data transfer direction
1026  * Notes   : This is called when entering DATA I/O phase, not
1027  *           while we're in a DATA I/O phase
1028  */
1029 static
1030 void acornscsi_dma_setup(AS_Host *host, dmadir_t direction)
1031 {
1032     unsigned int address, length, mode;
1033
1034     host->dma.direction = direction;
1035
1036     dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
1037
1038     if (direction == DMA_OUT) {
1039 #if (DEBUG & DEBUG_NO_WRITE)
1040         if (NO_WRITE & (1 << host->SCpnt->device->id)) {
1041             printk(KERN_CRIT "scsi%d.%c: I can't handle DMA_OUT!\n",
1042                     host->host->host_no, acornscsi_target(host));
1043             return;
1044         }
1045 #endif
1046         mode = DMAC_WRITE;
1047     } else
1048         mode = DMAC_READ;
1049
1050     /*
1051      * Allocate some buffer space, limited to half the buffer size
1052      */
1053     length = min_t(unsigned int, host->scsi.SCp.this_residual, DMAC_BUFFER_SIZE / 2);
1054     if (length) {
1055         host->dma.start_addr = address = host->dma.free_addr;
1056         host->dma.free_addr = (host->dma.free_addr + length) &
1057                                 (DMAC_BUFFER_SIZE - 1);
1058
1059         /*
1060          * Transfer data to DMA memory
1061          */
1062         if (direction == DMA_OUT)
1063             acornscsi_data_write(host, host->scsi.SCp.ptr, host->dma.start_addr,
1064                                 length);
1065
1066         length -= 1;
1067         dmac_write(host->dma.io_port, DMAC_TXCNTLO, length);
1068         dmac_write(host->dma.io_port, DMAC_TXCNTHI, length >> 8);
1069         dmac_write(host->dma.io_port, DMAC_TXADRLO, address);
1070         dmac_write(host->dma.io_port, DMAC_TXADRMD, address >> 8);
1071         dmac_write(host->dma.io_port, DMAC_TXADRHI, 0);
1072         dmac_write(host->dma.io_port, DMAC_MODECON, mode);
1073         dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_OFF);
1074
1075 #if (DEBUG & DEBUG_DMA)
1076         DBG(host->SCpnt, acornscsi_dumpdma(host, "strt"));
1077 #endif
1078         host->dma.xfer_setup = 1;
1079     }
1080 }
1081
1082 /*
1083  * Function: void acornscsi_dma_cleanup(AS_Host *host)
1084  * Purpose : ensure that all DMA transfers are up-to-date & host->scsi.SCp is correct
1085  * Params  : host - host to finish
1086  * Notes   : This is called when a command is:
1087  *              terminating, RESTORE_POINTERS, SAVE_POINTERS, DISCONECT
1088  *         : This must not return until all transfers are completed.
1089  */
1090 static
1091 void acornscsi_dma_cleanup(AS_Host *host)
1092 {
1093     dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
1094     dmac_clearintr(host->dma.io_intr_clear);
1095
1096     /*
1097      * Check for a pending transfer
1098      */
1099     if (host->dma.xfer_required) {
1100         host->dma.xfer_required = 0;
1101         if (host->dma.direction == DMA_IN)
1102             acornscsi_data_read(host, host->dma.xfer_ptr,
1103                                  host->dma.xfer_start, host->dma.xfer_length);
1104     }
1105
1106     /*
1107      * Has a transfer been setup?
1108      */
1109     if (host->dma.xfer_setup) {
1110         unsigned int transferred;
1111
1112         host->dma.xfer_setup = 0;
1113
1114 #if (DEBUG & DEBUG_DMA)
1115         DBG(host->SCpnt, acornscsi_dumpdma(host, "cupi"));
1116 #endif
1117
1118         /*
1119          * Calculate number of bytes transferred from DMA.
1120          */
1121         transferred = dmac_address(host->dma.io_port) - host->dma.start_addr;
1122         host->dma.transferred += transferred;
1123
1124         if (host->dma.direction == DMA_IN)
1125             acornscsi_data_read(host, host->scsi.SCp.ptr,
1126                                  host->dma.start_addr, transferred);
1127
1128         /*
1129          * Update SCSI pointers
1130          */
1131         acornscsi_data_updateptr(host, &host->scsi.SCp, transferred);
1132 #if (DEBUG & DEBUG_DMA)
1133         DBG(host->SCpnt, acornscsi_dumpdma(host, "cupo"));
1134 #endif
1135     }
1136 }
1137
1138 /*
1139  * Function: void acornscsi_dmacintr(AS_Host *host)
1140  * Purpose : handle interrupts from DMAC device
1141  * Params  : host - host to process
1142  * Notes   : If reading, we schedule the read to main memory &
1143  *           allow the transfer to continue.
1144  *         : If writing, we fill the onboard DMA memory from main
1145  *           memory.
1146  *         : Called whenever DMAC finished it's current transfer.
1147  */
1148 static
1149 void acornscsi_dma_intr(AS_Host *host)
1150 {
1151     unsigned int address, length, transferred;
1152
1153 #if (DEBUG & DEBUG_DMA)
1154     DBG(host->SCpnt, acornscsi_dumpdma(host, "inti"));
1155 #endif
1156
1157     dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
1158     dmac_clearintr(host->dma.io_intr_clear);
1159
1160     /*
1161      * Calculate amount transferred via DMA
1162      */
1163     transferred = dmac_address(host->dma.io_port) - host->dma.start_addr;
1164     host->dma.transferred += transferred;
1165
1166     /*
1167      * Schedule DMA transfer off board
1168      */
1169     if (host->dma.direction == DMA_IN) {
1170         host->dma.xfer_start = host->dma.start_addr;
1171         host->dma.xfer_length = transferred;
1172         host->dma.xfer_ptr = host->scsi.SCp.ptr;
1173         host->dma.xfer_required = 1;
1174     }
1175
1176     acornscsi_data_updateptr(host, &host->scsi.SCp, transferred);
1177
1178     /*
1179      * Allocate some buffer space, limited to half the on-board RAM size
1180      */
1181     length = min_t(unsigned int, host->scsi.SCp.this_residual, DMAC_BUFFER_SIZE / 2);
1182     if (length) {
1183         host->dma.start_addr = address = host->dma.free_addr;
1184         host->dma.free_addr = (host->dma.free_addr + length) &
1185                                 (DMAC_BUFFER_SIZE - 1);
1186
1187         /*
1188          * Transfer data to DMA memory
1189          */
1190         if (host->dma.direction == DMA_OUT)
1191             acornscsi_data_write(host, host->scsi.SCp.ptr, host->dma.start_addr,
1192                                 length);
1193
1194         length -= 1;
1195         dmac_write(host->dma.io_port, DMAC_TXCNTLO, length);
1196         dmac_write(host->dma.io_port, DMAC_TXCNTHI, length >> 8);
1197         dmac_write(host->dma.io_port, DMAC_TXADRLO, address);
1198         dmac_write(host->dma.io_port, DMAC_TXADRMD, address >> 8);
1199         dmac_write(host->dma.io_port, DMAC_TXADRHI, 0);
1200         dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_OFF);
1201
1202 #if (DEBUG & DEBUG_DMA)
1203         DBG(host->SCpnt, acornscsi_dumpdma(host, "into"));
1204 #endif
1205     } else {
1206         host->dma.xfer_setup = 0;
1207 #if 0
1208         /*
1209          * If the interface still wants more, then this is an error.
1210          * We give it another byte, but we also attempt to raise an
1211          * attention condition.  We continue giving one byte until
1212          * the device recognises the attention.
1213          */
1214         if (dmac_read(host->dma.io_port, DMAC_STATUS) & STATUS_RQ0) {
1215             acornscsi_abortcmd(host, host->SCpnt->tag);
1216
1217             dmac_write(host->dma.io_port, DMAC_TXCNTLO, 0);
1218             dmac_write(host->dma.io_port, DMAC_TXCNTHI, 0);
1219             dmac_write(host->dma.io_port, DMAC_TXADRLO, 0);
1220             dmac_write(host->dma.io_port, DMAC_TXADRMD, 0);
1221             dmac_write(host->dma.io_port, DMAC_TXADRHI, 0);
1222             dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_OFF);
1223         }
1224 #endif
1225     }
1226 }
1227
1228 /*
1229  * Function: void acornscsi_dma_xfer(AS_Host *host)
1230  * Purpose : transfer data between AcornSCSI and memory
1231  * Params  : host - host to process
1232  */
1233 static
1234 void acornscsi_dma_xfer(AS_Host *host)
1235 {
1236     host->dma.xfer_required = 0;
1237
1238     if (host->dma.direction == DMA_IN)
1239         acornscsi_data_read(host, host->dma.xfer_ptr,
1240                                 host->dma.xfer_start, host->dma.xfer_length);
1241 }
1242
1243 /*
1244  * Function: void acornscsi_dma_adjust(AS_Host *host)
1245  * Purpose : adjust DMA pointers & count for bytes transferred to
1246  *           SBIC but not SCSI bus.
1247  * Params  : host - host to adjust DMA count for
1248  */
1249 static
1250 void acornscsi_dma_adjust(AS_Host *host)
1251 {
1252     if (host->dma.xfer_setup) {
1253         signed long transferred;
1254 #if (DEBUG & (DEBUG_DMA|DEBUG_WRITE))
1255         DBG(host->SCpnt, acornscsi_dumpdma(host, "adji"));
1256 #endif
1257         /*
1258          * Calculate correct DMA address - DMA is ahead of SCSI bus while
1259          * writing.
1260          *  host->scsi.SCp.scsi_xferred is the number of bytes
1261          *  actually transferred to/from the SCSI bus.
1262          *  host->dma.transferred is the number of bytes transferred
1263          *  over DMA since host->dma.start_addr was last set.
1264          *
1265          * real_dma_addr = host->dma.start_addr + host->scsi.SCp.scsi_xferred
1266          *                 - host->dma.transferred
1267          */
1268         transferred = host->scsi.SCp.scsi_xferred - host->dma.transferred;
1269         if (transferred < 0)
1270             printk("scsi%d.%c: Ack! DMA write correction %ld < 0!\n",
1271                     host->host->host_no, acornscsi_target(host), transferred);
1272         else if (transferred == 0)
1273             host->dma.xfer_setup = 0;
1274         else {
1275             transferred += host->dma.start_addr;
1276             dmac_write(host->dma.io_port, DMAC_TXADRLO, transferred);
1277             dmac_write(host->dma.io_port, DMAC_TXADRMD, transferred >> 8);
1278             dmac_write(host->dma.io_port, DMAC_TXADRHI, transferred >> 16);
1279 #if (DEBUG & (DEBUG_DMA|DEBUG_WRITE))
1280             DBG(host->SCpnt, acornscsi_dumpdma(host, "adjo"));
1281 #endif
1282         }
1283     }
1284 }
1285 #endif
1286
1287 /* =========================================================================================
1288  * Data I/O
1289  */
1290 static int
1291 acornscsi_write_pio(AS_Host *host, char *bytes, int *ptr, int len, unsigned int max_timeout)
1292 {
1293         unsigned int asr, timeout = max_timeout;
1294         int my_ptr = *ptr;
1295
1296         while (my_ptr < len) {
1297                 asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
1298
1299                 if (asr & ASR_DBR) {
1300                         timeout = max_timeout;
1301
1302                         sbic_arm_write(host->scsi.io_port, SBIC_DATA, bytes[my_ptr++]);
1303                 } else if (asr & ASR_INT)
1304                         break;
1305                 else if (--timeout == 0)
1306                         break;
1307                 udelay(1);
1308         }
1309
1310         *ptr = my_ptr;
1311
1312         return (timeout == 0) ? -1 : 0;
1313 }
1314
1315 /*
1316  * Function: void acornscsi_sendcommand(AS_Host *host)
1317  * Purpose : send a command to a target
1318  * Params  : host - host which is connected to target
1319  */
1320 static void
1321 acornscsi_sendcommand(AS_Host *host)
1322 {
1323     Scsi_Cmnd *SCpnt = host->SCpnt;
1324
1325     sbic_arm_write(host->scsi.io_port, SBIC_TRANSCNTH, 0);
1326     sbic_arm_writenext(host->scsi.io_port, 0);
1327     sbic_arm_writenext(host->scsi.io_port, SCpnt->cmd_len - host->scsi.SCp.sent_command);
1328
1329     acornscsi_sbic_issuecmd(host, CMND_XFERINFO);
1330
1331     if (acornscsi_write_pio(host, SCpnt->cmnd,
1332         (int *)&host->scsi.SCp.sent_command, SCpnt->cmd_len, 1000000))
1333         printk("scsi%d: timeout while sending command\n", host->host->host_no);
1334
1335     host->scsi.phase = PHASE_COMMAND;
1336 }
1337
1338 static
1339 void acornscsi_sendmessage(AS_Host *host)
1340 {
1341     unsigned int message_length = msgqueue_msglength(&host->scsi.msgs);
1342     unsigned int msgnr;
1343     struct message *msg;
1344
1345 #if (DEBUG & DEBUG_MESSAGES)
1346     printk("scsi%d.%c: sending message ",
1347             host->host->host_no, acornscsi_target(host));
1348 #endif
1349
1350     switch (message_length) {
1351     case 0:
1352         acornscsi_sbic_issuecmd(host, CMND_XFERINFO | CMND_SBT);
1353
1354         acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "sending message 1");
1355
1356         sbic_arm_write(host->scsi.io_port, SBIC_DATA, NOP);
1357
1358         host->scsi.last_message = NOP;
1359 #if (DEBUG & DEBUG_MESSAGES)
1360         printk("NOP");
1361 #endif
1362         break;
1363
1364     case 1:
1365         acornscsi_sbic_issuecmd(host, CMND_XFERINFO | CMND_SBT);
1366         msg = msgqueue_getmsg(&host->scsi.msgs, 0);
1367
1368         acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "sending message 2");
1369
1370         sbic_arm_write(host->scsi.io_port, SBIC_DATA, msg->msg[0]);
1371
1372         host->scsi.last_message = msg->msg[0];
1373 #if (DEBUG & DEBUG_MESSAGES)
1374         spi_print_msg(msg->msg);
1375 #endif
1376         break;
1377
1378     default:
1379         /*
1380          * ANSI standard says: (SCSI-2 Rev 10c Sect 5.6.14)
1381          * 'When a target sends this (MESSAGE_REJECT) message, it
1382          *  shall change to MESSAGE IN phase and send this message
1383          *  prior to requesting additional message bytes from the
1384          *  initiator.  This provides an interlock so that the
1385          *  initiator can determine which message byte is rejected.
1386          */
1387         sbic_arm_write(host->scsi.io_port, SBIC_TRANSCNTH, 0);
1388         sbic_arm_writenext(host->scsi.io_port, 0);
1389         sbic_arm_writenext(host->scsi.io_port, message_length);
1390         acornscsi_sbic_issuecmd(host, CMND_XFERINFO);
1391
1392         msgnr = 0;
1393         while ((msg = msgqueue_getmsg(&host->scsi.msgs, msgnr++)) != NULL) {
1394             unsigned int i;
1395 #if (DEBUG & DEBUG_MESSAGES)
1396             spi_print_msg(msg);
1397 #endif
1398             i = 0;
1399             if (acornscsi_write_pio(host, msg->msg, &i, msg->length, 1000000))
1400                 printk("scsi%d: timeout while sending message\n", host->host->host_no);
1401
1402             host->scsi.last_message = msg->msg[0];
1403             if (msg->msg[0] == EXTENDED_MESSAGE)
1404                 host->scsi.last_message |= msg->msg[2] << 8;
1405
1406             if (i != msg->length)
1407                 break;
1408         }
1409         break;
1410     }
1411 #if (DEBUG & DEBUG_MESSAGES)
1412     printk("\n");
1413 #endif
1414 }
1415
1416 /*
1417  * Function: void acornscsi_readstatusbyte(AS_Host *host)
1418  * Purpose : Read status byte from connected target
1419  * Params  : host - host connected to target
1420  */
1421 static
1422 void acornscsi_readstatusbyte(AS_Host *host)
1423 {
1424     acornscsi_sbic_issuecmd(host, CMND_XFERINFO|CMND_SBT);
1425     acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "reading status byte");
1426     host->scsi.SCp.Status = sbic_arm_read(host->scsi.io_port, SBIC_DATA);
1427 }
1428
1429 /*
1430  * Function: unsigned char acornscsi_readmessagebyte(AS_Host *host)
1431  * Purpose : Read one message byte from connected target
1432  * Params  : host - host connected to target
1433  */
1434 static
1435 unsigned char acornscsi_readmessagebyte(AS_Host *host)
1436 {
1437     unsigned char message;
1438
1439     acornscsi_sbic_issuecmd(host, CMND_XFERINFO | CMND_SBT);
1440
1441     acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "for message byte");
1442
1443     message = sbic_arm_read(host->scsi.io_port, SBIC_DATA);
1444
1445     /* wait for MSGIN-XFER-PAUSED */
1446     acornscsi_sbic_wait(host, ASR_INT, ASR_INT, 1000, "for interrupt after message byte");
1447
1448     sbic_arm_read(host->scsi.io_port, SBIC_SSR);
1449
1450     return message;
1451 }
1452
1453 /*
1454  * Function: void acornscsi_message(AS_Host *host)
1455  * Purpose : Read complete message from connected target & action message
1456  * Params  : host - host connected to target
1457  */
1458 static
1459 void acornscsi_message(AS_Host *host)
1460 {
1461     unsigned char message[16];
1462     unsigned int msgidx = 0, msglen = 1;
1463
1464     do {
1465         message[msgidx] = acornscsi_readmessagebyte(host);
1466
1467         switch (msgidx) {
1468         case 0:
1469             if (message[0] == EXTENDED_MESSAGE ||
1470                 (message[0] >= 0x20 && message[0] <= 0x2f))
1471                 msglen = 2;
1472             break;
1473
1474         case 1:
1475             if (message[0] == EXTENDED_MESSAGE)
1476                 msglen += message[msgidx];
1477             break;
1478         }
1479         msgidx += 1;
1480         if (msgidx < msglen) {
1481             acornscsi_sbic_issuecmd(host, CMND_NEGATEACK);
1482
1483             /* wait for next msg-in */
1484             acornscsi_sbic_wait(host, ASR_INT, ASR_INT, 1000, "for interrupt after negate ack");
1485             sbic_arm_read(host->scsi.io_port, SBIC_SSR);
1486         }
1487     } while (msgidx < msglen);
1488
1489 #if (DEBUG & DEBUG_MESSAGES)
1490     printk("scsi%d.%c: message in: ",
1491             host->host->host_no, acornscsi_target(host));
1492     spi_print_msg(message);
1493     printk("\n");
1494 #endif
1495
1496     if (host->scsi.phase == PHASE_RECONNECTED) {
1497         /*
1498          * ANSI standard says: (Section SCSI-2 Rev. 10c Sect 5.6.17)
1499          * 'Whenever a target reconnects to an initiator to continue
1500          *  a tagged I/O process, the SIMPLE QUEUE TAG message shall
1501          *  be sent immediately following the IDENTIFY message...'
1502          */
1503         if (message[0] == SIMPLE_QUEUE_TAG)
1504             host->scsi.reconnected.tag = message[1];
1505         if (acornscsi_reconnect_finish(host))
1506             host->scsi.phase = PHASE_MSGIN;
1507     }
1508
1509     switch (message[0]) {
1510     case ABORT:
1511     case ABORT_TAG:
1512     case COMMAND_COMPLETE:
1513         if (host->scsi.phase != PHASE_STATUSIN) {
1514             printk(KERN_ERR "scsi%d.%c: command complete following non-status in phase?\n",
1515                     host->host->host_no, acornscsi_target(host));
1516             acornscsi_dumplog(host, host->SCpnt->device->id);
1517         }
1518         host->scsi.phase = PHASE_DONE;
1519         host->scsi.SCp.Message = message[0];
1520         break;
1521
1522     case SAVE_POINTERS:
1523         /*
1524          * ANSI standard says: (Section SCSI-2 Rev. 10c Sect 5.6.20)
1525          * 'The SAVE DATA POINTER message is sent from a target to
1526          *  direct the initiator to copy the active data pointer to
1527          *  the saved data pointer for the current I/O process.
1528          */
1529         acornscsi_dma_cleanup(host);
1530         host->SCpnt->SCp = host->scsi.SCp;
1531         host->SCpnt->SCp.sent_command = 0;
1532         host->scsi.phase = PHASE_MSGIN;
1533         break;
1534
1535     case RESTORE_POINTERS:
1536         /*
1537          * ANSI standard says: (Section SCSI-2 Rev. 10c Sect 5.6.19)
1538          * 'The RESTORE POINTERS message is sent from a target to
1539          *  direct the initiator to copy the most recently saved
1540          *  command, data, and status pointers for the I/O process
1541          *  to the corresponding active pointers.  The command and
1542          *  status pointers shall be restored to the beginning of
1543          *  the present command and status areas.'
1544          */
1545         acornscsi_dma_cleanup(host);
1546         host->scsi.SCp = host->SCpnt->SCp;
1547         host->scsi.phase = PHASE_MSGIN;
1548         break;
1549
1550     case DISCONNECT:
1551         /*
1552          * ANSI standard says: (Section SCSI-2 Rev. 10c Sect 6.4.2)
1553          * 'On those occasions when an error or exception condition occurs
1554          *  and the target elects to repeat the information transfer, the
1555          *  target may repeat the transfer either issuing a RESTORE POINTERS
1556          *  message or by disconnecting without issuing a SAVE POINTERS
1557          *  message.  When reconnection is completed, the most recent
1558          *  saved pointer values are restored.'
1559          */
1560         acornscsi_dma_cleanup(host);
1561         host->scsi.phase = PHASE_DISCONNECT;
1562         break;
1563
1564     case MESSAGE_REJECT:
1565 #if 0 /* this isn't needed any more */
1566         /*
1567          * If we were negociating sync transfer, we don't yet know if
1568          * this REJECT is for the sync transfer or for the tagged queue/wide
1569          * transfer.  Re-initiate sync transfer negociation now, and if
1570          * we got a REJECT in response to SDTR, then it'll be set to DONE.
1571          */
1572         if (host->device[host->SCpnt->device->id].sync_state == SYNC_SENT_REQUEST)
1573             host->device[host->SCpnt->device->id].sync_state = SYNC_NEGOCIATE;
1574 #endif
1575
1576         /*
1577          * If we have any messages waiting to go out, then assert ATN now
1578          */
1579         if (msgqueue_msglength(&host->scsi.msgs))
1580             acornscsi_sbic_issuecmd(host, CMND_ASSERTATN);
1581
1582         switch (host->scsi.last_message) {
1583 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
1584         case HEAD_OF_QUEUE_TAG:
1585         case ORDERED_QUEUE_TAG:
1586         case SIMPLE_QUEUE_TAG:
1587             /*
1588              * ANSI standard says: (Section SCSI-2 Rev. 10c Sect 5.6.17)
1589              *  If a target does not implement tagged queuing and a queue tag
1590              *  message is received, it shall respond with a MESSAGE REJECT
1591              *  message and accept the I/O process as if it were untagged.
1592              */
1593             printk(KERN_NOTICE "scsi%d.%c: disabling tagged queueing\n",
1594                     host->host->host_no, acornscsi_target(host));
1595             host->SCpnt->device->simple_tags = 0;
1596             set_bit(host->SCpnt->device->id * 8 + host->SCpnt->device->lun, host->busyluns);
1597             break;
1598 #endif
1599         case EXTENDED_MESSAGE | (EXTENDED_SDTR << 8):
1600             /*
1601              * Target can't handle synchronous transfers
1602              */
1603             printk(KERN_NOTICE "scsi%d.%c: Using asynchronous transfer\n",
1604                     host->host->host_no, acornscsi_target(host));
1605             host->device[host->SCpnt->device->id].sync_xfer = SYNCHTRANSFER_2DBA;
1606             host->device[host->SCpnt->device->id].sync_state = SYNC_ASYNCHRONOUS;
1607             sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
1608             break;
1609
1610         default:
1611             break;
1612         }
1613         break;
1614
1615     case QUEUE_FULL:
1616         /* TODO: target queue is full */
1617         break;
1618
1619     case SIMPLE_QUEUE_TAG:
1620         /* tag queue reconnect... message[1] = queue tag.  Print something to indicate something happened! */
1621         printk("scsi%d.%c: reconnect queue tag %02X\n",
1622                 host->host->host_no, acornscsi_target(host),
1623                 message[1]);
1624         break;
1625
1626     case EXTENDED_MESSAGE:
1627         switch (message[2]) {
1628 #ifdef CONFIG_SCSI_ACORNSCSI_SYNC
1629         case EXTENDED_SDTR:
1630             if (host->device[host->SCpnt->device->id].sync_state == SYNC_SENT_REQUEST) {
1631                 /*
1632                  * We requested synchronous transfers.  This isn't quite right...
1633                  * We can only say if this succeeded if we proceed on to execute the
1634                  * command from this message.  If we get a MESSAGE PARITY ERROR,
1635                  * and the target retries fail, then we fallback to asynchronous mode
1636                  */
1637                 host->device[host->SCpnt->device->id].sync_state = SYNC_COMPLETED;
1638                 printk(KERN_NOTICE "scsi%d.%c: Using synchronous transfer, offset %d, %d ns\n",
1639                         host->host->host_no, acornscsi_target(host),
1640                         message[4], message[3] * 4);
1641                 host->device[host->SCpnt->device->id].sync_xfer =
1642                         calc_sync_xfer(message[3] * 4, message[4]);
1643             } else {
1644                 unsigned char period, length;
1645                 /*
1646                  * Target requested synchronous transfers.  The agreement is only
1647                  * to be in operation AFTER the target leaves message out phase.
1648                  */
1649                 acornscsi_sbic_issuecmd(host, CMND_ASSERTATN);
1650                 period = max_t(unsigned int, message[3], sdtr_period / 4);
1651                 length = min_t(unsigned int, message[4], sdtr_size);
1652                 msgqueue_addmsg(&host->scsi.msgs, 5, EXTENDED_MESSAGE, 3,
1653                                  EXTENDED_SDTR, period, length);
1654                 host->device[host->SCpnt->device->id].sync_xfer =
1655                         calc_sync_xfer(period * 4, length);
1656             }
1657             sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
1658             break;
1659 #else
1660             /* We do not accept synchronous transfers.  Respond with a
1661              * MESSAGE_REJECT.
1662              */
1663 #endif
1664
1665         case EXTENDED_WDTR:
1666             /* The WD33C93A is only 8-bit.  We respond with a MESSAGE_REJECT
1667              * to a wide data transfer request.
1668              */
1669         default:
1670             acornscsi_sbic_issuecmd(host, CMND_ASSERTATN);
1671             msgqueue_flush(&host->scsi.msgs);
1672             msgqueue_addmsg(&host->scsi.msgs, 1, MESSAGE_REJECT);
1673             break;
1674         }
1675         break;
1676
1677 #ifdef CONFIG_SCSI_ACORNSCSI_LINK
1678     case LINKED_CMD_COMPLETE:
1679     case LINKED_FLG_CMD_COMPLETE:
1680         /*
1681          * We don't support linked commands yet
1682          */
1683         if (0) {
1684 #if (DEBUG & DEBUG_LINK)
1685             printk("scsi%d.%c: lun %d tag %d linked command complete\n",
1686                     host->host->host_no, acornscsi_target(host), host->SCpnt->tag);
1687 #endif
1688             /*
1689              * A linked command should only terminate with one of these messages
1690              * if there are more linked commands available.
1691              */
1692             if (!host->SCpnt->next_link) {
1693                 printk(KERN_WARNING "scsi%d.%c: lun %d tag %d linked command complete, but no next_link\n",
1694                         instance->host_no, acornscsi_target(host), host->SCpnt->tag);
1695                 acornscsi_sbic_issuecmd(host, CMND_ASSERTATN);
1696                 msgqueue_addmsg(&host->scsi.msgs, 1, ABORT);
1697             } else {
1698                 Scsi_Cmnd *SCpnt = host->SCpnt;
1699
1700                 acornscsi_dma_cleanup(host);
1701
1702                 host->SCpnt = host->SCpnt->next_link;
1703                 host->SCpnt->tag = SCpnt->tag;
1704                 SCpnt->result = DID_OK | host->scsi.SCp.Message << 8 | host->Scsi.SCp.Status;
1705                 SCpnt->done(SCpnt);
1706
1707                 /* initialise host->SCpnt->SCp */
1708             }
1709             break;
1710         }
1711 #endif
1712
1713     default: /* reject message */
1714         printk(KERN_ERR "scsi%d.%c: unrecognised message %02X, rejecting\n",
1715                 host->host->host_no, acornscsi_target(host),
1716                 message[0]);
1717         acornscsi_sbic_issuecmd(host, CMND_ASSERTATN);
1718         msgqueue_flush(&host->scsi.msgs);
1719         msgqueue_addmsg(&host->scsi.msgs, 1, MESSAGE_REJECT);
1720         host->scsi.phase = PHASE_MSGIN;
1721         break;
1722     }
1723     acornscsi_sbic_issuecmd(host, CMND_NEGATEACK);
1724 }
1725
1726 /*
1727  * Function: int acornscsi_buildmessages(AS_Host *host)
1728  * Purpose : build the connection messages for a host
1729  * Params  : host - host to add messages to
1730  */
1731 static
1732 void acornscsi_buildmessages(AS_Host *host)
1733 {
1734 #if 0
1735     /* does the device need resetting? */
1736     if (cmd_reset) {
1737         msgqueue_addmsg(&host->scsi.msgs, 1, BUS_DEVICE_RESET);
1738         return;
1739     }
1740 #endif
1741
1742     msgqueue_addmsg(&host->scsi.msgs, 1,
1743                      IDENTIFY(host->device[host->SCpnt->device->id].disconnect_ok,
1744                              host->SCpnt->device->lun));
1745
1746 #if 0
1747     /* does the device need the current command aborted */
1748     if (cmd_aborted) {
1749         acornscsi_abortcmd(host->SCpnt->tag);
1750         return;
1751     }
1752 #endif
1753
1754 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
1755     if (host->SCpnt->tag) {
1756         unsigned int tag_type;
1757
1758         if (host->SCpnt->cmnd[0] == REQUEST_SENSE ||
1759             host->SCpnt->cmnd[0] == TEST_UNIT_READY ||
1760             host->SCpnt->cmnd[0] == INQUIRY)
1761             tag_type = HEAD_OF_QUEUE_TAG;
1762         else
1763             tag_type = SIMPLE_QUEUE_TAG;
1764         msgqueue_addmsg(&host->scsi.msgs, 2, tag_type, host->SCpnt->tag);
1765     }
1766 #endif
1767
1768 #ifdef CONFIG_SCSI_ACORNSCSI_SYNC
1769     if (host->device[host->SCpnt->device->id].sync_state == SYNC_NEGOCIATE) {
1770         host->device[host->SCpnt->device->id].sync_state = SYNC_SENT_REQUEST;
1771         msgqueue_addmsg(&host->scsi.msgs, 5,
1772                          EXTENDED_MESSAGE, 3, EXTENDED_SDTR,
1773                          sdtr_period / 4, sdtr_size);
1774     }
1775 #endif
1776 }
1777
1778 /*
1779  * Function: int acornscsi_starttransfer(AS_Host *host)
1780  * Purpose : transfer data to/from connected target
1781  * Params  : host - host to which target is connected
1782  * Returns : 0 if failure
1783  */
1784 static
1785 int acornscsi_starttransfer(AS_Host *host)
1786 {
1787     int residual;
1788
1789     if (!host->scsi.SCp.ptr /*&& host->scsi.SCp.this_residual*/) {
1790         printk(KERN_ERR "scsi%d.%c: null buffer passed to acornscsi_starttransfer\n",
1791                 host->host->host_no, acornscsi_target(host));
1792         return 0;
1793     }
1794
1795     residual = host->SCpnt->request_bufflen - host->scsi.SCp.scsi_xferred;
1796
1797     sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
1798     sbic_arm_writenext(host->scsi.io_port, residual >> 16);
1799     sbic_arm_writenext(host->scsi.io_port, residual >> 8);
1800     sbic_arm_writenext(host->scsi.io_port, residual);
1801     acornscsi_sbic_issuecmd(host, CMND_XFERINFO);
1802     return 1;
1803 }
1804
1805 /* =========================================================================================
1806  * Connection & Disconnection
1807  */
1808 /*
1809  * Function : acornscsi_reconnect(AS_Host *host)
1810  * Purpose  : reconnect a previously disconnected command
1811  * Params   : host - host specific data
1812  * Remarks  : SCSI spec says:
1813  *              'The set of active pointers is restored from the set
1814  *               of saved pointers upon reconnection of the I/O process'
1815  */
1816 static
1817 int acornscsi_reconnect(AS_Host *host)
1818 {
1819     unsigned int target, lun, ok = 0;
1820
1821     target = sbic_arm_read(host->scsi.io_port, SBIC_SOURCEID);
1822
1823     if (!(target & 8))
1824         printk(KERN_ERR "scsi%d: invalid source id after reselection "
1825                 "- device fault?\n",
1826                 host->host->host_no);
1827
1828     target &= 7;
1829
1830     if (host->SCpnt && !host->scsi.disconnectable) {
1831         printk(KERN_ERR "scsi%d.%d: reconnected while command in "
1832                 "progress to target %d?\n",
1833                 host->host->host_no, target, host->SCpnt->device->id);
1834         host->SCpnt = NULL;
1835     }
1836
1837     lun = sbic_arm_read(host->scsi.io_port, SBIC_DATA) & 7;
1838
1839     host->scsi.reconnected.target = target;
1840     host->scsi.reconnected.lun = lun;
1841     host->scsi.reconnected.tag = 0;
1842
1843     if (host->scsi.disconnectable && host->SCpnt &&
1844         host->SCpnt->device->id == target && host->SCpnt->device->lun == lun)
1845         ok = 1;
1846
1847     if (!ok && queue_probetgtlun(&host->queues.disconnected, target, lun))
1848         ok = 1;
1849
1850     ADD_STATUS(target, 0x81, host->scsi.phase, 0);
1851
1852     if (ok) {
1853         host->scsi.phase = PHASE_RECONNECTED;
1854     } else {
1855         /* this doesn't seem to work */
1856         printk(KERN_ERR "scsi%d.%c: reselected with no command "
1857                 "to reconnect with\n",
1858                 host->host->host_no, '0' + target);
1859         acornscsi_dumplog(host, target);
1860         acornscsi_abortcmd(host, 0);
1861         if (host->SCpnt) {
1862             queue_add_cmd_tail(&host->queues.disconnected, host->SCpnt);
1863             host->SCpnt = NULL;
1864         }
1865     }
1866     acornscsi_sbic_issuecmd(host, CMND_NEGATEACK);
1867     return !ok;
1868 }
1869
1870 /*
1871  * Function: int acornscsi_reconect_finish(AS_Host *host)
1872  * Purpose : finish reconnecting a command
1873  * Params  : host - host to complete
1874  * Returns : 0 if failed
1875  */
1876 static
1877 int acornscsi_reconnect_finish(AS_Host *host)
1878 {
1879     if (host->scsi.disconnectable && host->SCpnt) {
1880         host->scsi.disconnectable = 0;
1881         if (host->SCpnt->device->id  == host->scsi.reconnected.target &&
1882             host->SCpnt->device->lun == host->scsi.reconnected.lun &&
1883             host->SCpnt->tag         == host->scsi.reconnected.tag) {
1884 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
1885             DBG(host->SCpnt, printk("scsi%d.%c: reconnected",
1886                     host->host->host_no, acornscsi_target(host)));
1887 #endif
1888         } else {
1889             queue_add_cmd_tail(&host->queues.disconnected, host->SCpnt);
1890 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
1891             DBG(host->SCpnt, printk("scsi%d.%c: had to move command "
1892                     "to disconnected queue\n",
1893                     host->host->host_no, acornscsi_target(host)));
1894 #endif
1895             host->SCpnt = NULL;
1896         }
1897     }
1898     if (!host->SCpnt) {
1899         host->SCpnt = queue_remove_tgtluntag(&host->queues.disconnected,
1900                                 host->scsi.reconnected.target,
1901                                 host->scsi.reconnected.lun,
1902                                 host->scsi.reconnected.tag);
1903 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
1904         DBG(host->SCpnt, printk("scsi%d.%c: had to get command",
1905                 host->host->host_no, acornscsi_target(host)));
1906 #endif
1907     }
1908
1909     if (!host->SCpnt)
1910         acornscsi_abortcmd(host, host->scsi.reconnected.tag);
1911     else {
1912         /*
1913          * Restore data pointer from SAVED pointers.
1914          */
1915         host->scsi.SCp = host->SCpnt->SCp;
1916 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
1917         printk(", data pointers: [%p, %X]",
1918                 host->scsi.SCp.ptr, host->scsi.SCp.this_residual);
1919 #endif
1920     }
1921 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
1922     printk("\n");
1923 #endif
1924
1925     host->dma.transferred = host->scsi.SCp.scsi_xferred;
1926
1927     return host->SCpnt != NULL;
1928 }
1929
1930 /*
1931  * Function: void acornscsi_disconnect_unexpected(AS_Host *host)
1932  * Purpose : handle an unexpected disconnect
1933  * Params  : host - host on which disconnect occurred
1934  */
1935 static
1936 void acornscsi_disconnect_unexpected(AS_Host *host)
1937 {
1938     printk(KERN_ERR "scsi%d.%c: unexpected disconnect\n",
1939             host->host->host_no, acornscsi_target(host));
1940 #if (DEBUG & DEBUG_ABORT)
1941     acornscsi_dumplog(host, 8);
1942 #endif
1943
1944     acornscsi_done(host, &host->SCpnt, DID_ERROR);
1945 }
1946
1947 /*
1948  * Function: void acornscsi_abortcmd(AS_host *host, unsigned char tag)
1949  * Purpose : abort a currently executing command
1950  * Params  : host - host with connected command to abort
1951  *           tag  - tag to abort
1952  */
1953 static
1954 void acornscsi_abortcmd(AS_Host *host, unsigned char tag)
1955 {
1956     host->scsi.phase = PHASE_ABORTED;
1957     sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_ASSERTATN);
1958
1959     msgqueue_flush(&host->scsi.msgs);
1960 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
1961     if (tag)
1962         msgqueue_addmsg(&host->scsi.msgs, 2, ABORT_TAG, tag);
1963     else
1964 #endif
1965         msgqueue_addmsg(&host->scsi.msgs, 1, ABORT);
1966 }
1967
1968 /* ==========================================================================================
1969  * Interrupt routines.
1970  */
1971 /*
1972  * Function: int acornscsi_sbicintr(AS_Host *host)
1973  * Purpose : handle interrupts from SCSI device
1974  * Params  : host - host to process
1975  * Returns : INTR_PROCESS if expecting another SBIC interrupt
1976  *           INTR_IDLE if no interrupt
1977  *           INTR_NEXT_COMMAND if we have finished processing the command
1978  */
1979 static
1980 intr_ret_t acornscsi_sbicintr(AS_Host *host, int in_irq)
1981 {
1982     unsigned int asr, ssr;
1983
1984     asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
1985     if (!(asr & ASR_INT))
1986         return INTR_IDLE;
1987
1988     ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
1989
1990 #if (DEBUG & DEBUG_PHASES)
1991     print_sbic_status(asr, ssr, host->scsi.phase);
1992 #endif
1993
1994     ADD_STATUS(8, ssr, host->scsi.phase, in_irq);
1995
1996     if (host->SCpnt && !host->scsi.disconnectable)
1997         ADD_STATUS(host->SCpnt->device->id, ssr, host->scsi.phase, in_irq);
1998
1999     switch (ssr) {
2000     case 0x00:                          /* reset state - not advanced                   */
2001         printk(KERN_ERR "scsi%d: reset in standard mode but wanted advanced mode.\n",
2002                 host->host->host_no);
2003         /* setup sbic - WD33C93A */
2004         sbic_arm_write(host->scsi.io_port, SBIC_OWNID, OWNID_EAF | host->host->this_id);
2005         sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_RESET);
2006         return INTR_IDLE;
2007
2008     case 0x01:                          /* reset state - advanced                       */
2009         sbic_arm_write(host->scsi.io_port, SBIC_CTRL, INIT_SBICDMA | CTRL_IDI);
2010         sbic_arm_write(host->scsi.io_port, SBIC_TIMEOUT, TIMEOUT_TIME);
2011         sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, SYNCHTRANSFER_2DBA);
2012         sbic_arm_write(host->scsi.io_port, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
2013         msgqueue_flush(&host->scsi.msgs);
2014         return INTR_IDLE;
2015
2016     case 0x41:                          /* unexpected disconnect aborted command        */
2017         acornscsi_disconnect_unexpected(host);
2018         return INTR_NEXT_COMMAND;
2019     }
2020
2021     switch (host->scsi.phase) {
2022     case PHASE_CONNECTING:              /* STATE: command removed from issue queue      */
2023         switch (ssr) {
2024         case 0x11:                      /* -> PHASE_CONNECTED                           */
2025             /* BUS FREE -> SELECTION */
2026             host->scsi.phase = PHASE_CONNECTED;
2027             msgqueue_flush(&host->scsi.msgs);
2028             host->dma.transferred = host->scsi.SCp.scsi_xferred;
2029             /* 33C93 gives next interrupt indicating bus phase */
2030             asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
2031             if (!(asr & ASR_INT))
2032                 break;
2033             ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
2034             ADD_STATUS(8, ssr, host->scsi.phase, 1);
2035             ADD_STATUS(host->SCpnt->device->id, ssr, host->scsi.phase, 1);
2036             goto connected;
2037
2038         case 0x42:                      /* select timed out                             */
2039                                         /* -> PHASE_IDLE                                */
2040             acornscsi_done(host, &host->SCpnt, DID_NO_CONNECT);
2041             return INTR_NEXT_COMMAND;
2042
2043         case 0x81:                      /* -> PHASE_RECONNECTED or PHASE_ABORTED        */
2044             /* BUS FREE -> RESELECTION */
2045             host->origSCpnt = host->SCpnt;
2046             host->SCpnt = NULL;
2047             msgqueue_flush(&host->scsi.msgs);
2048             acornscsi_reconnect(host);
2049             break;
2050
2051         default:
2052             printk(KERN_ERR "scsi%d.%c: PHASE_CONNECTING, SSR %02X?\n",
2053                     host->host->host_no, acornscsi_target(host), ssr);
2054             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2055             acornscsi_abortcmd(host, host->SCpnt->tag);
2056         }
2057         return INTR_PROCESSING;
2058
2059     connected:
2060     case PHASE_CONNECTED:               /* STATE: device selected ok                    */
2061         switch (ssr) {
2062 #ifdef NONSTANDARD
2063         case 0x8a:                      /* -> PHASE_COMMAND, PHASE_COMMANDPAUSED        */
2064             /* SELECTION -> COMMAND */
2065             acornscsi_sendcommand(host);
2066             break;
2067
2068         case 0x8b:                      /* -> PHASE_STATUS                              */
2069             /* SELECTION -> STATUS */
2070             acornscsi_readstatusbyte(host);
2071             host->scsi.phase = PHASE_STATUSIN;
2072             break;
2073 #endif
2074
2075         case 0x8e:                      /* -> PHASE_MSGOUT                              */
2076             /* SELECTION ->MESSAGE OUT */
2077             host->scsi.phase = PHASE_MSGOUT;
2078             acornscsi_buildmessages(host);
2079             acornscsi_sendmessage(host);
2080             break;
2081
2082         /* these should not happen */
2083         case 0x85:                      /* target disconnected                          */
2084             acornscsi_done(host, &host->SCpnt, DID_ERROR);
2085             break;
2086
2087         default:
2088             printk(KERN_ERR "scsi%d.%c: PHASE_CONNECTED, SSR %02X?\n",
2089                     host->host->host_no, acornscsi_target(host), ssr);
2090             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2091             acornscsi_abortcmd(host, host->SCpnt->tag);
2092         }
2093         return INTR_PROCESSING;
2094
2095     case PHASE_MSGOUT:                  /* STATE: connected & sent IDENTIFY message     */
2096         /*
2097          * SCSI standard says that MESSAGE OUT phases can be followed by a
2098          * DATA phase, STATUS phase, MESSAGE IN phase or COMMAND phase
2099          */
2100         switch (ssr) {
2101         case 0x8a:                      /* -> PHASE_COMMAND, PHASE_COMMANDPAUSED        */
2102         case 0x1a:                      /* -> PHASE_COMMAND, PHASE_COMMANDPAUSED        */
2103             /* MESSAGE OUT -> COMMAND */
2104             acornscsi_sendcommand(host);
2105             break;
2106
2107         case 0x8b:                      /* -> PHASE_STATUS                              */
2108         case 0x1b:                      /* -> PHASE_STATUS                              */
2109             /* MESSAGE OUT -> STATUS */
2110             acornscsi_readstatusbyte(host);
2111             host->scsi.phase = PHASE_STATUSIN;
2112             break;
2113
2114         case 0x8e:                      /* -> PHASE_MSGOUT                              */
2115             /* MESSAGE_OUT(MESSAGE_IN) ->MESSAGE OUT */
2116             acornscsi_sendmessage(host);
2117             break;
2118
2119         case 0x4f:                      /* -> PHASE_MSGIN, PHASE_DISCONNECT             */
2120         case 0x1f:                      /* -> PHASE_MSGIN, PHASE_DISCONNECT             */
2121             /* MESSAGE OUT -> MESSAGE IN */
2122             acornscsi_message(host);
2123             break;
2124
2125         default:
2126             printk(KERN_ERR "scsi%d.%c: PHASE_MSGOUT, SSR %02X?\n",
2127                     host->host->host_no, acornscsi_target(host), ssr);
2128             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2129         }
2130         return INTR_PROCESSING;
2131
2132     case PHASE_COMMAND:                 /* STATE: connected & command sent              */
2133         switch (ssr) {
2134         case 0x18:                      /* -> PHASE_DATAOUT                             */
2135             /* COMMAND -> DATA OUT */
2136             if (host->scsi.SCp.sent_command != host->SCpnt->cmd_len)
2137                 acornscsi_abortcmd(host, host->SCpnt->tag);
2138             acornscsi_dma_setup(host, DMA_OUT);
2139             if (!acornscsi_starttransfer(host))
2140                 acornscsi_abortcmd(host, host->SCpnt->tag);
2141             host->scsi.phase = PHASE_DATAOUT;
2142             return INTR_IDLE;
2143
2144         case 0x19:                      /* -> PHASE_DATAIN                              */
2145             /* COMMAND -> DATA IN */
2146             if (host->scsi.SCp.sent_command != host->SCpnt->cmd_len)
2147                 acornscsi_abortcmd(host, host->SCpnt->tag);
2148             acornscsi_dma_setup(host, DMA_IN);
2149             if (!acornscsi_starttransfer(host))
2150                 acornscsi_abortcmd(host, host->SCpnt->tag);
2151             host->scsi.phase = PHASE_DATAIN;
2152             return INTR_IDLE;
2153
2154         case 0x1b:                      /* -> PHASE_STATUS                              */
2155             /* COMMAND -> STATUS */
2156             acornscsi_readstatusbyte(host);
2157             host->scsi.phase = PHASE_STATUSIN;
2158             break;
2159
2160         case 0x1e:                      /* -> PHASE_MSGOUT                              */
2161             /* COMMAND -> MESSAGE OUT */
2162             acornscsi_sendmessage(host);
2163             break;
2164
2165         case 0x1f:                      /* -> PHASE_MSGIN, PHASE_DISCONNECT             */
2166             /* COMMAND -> MESSAGE IN */
2167             acornscsi_message(host);
2168             break;
2169
2170         default:
2171             printk(KERN_ERR "scsi%d.%c: PHASE_COMMAND, SSR %02X?\n",
2172                     host->host->host_no, acornscsi_target(host), ssr);
2173             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2174         }
2175         return INTR_PROCESSING;
2176
2177     case PHASE_DISCONNECT:              /* STATE: connected, received DISCONNECT msg    */
2178         if (ssr == 0x85) {              /* -> PHASE_IDLE                                */
2179             host->scsi.disconnectable = 1;
2180             host->scsi.reconnected.tag = 0;
2181             host->scsi.phase = PHASE_IDLE;
2182             host->stats.disconnects += 1;
2183         } else {
2184             printk(KERN_ERR "scsi%d.%c: PHASE_DISCONNECT, SSR %02X instead of disconnect?\n",
2185                     host->host->host_no, acornscsi_target(host), ssr);
2186             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2187         }
2188         return INTR_NEXT_COMMAND;
2189
2190     case PHASE_IDLE:                    /* STATE: disconnected                          */
2191         if (ssr == 0x81)                /* -> PHASE_RECONNECTED or PHASE_ABORTED        */
2192             acornscsi_reconnect(host);
2193         else {
2194             printk(KERN_ERR "scsi%d.%c: PHASE_IDLE, SSR %02X while idle?\n",
2195                     host->host->host_no, acornscsi_target(host), ssr);
2196             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2197         }
2198         return INTR_PROCESSING;
2199
2200     case PHASE_RECONNECTED:             /* STATE: device reconnected to initiator       */
2201         /*
2202          * Command reconnected - if MESGIN, get message - it may be
2203          * the tag.  If not, get command out of disconnected queue
2204          */
2205         /*
2206          * If we reconnected and we're not in MESSAGE IN phase after IDENTIFY,
2207          * reconnect I_T_L command
2208          */
2209         if (ssr != 0x8f && !acornscsi_reconnect_finish(host))
2210             return INTR_IDLE;
2211         ADD_STATUS(host->SCpnt->device->id, ssr, host->scsi.phase, in_irq);
2212         switch (ssr) {
2213         case 0x88:                      /* data out phase                               */
2214                                         /* -> PHASE_DATAOUT                             */
2215             /* MESSAGE IN -> DATA OUT */
2216             acornscsi_dma_setup(host, DMA_OUT);
2217             if (!acornscsi_starttransfer(host))
2218                 acornscsi_abortcmd(host, host->SCpnt->tag);
2219             host->scsi.phase = PHASE_DATAOUT;
2220             return INTR_IDLE;
2221
2222         case 0x89:                      /* data in phase                                */
2223                                         /* -> PHASE_DATAIN                              */
2224             /* MESSAGE IN -> DATA IN */
2225             acornscsi_dma_setup(host, DMA_IN);
2226             if (!acornscsi_starttransfer(host))
2227                 acornscsi_abortcmd(host, host->SCpnt->tag);
2228             host->scsi.phase = PHASE_DATAIN;
2229             return INTR_IDLE;
2230
2231         case 0x8a:                      /* command out                                  */
2232             /* MESSAGE IN -> COMMAND */
2233             acornscsi_sendcommand(host);/* -> PHASE_COMMAND, PHASE_COMMANDPAUSED        */
2234             break;
2235
2236         case 0x8b:                      /* status in                                    */
2237                                         /* -> PHASE_STATUSIN                            */
2238             /* MESSAGE IN -> STATUS */
2239             acornscsi_readstatusbyte(host);
2240             host->scsi.phase = PHASE_STATUSIN;
2241             break;
2242
2243         case 0x8e:                      /* message out                                  */
2244                                         /* -> PHASE_MSGOUT                              */
2245             /* MESSAGE IN -> MESSAGE OUT */
2246             acornscsi_sendmessage(host);
2247             break;
2248
2249         case 0x8f:                      /* message in                                   */
2250             acornscsi_message(host);    /* -> PHASE_MSGIN, PHASE_DISCONNECT             */
2251             break;
2252
2253         default:
2254             printk(KERN_ERR "scsi%d.%c: PHASE_RECONNECTED, SSR %02X after reconnect?\n",
2255                     host->host->host_no, acornscsi_target(host), ssr);
2256             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2257         }
2258         return INTR_PROCESSING;
2259
2260     case PHASE_DATAIN:                  /* STATE: transferred data in                   */
2261         /*
2262          * This is simple - if we disconnect then the DMA address & count is
2263          * correct.
2264          */
2265         switch (ssr) {
2266         case 0x19:                      /* -> PHASE_DATAIN                              */
2267         case 0x89:                      /* -> PHASE_DATAIN                              */
2268             acornscsi_abortcmd(host, host->SCpnt->tag);
2269             return INTR_IDLE;
2270
2271         case 0x1b:                      /* -> PHASE_STATUSIN                            */
2272         case 0x4b:                      /* -> PHASE_STATUSIN                            */
2273         case 0x8b:                      /* -> PHASE_STATUSIN                            */
2274             /* DATA IN -> STATUS */
2275             host->scsi.SCp.scsi_xferred = host->SCpnt->request_bufflen -
2276                                           acornscsi_sbic_xfcount(host);
2277             acornscsi_dma_stop(host);
2278             acornscsi_readstatusbyte(host);
2279             host->scsi.phase = PHASE_STATUSIN;
2280             break;
2281
2282         case 0x1e:                      /* -> PHASE_MSGOUT                              */
2283         case 0x4e:                      /* -> PHASE_MSGOUT                              */
2284         case 0x8e:                      /* -> PHASE_MSGOUT                              */
2285             /* DATA IN -> MESSAGE OUT */
2286             host->scsi.SCp.scsi_xferred = host->SCpnt->request_bufflen -
2287                                           acornscsi_sbic_xfcount(host);
2288             acornscsi_dma_stop(host);
2289             acornscsi_sendmessage(host);
2290             break;
2291
2292         case 0x1f:                      /* message in                                   */
2293         case 0x4f:                      /* message in                                   */
2294         case 0x8f:                      /* message in                                   */
2295             /* DATA IN -> MESSAGE IN */
2296             host->scsi.SCp.scsi_xferred = host->SCpnt->request_bufflen -
2297                                           acornscsi_sbic_xfcount(host);
2298             acornscsi_dma_stop(host);
2299             acornscsi_message(host);    /* -> PHASE_MSGIN, PHASE_DISCONNECT             */
2300             break;
2301
2302         default:
2303             printk(KERN_ERR "scsi%d.%c: PHASE_DATAIN, SSR %02X?\n",
2304                     host->host->host_no, acornscsi_target(host), ssr);
2305             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2306         }
2307         return INTR_PROCESSING;
2308
2309     case PHASE_DATAOUT:                 /* STATE: transferred data out                  */
2310         /*
2311          * This is more complicated - if we disconnect, the DMA could be 12
2312          * bytes ahead of us.  We need to correct this.
2313          */
2314         switch (ssr) {
2315         case 0x18:                      /* -> PHASE_DATAOUT                             */
2316         case 0x88:                      /* -> PHASE_DATAOUT                             */
2317             acornscsi_abortcmd(host, host->SCpnt->tag);
2318             return INTR_IDLE;
2319
2320         case 0x1b:                      /* -> PHASE_STATUSIN                            */
2321         case 0x4b:                      /* -> PHASE_STATUSIN                            */
2322         case 0x8b:                      /* -> PHASE_STATUSIN                            */
2323             /* DATA OUT -> STATUS */
2324             host->scsi.SCp.scsi_xferred = host->SCpnt->request_bufflen -
2325                                           acornscsi_sbic_xfcount(host);
2326             acornscsi_dma_stop(host);
2327             acornscsi_dma_adjust(host);
2328             acornscsi_readstatusbyte(host);
2329             host->scsi.phase = PHASE_STATUSIN;
2330             break;
2331
2332         case 0x1e:                      /* -> PHASE_MSGOUT                              */
2333         case 0x4e:                      /* -> PHASE_MSGOUT                              */
2334         case 0x8e:                      /* -> PHASE_MSGOUT                              */
2335             /* DATA OUT -> MESSAGE OUT */
2336             host->scsi.SCp.scsi_xferred = host->SCpnt->request_bufflen -
2337                                           acornscsi_sbic_xfcount(host);
2338             acornscsi_dma_stop(host);
2339             acornscsi_dma_adjust(host);
2340             acornscsi_sendmessage(host);
2341             break;
2342
2343         case 0x1f:                      /* message in                                   */
2344         case 0x4f:                      /* message in                                   */
2345         case 0x8f:                      /* message in                                   */
2346             /* DATA OUT -> MESSAGE IN */
2347             host->scsi.SCp.scsi_xferred = host->SCpnt->request_bufflen -
2348                                           acornscsi_sbic_xfcount(host);
2349             acornscsi_dma_stop(host);
2350             acornscsi_dma_adjust(host);
2351             acornscsi_message(host);    /* -> PHASE_MSGIN, PHASE_DISCONNECT             */
2352             break;
2353
2354         default:
2355             printk(KERN_ERR "scsi%d.%c: PHASE_DATAOUT, SSR %02X?\n",
2356                     host->host->host_no, acornscsi_target(host), ssr);
2357             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2358         }
2359         return INTR_PROCESSING;
2360
2361     case PHASE_STATUSIN:                /* STATE: status in complete                    */
2362         switch (ssr) {
2363         case 0x1f:                      /* -> PHASE_MSGIN, PHASE_DONE, PHASE_DISCONNECT */
2364         case 0x8f:                      /* -> PHASE_MSGIN, PHASE_DONE, PHASE_DISCONNECT */
2365             /* STATUS -> MESSAGE IN */
2366             acornscsi_message(host);
2367             break;
2368
2369         case 0x1e:                      /* -> PHASE_MSGOUT                              */
2370         case 0x8e:                      /* -> PHASE_MSGOUT                              */
2371             /* STATUS -> MESSAGE OUT */
2372             acornscsi_sendmessage(host);
2373             break;
2374
2375         default:
2376             printk(KERN_ERR "scsi%d.%c: PHASE_STATUSIN, SSR %02X instead of MESSAGE_IN?\n",
2377                     host->host->host_no, acornscsi_target(host), ssr);
2378             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2379         }
2380         return INTR_PROCESSING;
2381
2382     case PHASE_MSGIN:                   /* STATE: message in                            */
2383         switch (ssr) {
2384         case 0x1e:                      /* -> PHASE_MSGOUT                              */
2385         case 0x4e:                      /* -> PHASE_MSGOUT                              */
2386         case 0x8e:                      /* -> PHASE_MSGOUT                              */
2387             /* MESSAGE IN -> MESSAGE OUT */
2388             acornscsi_sendmessage(host);
2389             break;
2390
2391         case 0x1f:                      /* -> PHASE_MSGIN, PHASE_DONE, PHASE_DISCONNECT */
2392         case 0x2f:
2393         case 0x4f:
2394         case 0x8f:
2395             acornscsi_message(host);
2396             break;
2397
2398         case 0x85:
2399             printk("scsi%d.%c: strange message in disconnection\n",
2400                 host->host->host_no, acornscsi_target(host));
2401             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2402             acornscsi_done(host, &host->SCpnt, DID_ERROR);
2403             break;
2404
2405         default:
2406             printk(KERN_ERR "scsi%d.%c: PHASE_MSGIN, SSR %02X after message in?\n",
2407                     host->host->host_no, acornscsi_target(host), ssr);
2408             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2409         }
2410         return INTR_PROCESSING;
2411
2412     case PHASE_DONE:                    /* STATE: received status & message             */
2413         switch (ssr) {
2414         case 0x85:                      /* -> PHASE_IDLE                                */
2415             acornscsi_done(host, &host->SCpnt, DID_OK);
2416             return INTR_NEXT_COMMAND;
2417
2418         case 0x1e:
2419         case 0x8e:
2420             acornscsi_sendmessage(host);
2421             break;
2422
2423         default:
2424             printk(KERN_ERR "scsi%d.%c: PHASE_DONE, SSR %02X instead of disconnect?\n",
2425                     host->host->host_no, acornscsi_target(host), ssr);
2426             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2427         }
2428         return INTR_PROCESSING;
2429
2430     case PHASE_ABORTED:
2431         switch (ssr) {
2432         case 0x85:
2433             if (host->SCpnt)
2434                 acornscsi_done(host, &host->SCpnt, DID_ABORT);
2435             else {
2436                 clear_bit(host->scsi.reconnected.target * 8 + host->scsi.reconnected.lun,
2437                           host->busyluns);
2438                 host->scsi.phase = PHASE_IDLE;
2439             }
2440             return INTR_NEXT_COMMAND;
2441
2442         case 0x1e:
2443         case 0x2e:
2444         case 0x4e:
2445         case 0x8e:
2446             acornscsi_sendmessage(host);
2447             break;
2448
2449         default:
2450             printk(KERN_ERR "scsi%d.%c: PHASE_ABORTED, SSR %02X?\n",
2451                     host->host->host_no, acornscsi_target(host), ssr);
2452             acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2453         }
2454         return INTR_PROCESSING;
2455
2456     default:
2457         printk(KERN_ERR "scsi%d.%c: unknown driver phase %d\n",
2458                 host->host->host_no, acornscsi_target(host), ssr);
2459         acornscsi_dumplog(host, host->SCpnt ? host->SCpnt->device->id : 8);
2460     }
2461     return INTR_PROCESSING;
2462 }
2463
2464 /*
2465  * Prototype: void acornscsi_intr(int irq, void *dev_id, struct pt_regs *regs)
2466  * Purpose  : handle interrupts from Acorn SCSI card
2467  * Params   : irq    - interrupt number
2468  *            dev_id - device specific data (AS_Host structure)
2469  *            regs   - processor registers when interrupt occurred
2470  */
2471 static irqreturn_t
2472 acornscsi_intr(int irq, void *dev_id, struct pt_regs *regs)
2473 {
2474     AS_Host *host = (AS_Host *)dev_id;
2475     intr_ret_t ret;
2476     int iostatus;
2477     int in_irq = 0;
2478
2479     do {
2480         ret = INTR_IDLE;
2481
2482         iostatus = inb(host->card.io_intr);
2483
2484         if (iostatus & 2) {
2485             acornscsi_dma_intr(host);
2486             iostatus = inb(host->card.io_intr);
2487         }
2488
2489         if (iostatus & 8)
2490             ret = acornscsi_sbicintr(host, in_irq);
2491
2492         /*
2493          * If we have a transfer pending, start it.
2494          * Only start it if the interface has already started transferring
2495          * it's data
2496          */
2497         if (host->dma.xfer_required)
2498             acornscsi_dma_xfer(host);
2499
2500         if (ret == INTR_NEXT_COMMAND)
2501             ret = acornscsi_kick(host);
2502
2503         in_irq = 1;
2504     } while (ret != INTR_IDLE);
2505
2506     return IRQ_HANDLED;
2507 }
2508
2509 /*=============================================================================================
2510  * Interfaces between interrupt handler and rest of scsi code
2511  */
2512
2513 /*
2514  * Function : acornscsi_queuecmd(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
2515  * Purpose  : queues a SCSI command
2516  * Params   : cmd  - SCSI command
2517  *            done - function called on completion, with pointer to command descriptor
2518  * Returns  : 0, or < 0 on error.
2519  */
2520 int acornscsi_queuecmd(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
2521 {
2522     AS_Host *host = (AS_Host *)SCpnt->device->host->hostdata;
2523
2524     if (!done) {
2525         /* there should be some way of rejecting errors like this without panicing... */
2526         panic("scsi%d: queuecommand called with NULL done function [cmd=%p]",
2527                 host->host->host_no, SCpnt);
2528         return -EINVAL;
2529     }
2530
2531 #if (DEBUG & DEBUG_NO_WRITE)
2532     if (acornscsi_cmdtype(SCpnt->cmnd[0]) == CMD_WRITE && (NO_WRITE & (1 << SCpnt->device->id))) {
2533         printk(KERN_CRIT "scsi%d.%c: WRITE attempted with NO_WRITE flag set\n",
2534             host->host->host_no, '0' + SCpnt->device->id);
2535         SCpnt->result = DID_NO_CONNECT << 16;
2536         done(SCpnt);
2537         return 0;
2538     }
2539 #endif
2540
2541     SCpnt->scsi_done = done;
2542     SCpnt->host_scribble = NULL;
2543     SCpnt->result = 0;
2544     SCpnt->tag = 0;
2545     SCpnt->SCp.phase = (int)acornscsi_datadirection(SCpnt->cmnd[0]);
2546     SCpnt->SCp.sent_command = 0;
2547     SCpnt->SCp.scsi_xferred = 0;
2548
2549     init_SCp(SCpnt);
2550
2551     host->stats.queues += 1;
2552
2553     {
2554         unsigned long flags;
2555
2556         if (!queue_add_cmd_ordered(&host->queues.issue, SCpnt)) {
2557             SCpnt->result = DID_ERROR << 16;
2558             done(SCpnt);
2559             return 0;
2560         }
2561         local_irq_save(flags);
2562         if (host->scsi.phase == PHASE_IDLE)
2563             acornscsi_kick(host);
2564         local_irq_restore(flags);
2565     }
2566     return 0;
2567 }
2568
2569 /*
2570  * Prototype: void acornscsi_reportstatus(Scsi_Cmnd **SCpntp1, Scsi_Cmnd **SCpntp2, int result)
2571  * Purpose  : pass a result to *SCpntp1, and check if *SCpntp1 = *SCpntp2
2572  * Params   : SCpntp1 - pointer to command to return
2573  *            SCpntp2 - pointer to command to check
2574  *            result  - result to pass back to mid-level done function
2575  * Returns  : *SCpntp2 = NULL if *SCpntp1 is the same command structure as *SCpntp2.
2576  */
2577 static inline
2578 void acornscsi_reportstatus(Scsi_Cmnd **SCpntp1, Scsi_Cmnd **SCpntp2, int result)
2579 {
2580     Scsi_Cmnd *SCpnt = *SCpntp1;
2581
2582     if (SCpnt) {
2583         *SCpntp1 = NULL;
2584
2585         SCpnt->result = result;
2586         SCpnt->scsi_done(SCpnt);
2587     }
2588
2589     if (SCpnt == *SCpntp2)
2590         *SCpntp2 = NULL;
2591 }
2592
2593 enum res_abort { res_not_running, res_success, res_success_clear, res_snooze };
2594
2595 /*
2596  * Prototype: enum res acornscsi_do_abort(Scsi_Cmnd *SCpnt)
2597  * Purpose  : abort a command on this host
2598  * Params   : SCpnt - command to abort
2599  * Returns  : our abort status
2600  */
2601 static enum res_abort
2602 acornscsi_do_abort(AS_Host *host, Scsi_Cmnd *SCpnt)
2603 {
2604         enum res_abort res = res_not_running;
2605
2606         if (queue_remove_cmd(&host->queues.issue, SCpnt)) {
2607                 /*
2608                  * The command was on the issue queue, and has not been
2609                  * issued yet.  We can remove the command from the queue,
2610                  * and acknowledge the abort.  Neither the devices nor the
2611                  * interface know about the command.
2612                  */
2613 //#if (DEBUG & DEBUG_ABORT)
2614                 printk("on issue queue ");
2615 //#endif
2616                 res = res_success;
2617         } else if (queue_remove_cmd(&host->queues.disconnected, SCpnt)) {
2618                 /*
2619                  * The command was on the disconnected queue.  Simply
2620                  * acknowledge the abort condition, and when the target
2621                  * reconnects, we will give it an ABORT message.  The
2622                  * target should then disconnect, and we will clear
2623                  * the busylun bit.
2624                  */
2625 //#if (DEBUG & DEBUG_ABORT)
2626                 printk("on disconnected queue ");
2627 //#endif
2628                 res = res_success;
2629         } else if (host->SCpnt == SCpnt) {
2630                 unsigned long flags;
2631
2632 //#if (DEBUG & DEBUG_ABORT)
2633                 printk("executing ");
2634 //#endif
2635
2636                 local_irq_save(flags);
2637                 switch (host->scsi.phase) {
2638                 /*
2639                  * If the interface is idle, and the command is 'disconnectable',
2640                  * then it is the same as on the disconnected queue.  We simply
2641                  * remove all traces of the command.  When the target reconnects,
2642                  * we will give it an ABORT message since the command could not
2643                  * be found.  When the target finally disconnects, we will clear
2644                  * the busylun bit.
2645                  */
2646                 case PHASE_IDLE:
2647                         if (host->scsi.disconnectable) {
2648                                 host->scsi.disconnectable = 0;
2649                                 host->SCpnt = NULL;
2650                                 res = res_success;
2651                         }
2652                         break;
2653
2654                 /*
2655                  * If the command has connected and done nothing further,
2656                  * simply force a disconnect.  We also need to clear the
2657                  * busylun bit.
2658                  */
2659                 case PHASE_CONNECTED:
2660                         sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_DISCONNECT);
2661                         host->SCpnt = NULL;
2662                         res = res_success_clear;
2663                         break;
2664
2665                 default:
2666                         acornscsi_abortcmd(host, host->SCpnt->tag);
2667                         res = res_snooze;
2668                 }
2669                 local_irq_restore(flags);
2670         } else if (host->origSCpnt == SCpnt) {
2671                 /*
2672                  * The command will be executed next, but a command
2673                  * is currently using the interface.  This is similar to
2674                  * being on the issue queue, except the busylun bit has
2675                  * been set.
2676                  */
2677                 host->origSCpnt = NULL;
2678 //#if (DEBUG & DEBUG_ABORT)
2679                 printk("waiting for execution ");
2680 //#endif
2681                 res = res_success_clear;
2682         } else
2683                 printk("unknown ");
2684
2685         return res;
2686 }
2687
2688 /*
2689  * Prototype: int acornscsi_abort(Scsi_Cmnd *SCpnt)
2690  * Purpose  : abort a command on this host
2691  * Params   : SCpnt - command to abort
2692  * Returns  : one of SCSI_ABORT_ macros
2693  */
2694 int acornscsi_abort(Scsi_Cmnd *SCpnt)
2695 {
2696         AS_Host *host = (AS_Host *) SCpnt->device->host->hostdata;
2697         int result;
2698
2699         host->stats.aborts += 1;
2700
2701 #if (DEBUG & DEBUG_ABORT)
2702         {
2703                 int asr, ssr;
2704                 asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
2705                 ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
2706
2707                 printk(KERN_WARNING "acornscsi_abort: ");
2708                 print_sbic_status(asr, ssr, host->scsi.phase);
2709                 acornscsi_dumplog(host, SCpnt->device->id);
2710         }
2711 #endif
2712
2713         printk("scsi%d: ", host->host->host_no);
2714
2715         switch (acornscsi_do_abort(host, SCpnt)) {
2716         /*
2717          * We managed to find the command and cleared it out.
2718          * We do not expect the command to be executing on the
2719          * target, but we have set the busylun bit.
2720          */
2721         case res_success_clear:
2722 //#if (DEBUG & DEBUG_ABORT)
2723                 printk("clear ");
2724 //#endif
2725                 clear_bit(SCpnt->device->id * 8 + SCpnt->device->lun, host->busyluns);
2726
2727         /*
2728          * We found the command, and cleared it out.  Either
2729          * the command is still known to be executing on the
2730          * target, or the busylun bit is not set.
2731          */
2732         case res_success:
2733 //#if (DEBUG & DEBUG_ABORT)
2734                 printk("success\n");
2735 //#endif
2736                 SCpnt->result = DID_ABORT << 16;
2737                 SCpnt->scsi_done(SCpnt);
2738                 result = SCSI_ABORT_SUCCESS;
2739                 break;
2740
2741         /*
2742          * We did find the command, but unfortunately we couldn't
2743          * unhook it from ourselves.  Wait some more, and if it
2744          * still doesn't complete, reset the interface.
2745          */
2746         case res_snooze:
2747 //#if (DEBUG & DEBUG_ABORT)
2748                 printk("snooze\n");
2749 //#endif
2750                 result = SCSI_ABORT_SNOOZE;
2751                 break;
2752
2753         /*
2754          * The command could not be found (either because it completed,
2755          * or it got dropped.
2756          */
2757         default:
2758         case res_not_running:
2759                 acornscsi_dumplog(host, SCpnt->device->id);
2760 #if (DEBUG & DEBUG_ABORT)
2761                 result = SCSI_ABORT_SNOOZE;
2762 #else
2763                 result = SCSI_ABORT_NOT_RUNNING;
2764 #endif
2765 //#if (DEBUG & DEBUG_ABORT)
2766                 printk("not running\n");
2767 //#endif
2768                 break;
2769         }
2770
2771         return result;
2772 }
2773
2774 /*
2775  * Prototype: int acornscsi_reset(Scsi_Cmnd *SCpnt, unsigned int reset_flags)
2776  * Purpose  : reset a command on this host/reset this host
2777  * Params   : SCpnt  - command causing reset
2778  *            result - what type of reset to perform
2779  * Returns  : one of SCSI_RESET_ macros
2780  */
2781 int acornscsi_reset(Scsi_Cmnd *SCpnt, unsigned int reset_flags)
2782 {
2783     AS_Host *host = (AS_Host *)SCpnt->device->host->hostdata;
2784     Scsi_Cmnd *SCptr;
2785
2786     host->stats.resets += 1;
2787
2788 #if (DEBUG & DEBUG_RESET)
2789     {
2790         int asr, ssr;
2791
2792         asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
2793         ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
2794
2795         printk(KERN_WARNING "acornscsi_reset: ");
2796         print_sbic_status(asr, ssr, host->scsi.phase);
2797         acornscsi_dumplog(host, SCpnt->device->id);
2798     }
2799 #endif
2800
2801     acornscsi_dma_stop(host);
2802
2803     SCptr = host->SCpnt;
2804
2805     /*
2806      * do hard reset.  This resets all devices on this host, and so we
2807      * must set the reset status on all commands.
2808      */
2809     acornscsi_resetcard(host);
2810
2811     /*
2812      * report reset on commands current connected/disconnected
2813      */
2814     acornscsi_reportstatus(&host->SCpnt, &SCptr, DID_RESET);
2815
2816     while ((SCptr = queue_remove(&host->queues.disconnected)) != NULL)
2817         acornscsi_reportstatus(&SCptr, &SCpnt, DID_RESET);
2818
2819     if (SCpnt) {
2820         SCpnt->result = DID_RESET << 16;
2821         SCpnt->scsi_done(SCpnt);
2822     }
2823
2824     return SCSI_RESET_BUS_RESET | SCSI_RESET_HOST_RESET | SCSI_RESET_SUCCESS;
2825 }
2826
2827 /*==============================================================================================
2828  * initialisation & miscellaneous support
2829  */
2830
2831 /*
2832  * Function: char *acornscsi_info(struct Scsi_Host *host)
2833  * Purpose : return a string describing this interface
2834  * Params  : host - host to give information on
2835  * Returns : a constant string
2836  */
2837 const
2838 char *acornscsi_info(struct Scsi_Host *host)
2839 {
2840     static char string[100], *p;
2841
2842     p = string;
2843
2844     p += sprintf(string, "%s at port %08lX irq %d v%d.%d.%d"
2845 #ifdef CONFIG_SCSI_ACORNSCSI_SYNC
2846     " SYNC"
2847 #endif
2848 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
2849     " TAG"
2850 #endif
2851 #ifdef CONFIG_SCSI_ACORNSCSI_LINK
2852     " LINK"
2853 #endif
2854 #if (DEBUG & DEBUG_NO_WRITE)
2855     " NOWRITE ("NO_WRITE_STR")"
2856 #endif
2857                 , host->hostt->name, host->io_port, host->irq,
2858                 VER_MAJOR, VER_MINOR, VER_PATCH);
2859     return string;
2860 }
2861
2862 int acornscsi_proc_info(struct Scsi_Host *instance, char *buffer, char **start, off_t offset,
2863                         int length, int inout)
2864 {
2865     int pos, begin = 0, devidx;
2866     struct scsi_device *scd;
2867     AS_Host *host;
2868     char *p = buffer;
2869
2870     if (inout == 1)
2871         return -EINVAL;
2872
2873     host  = (AS_Host *)instance->hostdata;
2874
2875     p += sprintf(p, "AcornSCSI driver v%d.%d.%d"
2876 #ifdef CONFIG_SCSI_ACORNSCSI_SYNC
2877     " SYNC"
2878 #endif
2879 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
2880     " TAG"
2881 #endif
2882 #ifdef CONFIG_SCSI_ACORNSCSI_LINK
2883     " LINK"
2884 #endif
2885 #if (DEBUG & DEBUG_NO_WRITE)
2886     " NOWRITE ("NO_WRITE_STR")"
2887 #endif
2888                 "\n\n", VER_MAJOR, VER_MINOR, VER_PATCH);
2889
2890     p += sprintf(p,     "SBIC: WD33C93A  Address: %08X  IRQ : %d\n",
2891                         host->scsi.io_port, host->scsi.irq);
2892 #ifdef USE_DMAC
2893     p += sprintf(p,     "DMAC: uPC71071  Address: %08X  IRQ : %d\n\n",
2894                         host->dma.io_port, host->scsi.irq);
2895 #endif
2896
2897     p += sprintf(p,     "Statistics:\n"
2898                         "Queued commands: %-10u    Issued commands: %-10u\n"
2899                         "Done commands  : %-10u    Reads          : %-10u\n"
2900                         "Writes         : %-10u    Others         : %-10u\n"
2901                         "Disconnects    : %-10u    Aborts         : %-10u\n"
2902                         "Resets         : %-10u\n\nLast phases:",
2903                         host->stats.queues,             host->stats.removes,
2904                         host->stats.fins,               host->stats.reads,
2905                         host->stats.writes,             host->stats.miscs,
2906                         host->stats.disconnects,        host->stats.aborts,
2907                         host->stats.resets);
2908
2909     for (devidx = 0; devidx < 9; devidx ++) {
2910         unsigned int statptr, prev;
2911
2912         p += sprintf(p, "\n%c:", devidx == 8 ? 'H' : ('0' + devidx));
2913         statptr = host->status_ptr[devidx] - 10;
2914
2915         if ((signed int)statptr < 0)
2916             statptr += STATUS_BUFFER_SIZE;
2917
2918         prev = host->status[devidx][statptr].when;
2919
2920         for (; statptr != host->status_ptr[devidx]; statptr = (statptr + 1) & (STATUS_BUFFER_SIZE - 1)) {
2921             if (host->status[devidx][statptr].when) {
2922                 p += sprintf(p, "%c%02X:%02X+%2ld",
2923                         host->status[devidx][statptr].irq ? '-' : ' ',
2924                         host->status[devidx][statptr].ph,
2925                         host->status[devidx][statptr].ssr,
2926                         (host->status[devidx][statptr].when - prev) < 100 ?
2927                                 (host->status[devidx][statptr].when - prev) : 99);
2928                 prev = host->status[devidx][statptr].when;
2929             }
2930         }
2931     }
2932
2933     p += sprintf(p, "\nAttached devices:\n");
2934
2935     shost_for_each_device(scd, instance) {
2936         p += sprintf(p, "Device/Lun TaggedQ      Sync\n");
2937         p += sprintf(p, "     %d/%d   ", scd->id, scd->lun);
2938         if (scd->tagged_supported)
2939                 p += sprintf(p, "%3sabled(%3d) ",
2940                              scd->simple_tags ? "en" : "dis",
2941                              scd->current_tag);
2942         else
2943                 p += sprintf(p, "unsupported  ");
2944
2945         if (host->device[scd->id].sync_xfer & 15)
2946                 p += sprintf(p, "offset %d, %d ns\n",
2947                              host->device[scd->id].sync_xfer & 15,
2948                              acornscsi_getperiod(host->device[scd->id].sync_xfer));
2949         else
2950                 p += sprintf(p, "async\n");
2951
2952         pos = p - buffer;
2953         if (pos + begin < offset) {
2954             begin += pos;
2955             p = buffer;
2956         }
2957         pos = p - buffer;
2958         if (pos + begin > offset + length) {
2959             scsi_device_put(scd);
2960             break;
2961         }
2962     }
2963
2964     pos = p - buffer;
2965
2966     *start = buffer + (offset - begin);
2967     pos -= offset - begin;
2968
2969     if (pos > length)
2970         pos = length;
2971
2972     return pos;
2973 }
2974
2975 static struct scsi_host_template acornscsi_template = {
2976         .module                 = THIS_MODULE,
2977         .proc_info              = acornscsi_proc_info,
2978         .name                   = "AcornSCSI",
2979         .info                   = acornscsi_info,
2980         .queuecommand           = acornscsi_queuecmd,
2981 #warning fixme
2982         .abort                  = acornscsi_abort,
2983         .reset                  = acornscsi_reset,
2984         .can_queue              = 16,
2985         .this_id                = 7,
2986         .sg_tablesize           = SG_ALL,
2987         .cmd_per_lun            = 2,
2988         .unchecked_isa_dma      = 0,
2989         .use_clustering         = DISABLE_CLUSTERING,
2990         .proc_name              = "acornscsi",
2991 };
2992
2993 static int __devinit
2994 acornscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
2995 {
2996         struct Scsi_Host *host;
2997         AS_Host *ashost;
2998         int ret = -ENOMEM;
2999
3000         host = scsi_host_alloc(&acornscsi_template, sizeof(AS_Host));
3001         if (!host)
3002                 goto out;
3003
3004         ashost = (AS_Host *)host->hostdata;
3005
3006         host->io_port = ecard_address(ec, ECARD_MEMC, 0);
3007         host->irq = ec->irq;
3008
3009         ashost->host            = host;
3010         ashost->scsi.io_port    = ioaddr(host->io_port + 0x800);
3011         ashost->scsi.irq        = host->irq;
3012         ashost->card.io_intr    = POD_SPACE(host->io_port) + 0x800;
3013         ashost->card.io_page    = POD_SPACE(host->io_port) + 0xc00;
3014         ashost->card.io_ram     = ioaddr(host->io_port);
3015         ashost->dma.io_port     = host->io_port + 0xc00;
3016         ashost->dma.io_intr_clear = POD_SPACE(host->io_port) + 0x800;
3017
3018         ec->irqaddr     = (char *)ioaddr(ashost->card.io_intr);
3019         ec->irqmask     = 0x0a;
3020
3021         ret = -EBUSY;
3022         if (!request_region(host->io_port + 0x800, 2, "acornscsi(sbic)"))
3023                 goto err_1;
3024         if (!request_region(ashost->card.io_intr, 1, "acornscsi(intr)"))
3025                 goto err_2;
3026         if (!request_region(ashost->card.io_page, 1, "acornscsi(page)"))
3027                 goto err_3;
3028 #ifdef USE_DMAC
3029         if (!request_region(ashost->dma.io_port, 256, "acornscsi(dmac)"))
3030                 goto err_4;
3031 #endif
3032         if (!request_region(host->io_port, 2048, "acornscsi(ram)"))
3033                 goto err_5;
3034
3035         ret = request_irq(host->irq, acornscsi_intr, SA_INTERRUPT, "acornscsi", ashost);
3036         if (ret) {
3037                 printk(KERN_CRIT "scsi%d: IRQ%d not free: %d\n",
3038                         host->host_no, ashost->scsi.irq, ret);
3039                 goto err_6;
3040         }
3041
3042         memset(&ashost->stats, 0, sizeof (ashost->stats));
3043         queue_initialise(&ashost->queues.issue);
3044         queue_initialise(&ashost->queues.disconnected);
3045         msgqueue_initialise(&ashost->scsi.msgs);
3046
3047         acornscsi_resetcard(ashost);
3048
3049         ret = scsi_add_host(host, &ec->dev);
3050         if (ret)
3051                 goto err_7;
3052
3053         scsi_scan_host(host);
3054         goto out;
3055
3056  err_7:
3057         free_irq(host->irq, ashost);
3058  err_6:
3059         release_region(host->io_port, 2048);
3060  err_5:
3061 #ifdef USE_DMAC
3062         release_region(ashost->dma.io_port, 256);
3063 #endif
3064  err_4:
3065         release_region(ashost->card.io_page, 1);
3066  err_3:
3067         release_region(ashost->card.io_intr, 1);
3068  err_2:
3069         release_region(host->io_port + 0x800, 2);
3070  err_1:
3071         scsi_host_put(host);
3072  out:
3073         return ret;
3074 }
3075
3076 static void __devexit acornscsi_remove(struct expansion_card *ec)
3077 {
3078         struct Scsi_Host *host = ecard_get_drvdata(ec);
3079         AS_Host *ashost = (AS_Host *)host->hostdata;
3080
3081         ecard_set_drvdata(ec, NULL);
3082         scsi_remove_host(host);
3083
3084         /*
3085          * Put card into RESET state
3086          */
3087         outb(0x80, ashost->card.io_page);
3088
3089         free_irq(host->irq, ashost);
3090
3091         release_region(host->io_port + 0x800, 2);
3092         release_region(ashost->card.io_intr, 1);
3093         release_region(ashost->card.io_page, 1);
3094         release_region(ashost->dma.io_port, 256);
3095         release_region(host->io_port, 2048);
3096
3097         msgqueue_free(&ashost->scsi.msgs);
3098         queue_free(&ashost->queues.disconnected);
3099         queue_free(&ashost->queues.issue);
3100         scsi_host_put(host);
3101 }
3102
3103 static const struct ecard_id acornscsi_cids[] = {
3104         { MANU_ACORN, PROD_ACORN_SCSI },
3105         { 0xffff, 0xffff },
3106 };
3107
3108 static struct ecard_driver acornscsi_driver = {
3109         .probe          = acornscsi_probe,
3110         .remove         = __devexit_p(acornscsi_remove),
3111         .id_table       = acornscsi_cids,
3112         .drv = {
3113                 .name           = "acornscsi",
3114         },
3115 };
3116
3117 static int __init acornscsi_init(void)
3118 {
3119         return ecard_register_driver(&acornscsi_driver);
3120 }
3121
3122 static void __exit acornscsi_exit(void)
3123 {
3124         ecard_remove_driver(&acornscsi_driver);
3125 }
3126
3127 module_init(acornscsi_init);
3128 module_exit(acornscsi_exit);
3129
3130 MODULE_AUTHOR("Russell King");
3131 MODULE_DESCRIPTION("AcornSCSI driver");
3132 MODULE_LICENSE("GPL");