[SCSI] Merge sym53c8xx_comm.h and sym53c8xx_defs.h into ncr driver

When the sym1 driver was in the tree, it used to share various parts of
its infrastructure with the ncr driver.  Now it's gone, these files are
just an annoyance, so merge sym53c8xx_comm.h into ncr53c8xx.c and merge
sym53c8xx_defs.h into ncr53c8xx.h.

Signed-off-by: Matthew Wilcox <matthew@wil.cx>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

1 files changed, 733 insertions, 1 deletions

diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index 8e1c77c81f6c..32350707b940 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -131,7 +131,739 @@
 #define NAME53C                 "ncr53c"
 #define NAME53C8XX              "ncr53c8xx"
 
-#include "sym53c8xx_comm.h"
+
+/*==========================================================
+**
+**      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
+
+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 astraction, 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:
+                dma_unmap_sg(dev, cmd->buffer, cmd->use_sg,
+                                cmd->sc_data_direction);
+                break;
+        case 1:
+                dma_unmap_single(dev, cmd->__data_mapping,
+                                 cmd->request_bufflen,
+                                 cmd->sc_data_direction);
+                break;
+        }
+        cmd->__data_mapped = 0;
+}
+
+static u_long __map_scsi_single_data(struct device *dev, struct scsi_cmnd *cmd)
+{
+        dma_addr_t mapping;
+
+        if (cmd->request_bufflen == 0)
+                return 0;
+
+        mapping = dma_map_single(dev, cmd->request_buffer,
+                                 cmd->request_bufflen,
+                                 cmd->sc_data_direction);
+        cmd->__data_mapped = 1;
+        cmd->__data_mapping = mapping;
+
+        return mapping;
+}
+
+static int __map_scsi_sg_data(struct device *dev, struct scsi_cmnd *cmd)
+{
+        int use_sg;
+
+        if (cmd->use_sg == 0)
+                return 0;
+
+        use_sg = dma_map_sg(dev, cmd->buffer, cmd->use_sg,
+                        cmd->sc_data_direction);
+        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_single_data(np, cmd)   __map_scsi_single_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;
+
+#ifdef  SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
+static struct ncr_driver_setup
+        driver_safe_setup __initdata    = SCSI_NCR_DRIVER_SAFE_SETUP;
+#endif
+
+#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
+
+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 ';' */
+
+#ifdef MODULE
+#define ARG_SEP ' '
+#else
+#define ARG_SEP ','
+#endif
+
+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;
+}
+
+/*===================================================================
+**
+**      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;
+}
 
 
 /*==========================================================