usr/src/uts/sun4u/sys/sbbcvar.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _SYS_SBBCVAR_H
  27 #define _SYS_SBBCVAR_H
  28
  29 #pragma ident   "%Z%%M% %I%     %E% SMI"
  30
  31 #ifdef  __cplusplus
  32 extern "C" {
  33 #endif
  34
  35 typedef struct sbbc_intr_map {
  36         uint32_t sbbc_phys_hi;
  37         uint32_t sbbc_phys_mid;
  38         uint32_t sbbc_phys_low;
  39         uint32_t sbbc_intr;
  40         uint32_t intr_ctlr_nodeid;
  41         uint32_t ino;
  42 }sbbc_intr_map_t;
  43
  44 struct sbbc_intr_map_mask {
  45         uint32_t sbbc_phys_hi;
  46         uint32_t sbbc_phys_mid;
  47         uint32_t sbbc_phys_low;
  48         uint32_t sbbc_intr;
  49 };
  50
  51 /* sbbc intrspec for initializing its children. */
  52 struct sbbc_intrspec {
  53         struct intrspec intr_spec;
  54         dev_info_t *dip;                /* Interrupt parent dip */
  55         uint32_t intr;                  /* for lookup */
  56 };
  57
  58 /*
  59  * definition of sbbc child reg spec entry:
  60  */
  61 typedef struct {
  62         uint32_t addr_hi;
  63         uint32_t addr_low;
  64         uint32_t size;
  65 } sbbc_child_regspec_t;
  66
  67 /* SBBC range entry */
  68 typedef struct sbbc_pci_rangespec {
  69         uint32_t sbbc_phys_hi;          /* Child hi range address */
  70         uint32_t sbbc_phys_low;         /* Child low range address */
  71         uint32_t pci_phys_hi;           /* Parent hi rng addr */
  72         uint32_t pci_phys_mid;          /* Parent mid rng addr */
  73         uint32_t pci_phys_low;          /* Parent low rng addr */
  74         uint32_t rng_size;              /* Range size */
  75 } sbbc_pci_rangespec_t;
  76
  77 typedef int procid_t;
  78
  79 /* Max. SBBC devices/children */
  80 #define MAX_SBBC_DEVICES        3
  81
  82 /* Only used for fixed or legacy interrupts */
  83 #define SBBC_INTR_STATE_DISABLE 0       /* disabled */
  84 #define SBBC_INTR_STATE_ENABLE  1       /* enabled */
  85
  86 typedef struct sbbc_child_intr {
  87         char *name;
  88         uint_t inum;
  89         uint_t status;
  90         uint_t (*intr_handler)();
  91         caddr_t arg1;
  92         caddr_t arg2;
  93 } sbbc_child_intr_t;
  94
  95 typedef struct sbbcsoft {
  96         int instance;
  97         int oflag;
  98         uint_t myinumber;
  99         dev_info_t *dip;                        /* device information */
 100         pci_regspec_t *reg;
 101         int nreg;
 102         sbbc_pci_rangespec_t *rangep;
 103         int range_cnt;
 104         int range_len;
 105         struct sbbc_regs_map *pci_sbbc_map;     /* SBBC Internal Registers */
 106         ddi_acc_handle_t pci_sbbc_map_handle;
 107         ddi_iblock_cookie_t sbbc_iblock_cookie; /* interrupt block cookie */
 108         kmutex_t sbbc_intr_mutex;               /* lock for interrupts */
 109         sbbc_child_intr_t *child_intr[MAX_SBBC_DEVICES]; /* intr per device */
 110         boolean_t suspended;                    /* TRUE if driver suspended */
 111         kmutex_t umutex;                        /* lock for this structure */
 112 } sbbcsoft_t;
 113
 114 #define TRUE            1
 115 #define FALSE           0
 116
 117
 118 #if defined(DEBUG)
 119
 120 #define SBBC_DBG_ATTACH         0x1
 121 #define SBBC_DBG_DETACH         0x2
 122 #define SBBC_DBG_CTLOPS         0x4
 123 #define SBBC_DBG_INITCHILD      0x8
 124 #define SBBC_DBG_UNINITCHILD    0x10
 125 #define SBBC_DBG_BUSMAP         0x20
 126 #define SBBC_DBG_INTR           0x40
 127 #define SBBC_DBG_PCICONF        0x80
 128 #define SBBC_DBG_MAPRANGES      0x100
 129 #define SBBC_DBG_PROPERTIES     0x200
 130 #define SBBC_DBG_OPEN           0x400
 131 #define SBBC_DBG_CLOSE          0x800
 132 #define SBBC_DBG_IOCTL          0x1000
 133 #define SBBC_DBG_INTROPS        0x2000
 134
 135
 136 #define SBBC_DBG0(flag, dip, fmt) \
 137         sbbc_dbg(flag, dip, fmt, 0, 0, 0, 0, 0);
 138 #define SBBC_DBG1(flag, dip, fmt, a1) \
 139         sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), 0, 0, 0, 0);
 140 #define SBBC_DBG2(flag, dip, fmt, a1, a2) \
 141         sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), 0, 0, 0);
 142 #define SBBC_DBG3(flag, dip, fmt, a1, a2, a3) \
 143         sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), \
 144                 (uintptr_t)(a3), 0, 0);
 145 #define SBBC_DBG4(flag, dip, fmt, a1, a2, a3, a4) \
 146         sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), \
 147                 (uintptr_t)(a3), (uintptr_t)(a4), 0);
 148 #define SBBC_DBG5(flag, dip, fmt, a1, a2, a3, a4, a5) \
 149         sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), \
 150                 (uintptr_t)(a3), (uintptr_t)(a4), (uintptr_t)(a5));
 151
 152 #else /* DEBUG */
 153
 154 #define SBBC_DBG0(flag, dip, fmt)
 155 #define SBBC_DBG1(flag, dip, fmt, a1)
 156 #define SBBC_DBG2(flag, dip, fmt, a1, a2)
 157 #define SBBC_DBG3(flag, dip, fmt, a1, a2, a3)
 158 #define SBBC_DBG4(flag, dip, fmt, a1, a2, a3, a4)
 159 #define SBBC_DBG5(flag, dip, fmt, a1, a2, a3, a4, a5)
 160
 161 #endif /* DEBUG */
 162
 163 /* debugging flags */
 164 /*
 165  * To enable tracing, uncomment this line:
 166  * #define      SBBC_TRACE      1
 167  */
 168
 169 #if defined(SBBC_TRACE)
 170
 171 #ifndef NSBBCTRACE
 172 #define NSBBCTRACE      1024
 173 #endif
 174
 175 struct sbbctrace {
 176         int count;
 177         int function;           /* address of function */
 178         int trace_action;       /* descriptive 4 characters */
 179         int object;             /* object operated on */
 180 };
 181
 182 /*
 183  * For debugging, allocate space for the trace buffer
 184  */
 185
 186 extern struct sbbctrace sbbctrace_buffer[];
 187 extern struct sbbctrace *sbbctrace_ptr;
 188 extern int sbbctrace_count;
 189
 190 #define SBBCTRACEINIT() {                               \
 191         if (sbbctrace_ptr == NULL)              \
 192                 sbbctrace_ptr = sbbctrace_buffer; \
 193         }
 194
 195 #define LOCK_TRACE()    (uint_t)ddi_enter_critical()
 196 #define UNLOCK_TRACE(x) ddi_exit_critical((uint_t)x)
 197
 198 #define SBBCTRACE(func, act, obj) {             \
 199         int __s = LOCK_TRACE();                 \
 200         int *_p = &sbbctrace_ptr->count;        \
 201         *_p++ = ++sbbctrace_count;              \
 202         *_p++ = (int)(func);                    \
 203         *_p++ = (int)(act);                     \
 204         *_p++ = (int)(obj);                     \
 205         if ((struct sbbctrace *)(void *)_p >= &sbbctrace_buffer[NSBBCTRACE])\
 206                 sbbctrace_ptr = sbbctrace_buffer; \
 207         else                                    \
 208                 sbbctrace_ptr = (struct sbbctrace *)(void *)_p; \
 209         UNLOCK_TRACE(__s);                      \
 210         }
 211
 212 #else   /* !SBBC_TRACE */
 213
 214 /* If no tracing, define no-ops */
 215 #define SBBCTRACEINIT()
 216 #define SBBCTRACE(a, b, c)
 217
 218 #endif  /* !SBBC_TRACE */
 219
 220 #ifdef  __cplusplus
 221 }
 222 #endif
 223
 224 #endif  /* _SYS_SBBCVAR_H */