// SPDX-License-Identifier: GPL-2.0-or-later
/******************************************************************************
**  Device driver for the PCI-SCSI NCR538XX controller family.
**
**  Copyright (C) 1994  Wolfgang Stanglmeier
**
**
**-----------------------------------------------------------------------------
**
**  This driver has been ported to Linux from the FreeBSD NCR53C8XX driver
**  and is currently maintained by
**
**          Gerard Roudier              <groudier@free.fr>
**
**  Being given that this driver originates from the FreeBSD version, and
**  in order to keep synergy on both, any suggested enhancements and corrections
**  received on Linux are automatically a potential candidate for the FreeBSD 
**  version.
**
**  The original driver has been written for 386bsd and FreeBSD by
**          Wolfgang Stanglmeier        <wolf@cologne.de>
**          Stefan Esser                <se@mi.Uni-Koeln.de>
**
**  And has been ported to NetBSD by
**          Charles M. Hannum           <mycroft@gnu.ai.mit.edu>
**
**-----------------------------------------------------------------------------
**
**                     Brief history
**
**  December 10 1995 by Gerard Roudier:
**     Initial port to Linux.
**
**  June 23 1996 by Gerard Roudier:
**     Support for 64 bits architectures (Alpha).
**
**  November 30 1996 by Gerard Roudier:
**     Support for Fast-20 scsi.
**     Support for large DMA fifo and 128 dwords bursting.
**
**  February 27 1997 by Gerard Roudier:
**     Support for Fast-40 scsi.
**     Support for on-Board RAM.
**
**  May 3 1997 by Gerard Roudier:
**     Full support for scsi scripts instructions pre-fetching.
**
**  May 19 1997 by Richard Waltham <dormouse@farsrobt.demon.co.uk>:
**     Support for NvRAM detection and reading.
**
**  August 18 1997 by Cort <cort@cs.nmt.edu>:
**     Support for Power/PC (Big Endian).
**
**  June 20 1998 by Gerard Roudier
**     Support for up to 64 tags per lun.
**     O(1) everywhere (C and SCRIPTS) for normal cases.
**     Low PCI traffic for command handling when on-chip RAM is present.
**     Aggressive SCSI SCRIPTS optimizations.
**
**  2005 by Matthew Wilcox and James Bottomley
**     PCI-ectomy.  This driver now supports only the 720 chip (see the
**     NCR_Q720 and zalon drivers for the bus probe logic).
**
*******************************************************************************
*/

/*
**      Supported SCSI-II features:
**          Synchronous negotiation
**          Wide negotiation        (depends on the NCR Chip)
**          Enable disconnection
**          Tagged command queuing
**          Parity checking
**          Etc...
**
**      Supported NCR/SYMBIOS chips:
**              53C720          (Wide,   Fast SCSI-2, intfly problems)
*/

/* Name and version of the driver */
#define SCSI_NCR_DRIVER_NAME    "ncr53c8xx-3.4.3g"

#define SCSI_NCR_DEBUG_FLAGS    (0)

#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/errno.h>
#include <linux/gfp.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/spinlock.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/time.h>
#include <linux/timer.h>
#include <linux/types.h>

#include <asm/dma.h>
#include <asm/io.h>

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_spi.h>

#include "ncr53c8xx.h"

#define NAME53C8XX              "ncr53c8xx"

/*==========================================================
**
**      Debugging tags
**
**==========================================================
*/

#define DEBUG_ALLOC    (0x0001)
#define DEBUG_PHASE    (0x0002)
#define DEBUG_QUEUE    (0x0008)
#define DEBUG_RESULT   (0x0010)
#define DEBUG_POINTER  (0x0020)
#define DEBUG_SCRIPT   (0x0040)
#define DEBUG_TINY     (0x0080)
#define DEBUG_TIMING   (0x0100)
#define DEBUG_NEGO     (0x0200)
#define DEBUG_TAGS     (0x0400)
#define DEBUG_SCATTER  (0x0800)
#define DEBUG_IC        (0x1000)

/*
**    Enable/Disable debug messages.
**    Can be changed at runtime too.
*/

#ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
static int ncr_debug = SCSI_NCR_DEBUG_FLAGS;
        #define DEBUG_FLAGS ncr_debug
#else
        #define DEBUG_FLAGS     SCSI_NCR_DEBUG_FLAGS
#endif

/*
 * Locally used status flag
 */
#define SAM_STAT_ILLEGAL        0xff

static inline struct list_head *ncr_list_pop(struct list_head *head)
{
        if (!list_empty(head)) {
                struct list_head *elem = head->next;

                list_del(elem);
                return elem;
        }

        return NULL;
}

/*==========================================================
**
**      Simple power of two buddy-like allocator.
**
**      This simple code is not intended to be fast, but to 
**      provide power of 2 aligned memory allocations.
**      Since the SCRIPTS processor only supplies 8 bit 
**      arithmetic, this allocator allows simple and fast 
**      address calculations  from the SCRIPTS code.
**      In addition, cache line alignment is guaranteed for 
**      power of 2 cache line size.
**      Enhanced in linux-2.3.44 to provide a memory pool 
**      per pcidev to support dynamic dma mapping. (I would 
**      have preferred a real bus abstraction, btw).
**
**==========================================================
*/

#define MEMO_SHIFT      4       /* 16 bytes minimum memory chunk */
#if PAGE_SIZE >= 8192
#define MEMO_PAGE_ORDER 0       /* 1 PAGE  maximum */
#else
#define MEMO_PAGE_ORDER 1       /* 2 PAGES maximum */
#endif
#define MEMO_FREE_UNUSED        /* Free unused pages immediately */
#define MEMO_WARN       1
#define MEMO_GFP_FLAGS  GFP_ATOMIC
#define MEMO_CLUSTER_SHIFT      (PAGE_SHIFT+MEMO_PAGE_ORDER)
#define MEMO_CLUSTER_SIZE       (1UL << MEMO_CLUSTER_SHIFT)
#define MEMO_CLUSTER_MASK       (MEMO_CLUSTER_SIZE-1)

typedef u_long m_addr_t;        /* Enough bits to bit-hack addresses */
typedef struct device *m_bush_t;        /* Something that addresses DMAable */

typedef struct m_link {         /* Link between free memory chunks */
        struct m_link *next;
} m_link_s;

typedef struct m_vtob {         /* Virtual to Bus address translation */
        struct m_vtob *next;
        m_addr_t vaddr;
        m_addr_t baddr;
} m_vtob_s;
#define VTOB_HASH_SHIFT         5
#define VTOB_HASH_SIZE          (1UL << VTOB_HASH_SHIFT)
#define VTOB_HASH_MASK          (VTOB_HASH_SIZE-1)
#define VTOB_HASH_CODE(m)       \
        ((((m_addr_t) (m)) >> MEMO_CLUSTER_SHIFT) & VTOB_HASH_MASK)

typedef struct m_pool {         /* Memory pool of a given kind */
        m_bush_t bush;
        m_addr_t (*getp)(struct m_pool *);
        void (*freep)(struct m_pool *, m_addr_t);
        int nump;
        m_vtob_s *(vtob[VTOB_HASH_SIZE]);
        struct m_pool *next;
        struct m_link h[PAGE_SHIFT-MEMO_SHIFT+MEMO_PAGE_ORDER+1];
} m_pool_s;

static void *___m_alloc(m_pool_s *mp, int size)
{
        int i = 0;
        int s = (1 << MEMO_SHIFT);
        int j;
        m_addr_t a;
        m_link_s *h = mp->h;

        if (size > (PAGE_SIZE << MEMO_PAGE_ORDER))
                return NULL;

        while (size > s) {
                s <<= 1;
                ++i;
        }

        j = i;
        while (!h[j].next) {
                if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) {
                        h[j].next = (m_link_s *)mp->getp(mp);
                        if (h[j].next)
                                h[j].next->next = NULL;
                        break;
                }
                ++j;
                s <<= 1;
        }
        a = (m_addr_t) h[j].next;
        if (a) {
                h[j].next = h[j].next->next;
                while (j > i) {
                        j -= 1;
                        s >>= 1;
                        h[j].next = (m_link_s *) (a+s);
                        h[j].next->next = NULL;
                }
        }
#ifdef DEBUG
        printk("___m_alloc(%d) = %p\n", size, (void *) a);
#endif
        return (void *) a;
}

static void ___m_free(m_pool_s *mp, void *ptr, int size)
{
        int i = 0;
        int s = (1 << MEMO_SHIFT);
        m_link_s *q;
        m_addr_t a, b;
        m_link_s *h = mp->h;

#ifdef DEBUG
        printk("___m_free(%p, %d)\n", ptr, size);
#endif

        if (size > (PAGE_SIZE << MEMO_PAGE_ORDER))
                return;

        while (size > s) {
                s <<= 1;
                ++i;
        }

        a = (m_addr_t) ptr;

        while (1) {
#ifdef MEMO_FREE_UNUSED
                if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) {
                        mp->freep(mp, a);
                        break;
                }
#endif
                b = a ^ s;
                q = &h[i];
                while (q->next && q->next != (m_link_s *) b) {
                        q = q->next;
                }
                if (!q->next) {
                        ((m_link_s *) a)->next = h[i].next;
                        h[i].next = (m_link_s *) a;
                        break;
                }
                q->next = q->next->next;
                a = a & b;
                s <<= 1;
                ++i;
        }
}

static DEFINE_SPINLOCK(ncr53c8xx_lock);

static void *__m_calloc2(m_pool_s *mp, int size, char *name, int uflags)
{
        void *p;

        p = ___m_alloc(mp, size);

        if (DEBUG_FLAGS & DEBUG_ALLOC)
                printk ("new %-10s[%4d] @%p.\n", name, size, p);

        if (p)
                memset(p, 0, size);
        else if (uflags & MEMO_WARN)
                printk (NAME53C8XX ": failed to allocate %s[%d]\n", name, size);

        return p;
}

#define __m_calloc(mp, s, n)    __m_calloc2(mp, s, n, MEMO_WARN)

static void __m_free(m_pool_s *mp, void *ptr, int size, char *name)
{
        if (DEBUG_FLAGS & DEBUG_ALLOC)
                printk ("freeing %-10s[%4d] @%p.\n", name, size, ptr);

        ___m_free(mp, ptr, size);

}

/*
 * With pci bus iommu support, we use a default pool of unmapped memory 
 * for memory we donnot need to DMA from/to and one pool per pcidev for 
 * memory accessed by the PCI chip. `mp0' is the default not DMAable pool.
 */

static m_addr_t ___mp0_getp(m_pool_s *mp)
{
        m_addr_t m = __get_free_pages(MEMO_GFP_FLAGS, MEMO_PAGE_ORDER);
        if (m)
                ++mp->nump;
        return m;
}

static void ___mp0_freep(m_pool_s *mp, m_addr_t m)
{
        free_pages(m, MEMO_PAGE_ORDER);
        --mp->nump;
}

static m_pool_s mp0 = {NULL, ___mp0_getp, ___mp0_freep};

/*
 * DMAable pools.
 */

/*
 * With pci bus iommu support, we maintain one pool per pcidev and a 
 * hashed reverse table for virtual to bus physical address translations.
 */
static m_addr_t ___dma_getp(m_pool_s *mp)
{
        m_addr_t vp;
        m_vtob_s *vbp;

        vbp = __m_calloc(&mp0, sizeof(*vbp), "VTOB");
        if (vbp) {
                dma_addr_t daddr;
                vp = (m_addr_t) dma_alloc_coherent(mp->bush,
                                                PAGE_SIZE<<MEMO_PAGE_ORDER,
                                                &daddr, GFP_ATOMIC);
                if (vp) {
                        int hc = VTOB_HASH_CODE(vp);
                        vbp->vaddr = vp;
                        vbp->baddr = daddr;
                        vbp->next = mp->vtob[hc];
                        mp->vtob[hc] = vbp;
                        ++mp->nump;
                        return vp;
                }
        }
        if (vbp)
                __m_free(&mp0, vbp, sizeof(*vbp), "VTOB");
        return 0;
}

static void ___dma_freep(m_pool_s *mp, m_addr_t m)
{
        m_vtob_s **vbpp, *vbp;
        int hc = VTOB_HASH_CODE(m);

        vbpp = &mp->vtob[hc];
        while (*vbpp && (*vbpp)->vaddr != m)
                vbpp = &(*vbpp)->next;
        if (*vbpp) {
                vbp = *vbpp;
                *vbpp = (*vbpp)->next;
                dma_free_coherent(mp->bush, PAGE_SIZE<<MEMO_PAGE_ORDER,
                                  (void *)vbp->vaddr, (dma_addr_t)vbp->baddr);
                __m_free(&mp0, vbp, sizeof(*vbp), "VTOB");
                --mp->nump;
        }
}

static inline m_pool_s *___get_dma_pool(m_bush_t bush)
{
        m_pool_s *mp;
        for (mp = mp0.next; mp && mp->bush != bush; mp = mp->next);
        return mp;
}

static m_pool_s *___cre_dma_pool(m_bush_t bush)
{
        m_pool_s *mp;
        mp = __m_calloc(&mp0, sizeof(*mp), "MPOOL");
        if (mp) {
                memset(mp, 0, sizeof(*mp));
                mp->bush = bush;
                mp->getp = ___dma_getp;
                mp->freep = ___dma_freep;
                mp->next = mp0.next;
                mp0.next = mp;
        }
        return mp;
}

static void ___del_dma_pool(m_pool_s *p)
{
        struct m_pool **pp = &mp0.next;

        while (*pp && *pp != p)
                pp = &(*pp)->next;
        if (*pp) {
                *pp = (*pp)->next;
                __m_free(&mp0, p, sizeof(*p), "MPOOL");
        }
}

static void *__m_calloc_dma(m_bush_t bush, int size, char *name)
{
        u_long flags;
        struct m_pool *mp;
        void *m = NULL;

        spin_lock_irqsave(&ncr53c8xx_lock, flags);
        mp = ___get_dma_pool(bush);
        if (!mp)
                mp = ___cre_dma_pool(bush);
        if (mp)
                m = __m_calloc(mp, size, name);
        if (mp && !mp->nump)
                ___del_dma_pool(mp);
        spin_unlock_irqrestore(&ncr53c8xx_lock, flags);

        return m;
}

static void __m_free_dma(m_bush_t bush, void *m, int size, char *name)
{
        u_long flags;
        struct m_pool *mp;

        spin_lock_irqsave(&ncr53c8xx_lock, flags);
        mp = ___get_dma_pool(bush);
        if (mp)
                __m_free(mp, m, size, name);
        if (mp && !mp->nump)
                ___del_dma_pool(mp);
        spin_unlock_irqrestore(&ncr53c8xx_lock, flags);
}

static m_addr_t __vtobus(m_bush_t bush, void *m)
{
        u_long flags;
        m_pool_s *mp;
        int hc = VTOB_HASH_CODE(m);
        m_vtob_s *vp = NULL;
        m_addr_t a = ((m_addr_t) m) & ~MEMO_CLUSTER_MASK;

        spin_lock_irqsave(&ncr53c8xx_lock, flags);
        mp = ___get_dma_pool(bush);
        if (mp) {
                vp = mp->vtob[hc];
                while (vp && (m_addr_t) vp->vaddr != a)
                        vp = vp->next;
        }
        spin_unlock_irqrestore(&ncr53c8xx_lock, flags);
        return vp ? vp->baddr + (((m_addr_t) m) - a) : 0;
}

#define _m_calloc_dma(np, s, n)         __m_calloc_dma(np->dev, s, n)
#define _m_free_dma(np, p, s, n)        __m_free_dma(np->dev, p, s, n)
#define m_calloc_dma(s, n)              _m_calloc_dma(np, s, n)
#define m_free_dma(p, s, n)             _m_free_dma(np, p, s, n)
#define _vtobus(np, p)                  __vtobus(np->dev, p)
#define vtobus(p)                       _vtobus(np, p)

/*
 *  Deal with DMA mapping/unmapping.
 */

/* To keep track of the dma mapping (sg/single) that has been set */
#define __data_mapped   SCp.phase
#define __data_mapping  SCp.have_data_in

static void __unmap_scsi_data(struct device *dev, struct scsi_cmnd *cmd)
{
        switch(cmd->__data_mapped) {
        case 2:
                scsi_dma_unmap(cmd);
                break;
        }
        cmd->__data_mapped = 0;
}

static int __map_scsi_sg_data(struct device *dev, struct scsi_cmnd *cmd)
{
        int use_sg;

        use_sg = scsi_dma_map(cmd);
        if (!use_sg)
                return 0;

        cmd->__data_mapped = 2;
        cmd->__data_mapping = use_sg;

        return use_sg;
}

#define unmap_scsi_data(np, cmd)        __unmap_scsi_data(np->dev, cmd)
#define map_scsi_sg_data(np, cmd)       __map_scsi_sg_data(np->dev, cmd)

/*==========================================================
**
**      Driver setup.
**
**      This structure is initialized from linux config 
**      options. It can be overridden at boot-up by the boot 
**      command line.
**
**==========================================================
*/
static struct ncr_driver_setup
        driver_setup                    = SCSI_NCR_DRIVER_SETUP;

#ifndef MODULE
#ifdef  SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
static struct ncr_driver_setup
        driver_safe_setup __initdata    = SCSI_NCR_DRIVER_SAFE_SETUP;
#endif
#endif /* !MODULE */

#define initverbose (driver_setup.verbose)
#define bootverbose (np->verbose)


/*===================================================================
**
**      Driver setup from the boot command line
**
**===================================================================
*/

#ifdef MODULE
#define ARG_SEP ' '
#else
#define ARG_SEP ','
#endif

#define OPT_TAGS                1
#define OPT_MASTER_PARITY       2
#define OPT_SCSI_PARITY         3
#define OPT_DISCONNECTION       4
#define OPT_SPECIAL_FEATURES    5
#define OPT_UNUSED_1            6
#define OPT_FORCE_SYNC_NEGO     7
#define OPT_REVERSE_PROBE       8
#define OPT_DEFAULT_SYNC        9
#define OPT_VERBOSE             10
#define OPT_DEBUG               11
#define OPT_BURST_MAX           12
#define OPT_LED_PIN             13
#define OPT_MAX_WIDE            14
#define OPT_SETTLE_DELAY        15
#define OPT_DIFF_SUPPORT        16
#define OPT_IRQM                17
#define OPT_PCI_FIX_UP          18
#define OPT_BUS_CHECK           19
#define OPT_OPTIMIZE            20
#define OPT_RECOVERY            21
#define OPT_SAFE_SETUP          22
#define OPT_USE_NVRAM           23
#define OPT_EXCLUDE             24
#define OPT_HOST_ID             25

#ifdef SCSI_NCR_IARB_SUPPORT
#define OPT_IARB                26
#endif

#ifdef MODULE
#define ARG_SEP ' '
#else
#define ARG_SEP ','
#endif

#ifndef MODULE
static char setup_token[] __initdata = 
        "tags:"   "mpar:"
        "spar:"   "disc:"
        "specf:"  "ultra:"
        "fsn:"    "revprob:"
        "sync:"   "verb:"
        "debug:"  "burst:"
        "led:"    "wide:"
        "settle:" "diff:"
        "irqm:"   "pcifix:"
        "buschk:" "optim:"
        "recovery:"
        "safe:"   "nvram:"
        "excl:"   "hostid:"
#ifdef SCSI_NCR_IARB_SUPPORT
        "iarb:"
#endif
        ;       /* DONNOT REMOVE THIS ';' */

static int __init get_setup_token(char *p)
{
        char *cur = setup_token;
        char *pc;
        int i = 0;

        while (cur != NULL && (pc = strchr(cur, ':')) != NULL) {
                ++pc;
                ++i;
                if (!strncmp(p, cur, pc - cur))
                        return i;
                cur = pc;
        }
        return 0;
}

static int __init sym53c8xx__setup(char *str)
{
#ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
        char *cur = str;
        char *pc, *pv;
        int i, val, c;
        int xi = 0;

        while (cur != NULL && (pc = strchr(cur, ':')) != NULL) {
                char *pe;

                val = 0;
                pv = pc;
                c = *++pv;

                if      (c == 'n')
                        val = 0;
                else if (c == 'y')
                        val = 1;
                else
                        val = (int) simple_strtoul(pv, &pe, 0);

                switch (get_setup_token(cur)) {
                case OPT_TAGS:
                        driver_setup.default_tags = val;
                        if (pe && *pe == '/') {
                                i = 0;
                                while (*pe && *pe != ARG_SEP && 
                                        i < sizeof(driver_setup.tag_ctrl)-1) {
                                        driver_setup.tag_ctrl[i++] = *pe++;
                                }
                                driver_setup.tag_ctrl[i] = '\0';
                        }
                        break;
                case OPT_MASTER_PARITY:
                        driver_setup.master_parity = val;
                        break;
                case OPT_SCSI_PARITY:
                        driver_setup.scsi_parity = val;
                        break;
                case OPT_DISCONNECTION:
                        driver_setup.disconnection = val;
                        break;
                case OPT_SPECIAL_FEATURES:
                        driver_setup.special_features = val;
                        break;
                case OPT_FORCE_SYNC_NEGO:
                        driver_setup.force_sync_nego = val;
                        break;
                case OPT_REVERSE_PROBE:
                        driver_setup.reverse_probe = val;
                        break;
                case OPT_DEFAULT_SYNC:
                        driver_setup.default_sync = val;
                        break;
                case OPT_VERBOSE:
                        driver_setup.verbose = val;
                        break;
                case OPT_DEBUG:
                        driver_setup.debug = val;
                        break;
                case OPT_BURST_MAX:
                        driver_setup.burst_max = val;
                        break;
                case OPT_LED_PIN:
                        driver_setup.led_pin = val;
                        break;
                case OPT_MAX_WIDE:
                        driver_setup.max_wide = val? 1:0;
                        break;
                case OPT_SETTLE_DELAY:
                        driver_setup.settle_delay = val;
                        break;
                case OPT_DIFF_SUPPORT:
                        driver_setup.diff_support = val;
                        break;
                case OPT_IRQM:
                        driver_setup.irqm = val;
                        break;
                case OPT_PCI_FIX_UP:
                        driver_setup.pci_fix_up = val;
                        break;
                case OPT_BUS_CHECK:
                        driver_setup.bus_check = val;
                        break;
                case OPT_OPTIMIZE:
                        driver_setup.optimize = val;
                        break;
                case OPT_RECOVERY:
                        driver_setup.recovery = val;
                        break;
                case OPT_USE_NVRAM:
                        driver_setup.use_nvram = val;
                        break;
                case OPT_SAFE_SETUP:
                        memcpy(&driver_setup, &driver_safe_setup,
                                sizeof(driver_setup));
                        break;
                case OPT_EXCLUDE:
                        if (xi < SCSI_NCR_MAX_EXCLUDES)
                                driver_setup.excludes[xi++] = val;
                        break;
                case OPT_HOST_ID:
                        driver_setup.host_id = val;
                        break;
#ifdef SCSI_NCR_IARB_SUPPORT
                case OPT_IARB:
                        driver_setup.iarb = val;
                        break;
#endif
                default:
                        printk("sym53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc-cur+1), cur);
                        break;
                }

                if ((cur = strchr(cur, ARG_SEP)) != NULL)
                        ++cur;
        }
#endif /* SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT */
        return 1;
}
#endif /* !MODULE */

/*===================================================================
**
**      Get device queue depth from boot command line.
**
**===================================================================
*/
#define DEF_DEPTH       (driver_setup.default_tags)
#define ALL_TARGETS     -2
#define NO_TARGET       -1
#define ALL_LUNS        -2
#define NO_LUN          -1

static int device_queue_depth(int unit, int target, int lun)
{
        int c, h, t, u, v;
        char *p = driver_setup.tag_ctrl;
        char *ep;

        h = -1;
        t = NO_TARGET;
        u = NO_LUN;
        while ((c = *p++) != 0) {
                v = simple_strtoul(p, &ep, 0);
                switch(c) {
                case '/':
                        ++h;
                        t = ALL_TARGETS;
                        u = ALL_LUNS;
                        break;
                case 't':
                        if (t != target)
                                t = (target == v) ? v : NO_TARGET;
                        u = ALL_LUNS;
                        break;
                case 'u':
                        if (u != lun)
                                u = (lun == v) ? v : NO_LUN;
                        break;
                case 'q':
                        if (h == unit &&
                                (t == ALL_TARGETS || t == target) &&
                                (u == ALL_LUNS    || u == lun))
                                return v;
                        break;
                case '-':
                        t = ALL_TARGETS;
                        u = ALL_LUNS;
                        break;
                default:
                        break;
                }
                p = ep;
        }
        return DEF_DEPTH;
}


/*==========================================================
**
**      The CCB done queue uses an array of CCB virtual 
**      addresses. Empty entries are flagged using the bogus 
**      virtual address 0xffffffff.
**
**      Since PCI ensures that only aligned DWORDs are accessed 
**      atomically, 64 bit little-endian architecture requires 
**      to test the high order DWORD of the entry to determine 
**      if it is empty or valid.
**
**      BTW, I will make things differently as soon as I will 
**      have a better idea, but this is simple and should work.
**
**==========================================================
*/
 
#define SCSI_NCR_CCB_DONE_SUPPORT
#ifdef  SCSI_NCR_CCB_DONE_SUPPORT

#define MAX_DONE 24
#define CCB_DONE_EMPTY 0xffffffffUL

/* All 32 bit architectures */
#if BITS_PER_LONG == 32
#define CCB_DONE_VALID(cp)  (((u_long) cp) != CCB_DONE_EMPTY)

/* All > 32 bit (64 bit) architectures regardless endian-ness */
#else
#define CCB_DONE_VALID(cp)  \
        ((((u_long) cp) & 0xffffffff00000000ul) &&      \
         (((u_long) cp) & 0xfffffffful) != CCB_DONE_EMPTY)
#endif

#endif /* SCSI_NCR_CCB_DONE_SUPPORT */

/*==========================================================
**
**      Configuration and Debugging
**
**==========================================================
*/

/*
**    SCSI address of this device.
**    The boot routines should have set it.
**    If not, use this.
*/

#ifndef SCSI_NCR_MYADDR
#define SCSI_NCR_MYADDR      (7)
#endif

/*
**    The maximum number of tags per logic unit.
**    Used only for disk devices that support tags.
*/

#ifndef SCSI_NCR_MAX_TAGS
#define SCSI_NCR_MAX_TAGS    (8)
#endif

/*
**    TAGS are actually limited to 64 tags/lun.
**    We need to deal with power of 2, for alignment constraints.
*/
#if     SCSI_NCR_MAX_TAGS > 64
#define MAX_TAGS (64)
#else
#define MAX_TAGS SCSI_NCR_MAX_TAGS
#endif

#define NO_TAG  (255)

/*
**      Choose appropriate type for tag bitmap.
*/
#if     MAX_TAGS > 32
typedef u64 tagmap_t;
#else
typedef u32 tagmap_t;
#endif

/*
**    Number of targets supported by the driver.
**    n permits target numbers 0..n-1.
**    Default is 16, meaning targets #0..#15.
**    #7 .. is myself.
*/

#ifdef SCSI_NCR_MAX_TARGET
#define MAX_TARGET  (SCSI_NCR_MAX_TARGET)
#else
#define MAX_TARGET  (16)
#endif

/*
**    Number of logic units supported by the driver.
**    n enables logic unit numbers 0..n-1.
**    The common SCSI devices require only
**    one lun, so take 1 as the default.
*/

#ifdef SCSI_NCR_MAX_LUN
#define MAX_LUN    SCSI_NCR_MAX_LUN
#else
#define MAX_LUN    (1)
#endif

/*
**    Asynchronous pre-scaler (ns). Shall be 40
*/
 
#ifndef SCSI_NCR_MIN_ASYNC
#define SCSI_NCR_MIN_ASYNC (40)
#endif

/*
**    The maximum number of jobs scheduled for starting.
**    There should be one slot per target, and one slot
**    for each tag of each target in use.
**    The calculation below is actually quite silly ...
*/

#ifdef SCSI_NCR_CAN_QUEUE
#define MAX_START   (SCSI_NCR_CAN_QUEUE + 4)
#else
#define MAX_START   (MAX_TARGET + 7 * MAX_TAGS)
#endif

/*
**   We limit the max number of pending IO to 250.
**   since we donnot want to allocate more than 1 
**   PAGE for 'scripth'.
*/
#if     MAX_START > 250
#undef  MAX_START
#define MAX_START 250
#endif

/*
**    The maximum number of segments a transfer is split into.
**    We support up to 127 segments for both read and write.
**    The data scripts are broken into 2 sub-scripts.
**    80 (MAX_SCATTERL) segments are moved from a sub-script
**    in on-chip RAM. This makes data transfers shorter than 
**    80k (assuming 1k fs) as fast as possible.
*/

#define MAX_SCATTER (SCSI_NCR_MAX_SCATTER)

#if (MAX_SCATTER > 80)
#define MAX_SCATTERL    80
#define MAX_SCATTERH    (MAX_SCATTER - MAX_SCATTERL)
#else
#define MAX_SCATTERL    (MAX_SCATTER-1)
#define MAX_SCATTERH    1
#endif

/*
**      other
*/

#define NCR_SNOOP_TIMEOUT (1000000)

/*
**      Other definitions
*/

#define initverbose (driver_setup.verbose)
#define bootverbose (np->verbose)

/*==========================================================
**
**      Command control block states.
**
**==========================================================
*/

#define HS_IDLE         (0)
#define HS_BUSY         (1)
#define HS_NEGOTIATE    (2)     /* sync/wide data transfer*/
#define HS_DISCONNECT   (3)     /* Disconnected by target */

#define HS_DONEMASK     (0x80)
#define HS_COMPLETE     (4|HS_DONEMASK)
#define HS_SEL_TIMEOUT  (5|HS_DONEMASK) /* Selection timeout      */
#define HS_RESET        (6|HS_DONEMASK) /* SCSI reset             */
#define HS_ABORTED      (7|HS_DONEMASK) /* Transfer aborted       */
#define HS_TIMEOUT      (8|HS_DONEMASK) /* Software timeout       */
#define HS_FAIL         (9|HS_DONEMASK) /* SCSI or PCI bus errors */
#define HS_UNEXPECTED   (10|HS_DONEMASK)/* Unexpected disconnect  */

/*
**      Invalid host status values used by the SCRIPTS processor 
**      when the nexus is not fully identified.
**      Shall never appear in a CCB.
*/

#define HS_INVALMASK    (0x40)
#define HS_SELECTING    (0|HS_INVALMASK)
#define HS_IN_RESELECT  (1|HS_INVALMASK)
#define HS_STARTING     (2|HS_INVALMASK)

/*
**      Flags set by the SCRIPT processor for commands 
**      that have been skipped.
*/
#define HS_SKIPMASK     (0x20)

/*==========================================================
**
**      Software Interrupt Codes
**
**==========================================================
*/

#define SIR_BAD_STATUS          (1)
#define SIR_XXXXXXXXXX          (2)
#define SIR_NEGO_SYNC           (3)
#define SIR_NEGO_WIDE           (4)
#define SIR_NEGO_FAILED         (5)
#define SIR_NEGO_PROTO          (6)
#define SIR_REJECT_RECEIVED     (7)
#define SIR_REJECT_SENT         (8)
#define SIR_IGN_RESIDUE         (9)
#define SIR_MISSING_SAVE        (10)
#define SIR_RESEL_NO_MSG_IN     (11)
#define SIR_RESEL_NO_IDENTIFY   (12)
#define SIR_RESEL_BAD_LUN       (13)
#define SIR_RESEL_BAD_TARGET    (14)
#define SIR_RESEL_BAD_I_T_L     (15)
#define SIR_RESEL_BAD_I_T_L_Q   (16)
#define SIR_DONE_OVERFLOW       (17)
#define SIR_INTFLY              (18)
#define SIR_MAX                 (18)

/*==========================================================
**
**      Extended error codes.
**      xerr_status field of struct ccb.
**
**==========================================================
*/

#define XE_OK           (0)
#define XE_EXTRA_DATA   (1)     /* unexpected data phase */
#define XE_BAD_PHASE    (2)     /* illegal phase (4/5)   */

/*==========================================================
**
**      Negotiation status.
**      nego_status field       of struct ccb.
**
**==========================================================
*/

#define NS_NOCHANGE     (0)
#define NS_SYNC         (1)
#define NS_WIDE         (2)
#define NS_PPR          (4)

/*==========================================================
**
**      Misc.
**
**==========================================================
*/

#define CCB_MAGIC       (0xf2691ad2)

/*==========================================================
**
**      Declaration of structs.
**
**==========================================================
*/

static struct scsi_transport_template *ncr53c8xx_transport_template = NULL;

struct tcb;
struct lcb;
struct ccb;
struct ncb;
struct script;

struct link {
        ncrcmd  l_cmd;
        ncrcmd  l_paddr;
};

struct  usrcmd {
        u_long  target;
        u_long  lun;
        u_long  data;
        u_long  cmd;
};

#define UC_SETSYNC      10
#define UC_SETTAGS      11
#define UC_SETDEBUG     12
#define UC_SETORDER     13
#define UC_SETWIDE      14
#define UC_SETFLAG      15
#define UC_SETVERBOSE   17

#define UF_TRACE        (0x01)
#define UF_NODISC       (0x02)
#define UF_NOSCAN       (0x04)

/*========================================================================
**
**      Declaration of structs:         target control block
**
**========================================================================
*/
struct tcb {
        /*----------------------------------------------------------------
        **      During reselection the ncr jumps to this point with SFBR 
        **      set to the encoded target number with bit 7 set.
        **      if it's not this target, jump to the next.
        **
        **      JUMP  IF (SFBR != #target#), @(next tcb)
        **----------------------------------------------------------------
        */
        struct link   jump_tcb;

        /*----------------------------------------------------------------
        **      Load the actual values for the sxfer and the scntl3
        **      register (sync/wide mode).
        **
        **      SCR_COPY (1), @(sval field of this tcb), @(sxfer  register)
        **      SCR_COPY (1), @(wval field of this tcb), @(scntl3 register)
        **----------------------------------------------------------------
        */
        ncrcmd  getscr[6];

        /*----------------------------------------------------------------
        **      Get the IDENTIFY message and load the LUN to SFBR.
        **
        **      CALL, <RESEL_LUN>
        **----------------------------------------------------------------
        */
        struct link   call_lun;

        /*----------------------------------------------------------------
        **      Now look for the right lun.
        **
        **      For i = 0 to 3
        **              SCR_JUMP ^ IFTRUE(MASK(i, 3)), @(first lcb mod. i)
        **
        **      Recent chips will prefetch the 4 JUMPS using only 1 burst.
        **      It is kind of hashcoding.
        **----------------------------------------------------------------
        */
        struct link     jump_lcb[4];    /* JUMPs for reselection        */
        struct lcb *    lp[MAX_LUN];    /* The lcb's of this tcb        */

        /*----------------------------------------------------------------
        **      Pointer to the ccb used for negotiation.
        **      Prevent from starting a negotiation for all queued commands 
        **      when tagged command queuing is enabled.
        **----------------------------------------------------------------
        */
        struct ccb *   nego_cp;

        /*----------------------------------------------------------------
        **      statistical data
        **----------------------------------------------------------------
        */
        u_long  transfers;
        u_long  bytes;

        /*----------------------------------------------------------------
        **      negotiation of wide and synch transfer and device quirks.
        **----------------------------------------------------------------
        */
#ifdef SCSI_NCR_BIG_ENDIAN
/*0*/   u16     period;
/*2*/   u_char  sval;
/*3*/   u_char  minsync;
/*0*/   u_char  wval;
/*1*/   u_char  widedone;
/*2*/   u_char  quirks;
/*3*/   u_char  maxoffs;
#else
/*0*/   u_char  minsync;
/*1*/   u_char  sval;
/*2*/   u16     period;
/*0*/   u_char  maxoffs;
/*1*/   u_char  quirks;
/*2*/   u_char  widedone;
/*3*/   u_char  wval;
#endif

        /* User settable limits and options.  */
        u_char  usrsync;
        u_char  usrwide;
        u_char  usrtags;
        u_char  usrflag;
        struct scsi_target *starget;
};

/*========================================================================
**
**      Declaration of structs:         lun control block
**
**========================================================================
*/
struct lcb {
        /*----------------------------------------------------------------
        **      During reselection the ncr jumps to this point
        **      with SFBR set to the "Identify" message.
        **      if it's not this lun, jump to the next.
        **
        **      JUMP  IF (SFBR != #lun#), @(next lcb of this target)
        **
        **      It is this lun. Load TEMP with the nexus jumps table 
        **      address and jump to RESEL_TAG (or RESEL_NOTAG).
        **
        **              SCR_COPY (4), p_jump_ccb, TEMP,
        **              SCR_JUMP, <RESEL_TAG>
        **----------------------------------------------------------------
        */
        struct link     jump_lcb;
        ncrcmd          load_jump_ccb[3];
        struct link     jump_tag;
        ncrcmd          p_jump_ccb;     /* Jump table bus address       */

        /*----------------------------------------------------------------
        **      Jump table used by the script processor to directly jump 
        **      to the CCB corresponding to the reselected nexus.
        **      Address is allocated on 256 bytes boundary in order to 
        **      allow 8 bit calculation of the tag jump entry for up to 
        **      64 possible tags.
        **----------------------------------------------------------------
        */
        u32             jump_ccb_0;     /* Default table if no tags     */
        u32             *jump_ccb;      /* Virtual address              */

        /*----------------------------------------------------------------
        **      CCB queue management.
        **----------------------------------------------------------------
        */
        struct list_head free_ccbq;     /* Queue of available CCBs      */
        struct list_head busy_ccbq;     /* Queue of busy CCBs           */
        struct list_head wait_ccbq;     /* Queue of waiting for IO CCBs */
        struct list_head skip_ccbq;     /* Queue of skipped CCBs        */
        u_char          actccbs;        /* Number of allocated CCBs     */
        u_char          busyccbs;       /* CCBs busy for this lun       */
        u_char          queuedccbs;     /* CCBs queued to the controller*/
        u_char          queuedepth;     /* Queue depth for this lun     */
        u_char          scdev_depth;    /* SCSI device queue depth      */
        u_char          maxnxs;         /* Max possible nexuses         */

        /*----------------------------------------------------------------
        **      Control of tagged command queuing.
        **      Tags allocation is performed using a circular buffer.
        **      This avoids using a loop for tag allocation.
        **----------------------------------------------------------------
        */
        u_char          ia_tag;         /* Allocation index             */
        u_char          if_tag;         /* Freeing index                */
        u_char cb_tags[MAX_TAGS];       /* Circular tags buffer */
        u_char          usetags;        /* Command queuing is active    */
        u_char          maxtags;        /* Max nr of tags asked by user */
        u_char          numtags;        /* Current number of tags       */

        /*----------------------------------------------------------------
        **      QUEUE FULL control and ORDERED tag control.
        **----------------------------------------------------------------
        */
        /*----------------------------------------------------------------
        **      QUEUE FULL and ORDERED tag control.
        **----------------------------------------------------------------
        */
        u16             num_good;       /* Nr of GOOD since QUEUE FULL  */
        tagmap_t        tags_umap;      /* Used tags bitmap             */
        tagmap_t        tags_smap;      /* Tags in use at 'tag_stime'   */
        u_long          tags_stime;     /* Last time we set smap=umap   */
        struct ccb *    held_ccb;       /* CCB held for QUEUE FULL      */
};

/*========================================================================
**
**      Declaration of structs:     the launch script.
**
**========================================================================
**
**      It is part of the CCB and is called by the scripts processor to 
**      start or restart the data structure (nexus).
**      This 6 DWORDs mini script makes use of prefetching.
**
**------------------------------------------------------------------------
*/
struct launch {
        /*----------------------------------------------------------------
        **      SCR_COPY(4),    @(p_phys), @(dsa register)
        **      SCR_JUMP,       @(scheduler_point)
        **----------------------------------------------------------------
        */
        ncrcmd          setup_dsa[3];   /* Copy 'phys' address to dsa   */
        struct link     schedule;       /* Jump to scheduler point      */
        ncrcmd          p_phys;         /* 'phys' header bus address    */
};

/*========================================================================
**
**      Declaration of structs:     global HEADER.
**
**========================================================================
**
**      This substructure is copied from the ccb to a global address after 
**      selection (or reselection) and copied back before disconnect.
**
**      These fields are accessible to the script processor.
**
**------------------------------------------------------------------------
*/

struct head {
        /*----------------------------------------------------------------
        **      Saved data pointer.
        **      Points to the position in the script responsible for the
        **      actual transfer transfer of data.
        **      It's written after reception of a SAVE_DATA_POINTER message.
        **      The goalpointer points after the last transfer command.
        **----------------------------------------------------------------
        */
        u32             savep;
        u32             lastp;
        u32             goalp;

        /*----------------------------------------------------------------
        **      Alternate data pointer.
        **      They are copied back to savep/lastp/goalp by the SCRIPTS 
        **      when the direction is unknown and the device claims data out.
        **----------------------------------------------------------------
        */
        u32             wlastp;
        u32             wgoalp;

        /*----------------------------------------------------------------
        **      The virtual address of the ccb containing this header.
        **----------------------------------------------------------------
        */
        struct ccb *    cp;

        /*----------------------------------------------------------------
        **      Status fields.
        **----------------------------------------------------------------
        */
        u_char          scr_st[4];      /* script status                */
        u_char          status[4];      /* host status. must be the     */
                                        /*  last DWORD of the header.   */
};

/*
**      The status bytes are used by the host and the script processor.
**
**      The byte corresponding to the host_status must be stored in the 
**      last DWORD of the CCB header since it is used for command 
**      completion (ncr_wakeup()). Doing so, we are sure that the header 
**      has been entirely copied back to the CCB when the host_status is 
**      seen complete by the CPU.
**
**      The last four bytes (status[4]) are copied to the scratchb register
**      (declared as scr0..scr3 in ncr_reg.h) just after the select/reselect,
**      and copied back just after disconnecting.
**      Inside the script the XX_REG are used.
**
**      The first four bytes (scr_st[4]) are used inside the script by 
**      "COPY" commands.
**      Because source and destination must have the same alignment
**      in a DWORD, the fields HAVE to be at the chosen offsets.
**              xerr_st         0       (0x34)  scratcha
**              sync_st         1       (0x05)  sxfer
**              wide_st         3       (0x03)  scntl3
*/

/*
**      Last four bytes (script)
*/
#define  QU_REG scr0
#define  HS_REG scr1
#define  HS_PRT nc_scr1
#define  SS_REG scr2
#define  SS_PRT nc_scr2
#define  PS_REG scr3

/*
**      Last four bytes (host)
*/
#ifdef SCSI_NCR_BIG_ENDIAN
#define  actualquirks  phys.header.status[3]
#define  host_status   phys.header.status[2]
#define  scsi_status   phys.header.status[1]
#define  parity_status phys.header.status[0]
#else
#define  actualquirks  phys.header.status[0]
#define  host_status   phys.header.status[1]
#define  scsi_status   phys.header.status[2]
#define  parity_status phys.header.status[3]
#endif

/*
**      First four bytes (script)
*/
#define  xerr_st       header.scr_st[0]
#define  sync_st       header.scr_st[1]
#define  nego_st       header.scr_st[2]
#define  wide_st       header.scr_st[3]

/*
**      First four bytes (host)
*/
#define  xerr_status   phys.xerr_st
#define  nego_status   phys.nego_st

#if 0
#define  sync_status   phys.sync_st
#define  wide_status   phys.wide_st
#endif

/*==========================================================
**
**      Declaration of structs:     Data structure block
**
**==========================================================
**
**      During execution of a ccb by the script processor,
**      the DSA (data structure address) register points
**      to this substructure of the ccb.
**      This substructure contains the header with
**      the script-processor-changeable data and
**      data blocks for the indirect move commands.
**
**----------------------------------------------------------
*/

struct dsb {

        /*
        **      Header.
        */

        struct head     header;

        /*
        **      Table data for Script
        */

        struct scr_tblsel  select;
        struct scr_tblmove smsg  ;
        struct scr_tblmove cmd   ;
        struct scr_tblmove sense ;
        struct scr_tblmove data[MAX_SCATTER];
};


/*========================================================================
**
**      Declaration of structs:     Command control block.
**
**========================================================================
*/
struct ccb {
        /*----------------------------------------------------------------
        **      This is the data structure which is pointed by the DSA 
        **      register when it is executed by the script processor.
        **      It must be the first entry because it contains the header 
        **      as first entry that must be cache line aligned.
        **----------------------------------------------------------------
        */
        struct dsb      phys;

        /*----------------------------------------------------------------
        **      Mini-script used at CCB execution start-up.
        **      Load the DSA with the data structure address (phys) and 
        **      jump to SELECT. Jump to CANCEL if CCB is to be canceled.
        **----------------------------------------------------------------
        */
        struct launch   start;

        /*----------------------------------------------------------------
        **      Mini-script used at CCB relection to restart the nexus.
        **      Load the DSA with the data structure address (phys) and 
        **      jump to RESEL_DSA. Jump to ABORT if CCB is to be aborted.
        **----------------------------------------------------------------
        */
        struct launch   restart;

        /*----------------------------------------------------------------
        **      If a data transfer phase is terminated too early
        **      (after reception of a message (i.e. DISCONNECT)),
        **      we have to prepare a mini script to transfer
        **      the rest of the data.
        **----------------------------------------------------------------
        */
        ncrcmd          patch[8];

        /*----------------------------------------------------------------
        **      The general SCSI driver provides a
        **      pointer to a control block.
        **----------------------------------------------------------------
        */
        struct scsi_cmnd        *cmd;           /* SCSI command                 */
        u_char          cdb_buf[16];    /* Copy of CDB                  */
        u_char          sense_buf[64];
        int             data_len;       /* Total data length            */

        /*----------------------------------------------------------------
        **      Message areas.
        **      We prepare a message to be sent after selection.
        **      We may use a second one if the command is rescheduled 
        **      due to GETCC or QFULL.
        **      Contents are IDENTIFY and SIMPLE_TAG.
        **      While negotiating sync or wide transfer,
        **      a SDTR or WDTR message is appended.
        **----------------------------------------------------------------
        */
        u_char          scsi_smsg [8];
        u_char          scsi_smsg2[8];

        /*----------------------------------------------------------------
        **      Other fields.
        **----------------------------------------------------------------
        */
        u_long          p_ccb;          /* BUS address of this CCB      */
        u_char          sensecmd[6];    /* Sense command                */
        u_char          tag;            /* Tag for this transfer        */
                                        /*  255 means no tag            */
        u_char          target;
        u_char          lun;
        u_char          queued;
        u_char          auto_sense;
        struct ccb *    link_ccb;       /* Host adapter CCB chain       */
        struct list_head link_ccbq;     /* Link to unit CCB queue       */
        u32             startp;         /* Initial data pointer         */
        u_long          magic;          /* Free / busy  CCB flag        */
};

#define CCB_PHYS(cp,lbl)        (cp->p_ccb + offsetof(struct ccb, lbl))


/*========================================================================
**
**      Declaration of structs:     NCR device descriptor
**
**========================================================================
*/
struct ncb {
        /*----------------------------------------------------------------
        **      The global header.
        **      It is accessible to both the host and the script processor.
        **      Must be cache line size aligned (32 for x86) in order to 
        **      allow cache line bursting when it is copied to/from CCB.
        **----------------------------------------------------------------
        */
        struct head     header;

        /*----------------------------------------------------------------
        **      CCBs management queues.
        **----------------------------------------------------------------
        */
        struct scsi_cmnd        *waiting_list;  /* Commands waiting for a CCB   */
                                        /*  when lcb is not allocated.  */
        struct scsi_cmnd        *done_list;     /* Commands waiting for done()  */
                                        /* callback to be invoked.      */ 
        spinlock_t      smp_lock;       /* Lock for SMP threading       */

        /*----------------------------------------------------------------
        **      Chip and controller identification.
        **----------------------------------------------------------------
        */
        int             unit;           /* Unit number                  */
        char            inst_name[16];  /* ncb instance name            */

        /*----------------------------------------------------------------
        **      Initial value of some IO register bits.
        **      These values are assumed to have been set by BIOS, and may 
        **      be used for probing adapter implementation differences.
        **----------------------------------------------------------------
        */
        u_char  sv_scntl0, sv_scntl3, sv_dmode, sv_dcntl, sv_ctest0, sv_ctest3,
                sv_ctest4, sv_ctest5, sv_gpcntl, sv_stest2, sv_stest4;

        /*----------------------------------------------------------------
        **      Actual initial value of IO register bits used by the 
        **      driver. They are loaded at initialisation according to  
        **      features that are to be enabled.
        **----------------------------------------------------------------
        */
        u_char  rv_scntl0, rv_scntl3, rv_dmode, rv_dcntl, rv_ctest0, rv_ctest3,
                rv_ctest4, rv_ctest5, rv_stest2;

        /*----------------------------------------------------------------
        **      Targets management.
        **      During reselection the ncr jumps to jump_tcb.
        **      The SFBR register is loaded with the encoded target id.
        **      For i = 0 to 3
        **              SCR_JUMP ^ IFTRUE(MASK(i, 3)), @(next tcb mod. i)
        **
        **      Recent chips will prefetch the 4 JUMPS using only 1 burst.
        **      It is kind of hashcoding.
        **----------------------------------------------------------------
        */
        struct link     jump_tcb[4];    /* JUMPs for reselection        */
        struct tcb  target[MAX_TARGET]; /* Target data                  */

        /*----------------------------------------------------------------
        **      Virtual and physical bus addresses of the chip.
        **----------------------------------------------------------------
        */
        void __iomem *vaddr;            /* Virtual and bus address of   */
        unsigned long   paddr;          /*  chip's IO registers.        */
        unsigned long   paddr2;         /* On-chip RAM bus address.     */
        volatile                        /* Pointer to volatile for      */
        struct ncr_reg  __iomem *reg;   /*  memory mapped IO.           */

        /*----------------------------------------------------------------
        **      SCRIPTS virtual and physical bus addresses.
        **      'script'  is loaded in the on-chip RAM if present.
        **      'scripth' stays in main memory.
        **----------------------------------------------------------------
        */
        struct script   *script0;       /* Copies of script and scripth */
        struct scripth  *scripth0;      /*  relocated for this ncb.     */
        struct scripth  *scripth;       /* Actual scripth virt. address */
        u_long          p_script;       /* Actual script and scripth    */
        u_long          p_scripth;      /*  bus addresses.              */

        /*----------------------------------------------------------------
        **      General controller parameters and configuration.
        **----------------------------------------------------------------
        */
        struct device   *dev;
        u_char          revision_id;    /* PCI device revision id       */
        u32             irq;            /* IRQ level                    */
        u32             features;       /* Chip features map            */
        u_char          myaddr;         /* SCSI id of the adapter       */
        u_char          maxburst;       /* log base 2 of dwords burst   */
        u_char          maxwide;        /* Maximum transfer width       */
        u_char          minsync;        /* Minimum sync period factor   */
        u_char          maxsync;        /* Maximum sync period factor   */
        u_char          maxoffs;        /* Max scsi offset              */
        u_char          multiplier;     /* Clock multiplier (1,2,4)     */
        u_char          clock_divn;     /* Number of clock divisors     */
        u_long          clock_khz;      /* SCSI clock frequency in KHz  */

        /*----------------------------------------------------------------
        **      Start queue management.
        **      It is filled up by the host processor and accessed by the 
        **      SCRIPTS processor in order to start SCSI commands.
        **----------------------------------------------------------------
        */
        u16             squeueput;      /* Next free slot of the queue  */
        u16             actccbs;        /* Number of allocated CCBs     */
        u16             queuedccbs;     /* Number of CCBs in start queue*/
        u16             queuedepth;     /* Start queue depth            */

        /*----------------------------------------------------------------
        **      Timeout handler.
        **----------------------------------------------------------------
        */
        struct timer_list timer;        /* Timer handler link header    */
        u_long          lasttime;
        u_long          settle_time;    /* Resetting the SCSI BUS       */

        /*----------------------------------------------------------------
        **      Debugging and profiling.
        **----------------------------------------------------------------
        */
        struct ncr_reg  regdump;        /* Register dump                */
        u_long          regtime;        /* Time it has been done        */

        /*----------------------------------------------------------------
        **      Miscellaneous buffers accessed by the scripts-processor.
        **      They shall be DWORD aligned, because they may be read or 
        **      written with a SCR_COPY script command.
        **----------------------------------------------------------------
        */
        u_char          msgout[8];      /* Buffer for MESSAGE OUT       */
        u_char          msgin [8];      /* Buffer for MESSAGE IN        */
        u32             lastmsg;        /* Last SCSI message sent       */
        u_char          scratch;        /* Scratch for SCSI receive     */

        /*----------------------------------------------------------------
        **      Miscellaneous configuration and status parameters.
        **----------------------------------------------------------------
        */
        u_char          disc;           /* Disconnection allowed        */
        u_char          scsi_mode;      /* Current SCSI BUS mode        */
        u_char          order;          /* Tag order to use             */
        u_char          verbose;        /* Verbosity for this controller*/
        int             ncr_cache;      /* Used for cache test at init. */
        u_long          p_ncb;          /* BUS address of this NCB      */

        /*----------------------------------------------------------------
        **      Command completion handling.
        **----------------------------------------------------------------
        */
#ifdef SCSI_NCR_CCB_DONE_SUPPORT
        struct ccb      *(ccb_done[MAX_DONE]);
        int             ccb_done_ic;
#endif
        /*----------------------------------------------------------------
        **      Fields that should be removed or changed.
        **----------------------------------------------------------------
        */
        struct ccb      *ccb;           /* Global CCB                   */
        struct usrcmd   user;           /* Command from user            */
        volatile u_char release_stage;  /* Synchronisation stage on release  */
};

#define NCB_SCRIPT_PHYS(np,lbl)  (np->p_script  + offsetof (struct script, lbl))
#define NCB_SCRIPTH_PHYS(np,lbl) (np->p_scripth + offsetof (struct scripth,lbl))

/*==========================================================
**
**
**      Script for NCR-Processor.
**
**      Use ncr_script_fill() to create the variable parts.
**      Use ncr_script_copy_and_bind() to make a copy and
**      bind to physical addresses.
**
**
**==========================================================
**
**      We have to know the offsets of all labels before
**      we reach them (for forward jumps).
**      Therefore we declare a struct here.
**      If you make changes inside the script,
**      DONT FORGET TO CHANGE THE LENGTHS HERE!
**
**----------------------------------------------------------
*/

/*
**      For HP Zalon/53c720 systems, the Zalon interface
**      between CPU and 53c720 does prefetches, which causes
**      problems with self modifying scripts.  The problem
**      is overcome by calling a dummy subroutine after each
**      modification, to force a refetch of the script on
**      return from the subroutine.
*/

#ifdef CONFIG_NCR53C8XX_PREFETCH
#define PREFETCH_FLUSH_CNT      2
#define PREFETCH_FLUSH          SCR_CALL, PADDRH (wait_dma),
#else
#define PREFETCH_FLUSH_CNT      0
#define PREFETCH_FLUSH
#endif

/*
**      Script fragments which are loaded into the on-chip RAM 
**      of 825A, 875 and 895 chips.
*/
struct script {
        ncrcmd  start           [  5];
        ncrcmd  startpos        [  1];
        ncrcmd  select          [  6];
        ncrcmd  select2         [  9 + PREFETCH_FLUSH_CNT];
        ncrcmd  loadpos         [  4];
        ncrcmd  send_ident      [  9];
        ncrcmd  prepare         [  6];
        ncrcmd  prepare2        [  7];
        ncrcmd  command         [  6];
        ncrcmd  dispatch        [ 32];
        ncrcmd  clrack          [  4];
        ncrcmd  no_data         [ 17];
        ncrcmd  status          [  8];
        ncrcmd  msg_in          [  2];
        ncrcmd  msg_in2         [ 16];
        ncrcmd  msg_bad         [  4];
        ncrcmd  setmsg          [  7];
        ncrcmd  cleanup         [  6];
        ncrcmd  complete        [  9];
        ncrcmd  cleanup_ok      [  8 + PREFETCH_FLUSH_CNT];
        ncrcmd  cleanup0        [  1];
#ifndef SCSI_NCR_CCB_DONE_SUPPORT
        ncrcmd  signal          [ 12];
#else
        ncrcmd  signal          [  9];
        ncrcmd  done_pos        [  1];
        ncrcmd  done_plug       [  2];
        ncrcmd  done_end        [  7];
#endif
        ncrcmd  save_dp         [  7];
        ncrcmd  restore_dp      [  5];
        ncrcmd  disconnect      [ 10];
        ncrcmd  msg_out         [  9];
        ncrcmd  msg_out_done    [  7];
        ncrcmd  idle            [  2];
        ncrcmd  reselect        [  8];
        ncrcmd  reselected      [  8];
        ncrcmd  resel_dsa       [  6 + PREFETCH_FLUSH_CNT];
        ncrcmd  loadpos1        [  4];
        ncrcmd  resel_lun       [  6];
        ncrcmd  resel_tag       [  6];
        ncrcmd  jump_to_nexus   [  4 + PREFETCH_FLUSH_CNT];
        ncrcmd  nexus_indirect  [  4];
        ncrcmd  resel_notag     [  4];
        ncrcmd  data_in         [MAX_SCATTERL * 4];
        ncrcmd  data_in2        [  4];
        ncrcmd  data_out        [MAX_SCATTERL * 4];
        ncrcmd  data_out2       [  4];
};

/*
**      Script fragments which stay in main memory for all chips.
*/
struct scripth {
        ncrcmd  tryloop         [MAX_START*2];
        ncrcmd  tryloop2        [  2];
#ifdef SCSI_NCR_CCB_DONE_SUPPORT
        ncrcmd  done_queue      [MAX_DONE*5];
        ncrcmd  done_queue2     [  2];
#endif
        ncrcmd  select_no_atn   [  8];
        ncrcmd  cancel          [  4];
        ncrcmd  skip            [  9 + PREFETCH_FLUSH_CNT];
        ncrcmd  skip2           [ 19];
        ncrcmd  par_err_data_in [  6];
        ncrcmd  par_err_other   [  4];
        ncrcmd  msg_reject      [  8];
        ncrcmd  msg_ign_residue [ 24];
        ncrcmd  msg_extended    [ 10];
        ncrcmd  msg_ext_2       [ 10];
        ncrcmd  msg_wdtr        [ 14];
        ncrcmd  send_wdtr       [  7];
        ncrcmd  msg_ext_3       [ 10];
        ncrcmd  msg_sdtr        [ 14];
        ncrcmd  send_sdtr       [  7];
        ncrcmd  nego_bad_phase  [  4];
        ncrcmd  msg_out_abort   [ 10];
        ncrcmd  hdata_in        [MAX_SCATTERH * 4];
        ncrcmd  hdata_in2       [  2];
        ncrcmd  hdata_out       [MAX_SCATTERH * 4];
        ncrcmd  hdata_out2      [  2];
        ncrcmd  reset           [  4];
        ncrcmd  aborttag        [  4];
        ncrcmd  abort           [  2];
        ncrcmd  abort_resel     [ 20];
        ncrcmd  resend_ident    [  4];
        ncrcmd  clratn_go_on    [  3];
        ncrcmd  nxtdsp_go_on    [  1];
        ncrcmd  sdata_in        [  8];
        ncrcmd  data_io         [ 18];
        ncrcmd  bad_identify    [ 12];
        ncrcmd  bad_i_t_l       [  4];
        ncrcmd  bad_i_t_l_q     [  4];
        ncrcmd  bad_target      [  8];
        ncrcmd  bad_status      [  8];
        ncrcmd  start_ram       [  4 + PREFETCH_FLUSH_CNT];
        ncrcmd  start_ram0      [  4];
        ncrcmd  sto_restart     [  5];
        ncrcmd  wait_dma        [  2];
        ncrcmd  snooptest       [  9];
        ncrcmd  snoopend        [  2];
};

/*==========================================================
**
**
**      Function headers.
**
**
**==========================================================
*/

static  void    ncr_alloc_ccb   (struct ncb *np, u_char tn, u_char ln);
static  void    ncr_complete    (struct ncb *np, struct ccb *cp);
static  void    ncr_exception   (struct ncb *np);
static  void    ncr_free_ccb    (struct ncb *np, struct ccb *cp);
static  void    ncr_init_ccb    (struct ncb *np, struct ccb *cp);
static  void    ncr_init_tcb    (struct ncb *np, u_char tn);
static  struct lcb *    ncr_alloc_lcb   (struct ncb *np, u_char tn, u_char ln);
static  struct lcb *    ncr_setup_lcb   (struct ncb *np, struct scsi_device *sdev);
static  void    ncr_getclock    (struct ncb *np, int mult);
static  void    ncr_selectclock (struct ncb *np, u_char scntl3);
static  struct ccb *ncr_get_ccb (struct ncb *np, struct scsi_cmnd *cmd);
static  void    ncr_chip_reset  (struct ncb *np, int delay);
static  void    ncr_init        (struct ncb *np, int reset, char * msg, u_long code);
static  int     ncr_int_sbmc    (struct ncb *np);
static  int     ncr_int_par     (struct ncb *np);
static  void    ncr_int_ma      (struct ncb *np);
static  void    ncr_int_sir     (struct ncb *np);
static  void    ncr_int_sto     (struct ncb *np);
static  void    ncr_negotiate   (struct ncb* np, struct tcb* tp);
static  int     ncr_prepare_nego(struct ncb *np, struct ccb *cp, u_char *msgptr);

static  void    ncr_script_copy_and_bind
                                (struct ncb *np, ncrcmd *src, ncrcmd *dst, int len);
static  void    ncr_script_fill (struct script * scr, struct scripth * scripth);
static  int     ncr_scatter     (struct ncb *np, struct ccb *cp, struct scsi_cmnd *cmd);
static  void    ncr_getsync     (struct ncb *np, u_char sfac, u_char *fakp, u_char *scntl3p);
static  void    ncr_setsync     (struct ncb *np, struct ccb *cp, u_char scntl3, u_char sxfer);
static  void    ncr_setup_tags  (struct ncb *np, struct scsi_device *sdev);
static  void    ncr_setwide     (struct ncb *np, struct ccb *cp, u_char wide, u_char ack);
static  int     ncr_snooptest   (struct ncb *np);
static  void    ncr_timeout     (struct ncb *np);
static  void    ncr_wakeup      (struct ncb *np, u_long code);
static  void    ncr_wakeup_done (struct ncb *np);
static  void    ncr_start_next_ccb (struct ncb *np, struct lcb * lp, int maxn);
static  void    ncr_put_start_queue(struct ncb *np, struct ccb *cp);

static void insert_into_waiting_list(struct ncb *np, struct scsi_cmnd *cmd);
static struct scsi_cmnd *retrieve_from_waiting_list(int to_remove, struct ncb *np, struct scsi_cmnd *cmd);
static void process_waiting_list(struct ncb *np, int sts);

#define remove_from_waiting_list(np, cmd) \
                retrieve_from_waiting_list(1, (np), (cmd))
#define requeue_waiting_list(np) process_waiting_list((np), DID_OK)
#define reset_waiting_list(np) process_waiting_list((np), DID_RESET)

static inline char *ncr_name (struct ncb *np)
{
        return np->inst_name;
}


/*==========================================================
**
**
**      Scripts for NCR-Processor.
**
**      Use ncr_script_bind for binding to physical addresses.
**
**
**==========================================================
**
**      NADDR generates a reference to a field of the controller data.
**      PADDR generates a reference to another part of the script.
**      RADDR generates a reference to a script processor register.
**      FADDR generates a reference to a script processor register
**              with offset.
**
**----------------------------------------------------------
*/

#define RELOC_SOFTC     0x40000000
#define RELOC_LABEL     0x50000000
#define RELOC_REGISTER  0x60000000
#if 0
#define RELOC_KVAR      0x70000000
#endif
#define RELOC_LABELH    0x80000000
#define RELOC_MASK      0xf0000000

#define NADDR(label)    (RELOC_SOFTC | offsetof(struct ncb, label))
#define PADDR(label)    (RELOC_LABEL | offsetof(struct script, label))
#define PADDRH(label)   (RELOC_LABELH | offsetof(struct scripth, label))
#define RADDR(label)    (RELOC_REGISTER | REG(label))
#define FADDR(label,ofs)(RELOC_REGISTER | ((REG(label))+(ofs)))
#if 0
#define KVAR(which)     (RELOC_KVAR | (which))
#endif

#if 0
#define SCRIPT_KVAR_JIFFIES     (0)
#define SCRIPT_KVAR_FIRST               SCRIPT_KVAR_JIFFIES