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