include/asm-ia64/sn/module.h

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1992 - 1997, 2000-2002 Silicon Graphics, Inc. All rights reserved.
   7  */
   8 #ifndef _ASM_IA64_SN_MODULE_H
   9 #define _ASM_IA64_SN_MODULE_H
  10
  11 #ifdef  __cplusplus
  12 extern "C" {
  13 #endif
  14
  15
  16 #include <linux/config.h>
  17 #include <asm/sn/systeminfo.h>
  18 #include <asm/sn/klconfig.h>
  19 #include <asm/sn/ksys/elsc.h>
  20
  21 #define MODULE_MAX                      128
  22 #define MODULE_MAX_NODES                2
  23 #define MODULE_HIST_CNT                 16
  24 #define MAX_MODULE_LEN                  16
  25
  26 /* Well-known module IDs */
  27 #define MODULE_UNKNOWN          (-2) /* initial value of klconfig brd_module */
  28 /* #define INVALID_MODULE       (-1) ** generic invalid moduleid_t (arch.h) */
  29 #define MODULE_NOT_SET          0    /* module ID not set in sys ctlrs. */
  30
  31 /* parameter for format_module_id() */
  32 #define MODULE_FORMAT_BRIEF     1
  33 #define MODULE_FORMAT_LONG      2
  34
  35
  36 #ifdef CONFIG_IA64_SGI_SN2
  37
  38 /*
  39  *      Module id format
  40  *
  41  *      31-16   Rack ID (encoded class, group, number - 16-bit unsigned int)
  42  *       15-8   Brick type (8-bit ascii character)
  43  *        7-0   Bay (brick position in rack (0-63) - 8-bit unsigned int)
  44  *
  45  */
  46
  47 /*
  48  * Macros for getting the brick type
  49  */
  50 #define MODULE_BTYPE_MASK       0xff00
  51 #define MODULE_BTYPE_SHFT       8
  52 #define MODULE_GET_BTYPE(_m)    (((_m) & MODULE_BTYPE_MASK) >> MODULE_BTYPE_SHFT)
  53 #define MODULE_BT_TO_CHAR(_b)   ((char)(_b))
  54 #define MODULE_GET_BTCHAR(_m)   (MODULE_BT_TO_CHAR(MODULE_GET_BTYPE(_m)))
  55
  56 /*
  57  * Macros for getting the rack ID.
  58  */
  59 #define MODULE_RACK_MASK        0xffff0000
  60 #define MODULE_RACK_SHFT        16
  61 #define MODULE_GET_RACK(_m)     (((_m) & MODULE_RACK_MASK) >> MODULE_RACK_SHFT)
  62
  63 /*
  64  * Macros for getting the brick position
  65  */
  66 #define MODULE_BPOS_MASK        0x00ff
  67 #define MODULE_BPOS_SHFT        0
  68 #define MODULE_GET_BPOS(_m)     (((_m) & MODULE_BPOS_MASK) >> MODULE_BPOS_SHFT)
  69
  70 /*
  71  * Macros for constructing moduleid_t's
  72  */
  73 #define RBT_TO_MODULE(_r, _b, _t) ((_r) << MODULE_RACK_SHFT | \
  74                                    (_b) << MODULE_BPOS_SHFT | \
  75                                    (_t) << MODULE_BTYPE_SHFT)
  76
  77 /*
  78  * Macros for encoding and decoding rack IDs
  79  * A rack number consists of three parts:
  80  *   class (0==CPU/mixed, 1==I/O), group, number
  81  *
  82  * Rack number is stored just as it is displayed on the screen:
  83  * a 3-decimal-digit number.
  84  */
  85 #define RACK_CLASS_DVDR         100
  86 #define RACK_GROUP_DVDR         10
  87 #define RACK_NUM_DVDR           1
  88
  89 #define RACK_CREATE_RACKID(_c, _g, _n)  ((_c) * RACK_CLASS_DVDR +       \
  90         (_g) * RACK_GROUP_DVDR + (_n) * RACK_NUM_DVDR)
  91
  92 #define RACK_GET_CLASS(_r)              ((_r) / RACK_CLASS_DVDR)
  93 #define RACK_GET_GROUP(_r)              (((_r) - RACK_GET_CLASS(_r) *   \
  94             RACK_CLASS_DVDR) / RACK_GROUP_DVDR)
  95 #define RACK_GET_NUM(_r)                (((_r) - RACK_GET_CLASS(_r) *   \
  96             RACK_CLASS_DVDR - RACK_GET_GROUP(_r) *      \
  97             RACK_GROUP_DVDR) / RACK_NUM_DVDR)
  98
  99 /*
 100  * Macros for encoding and decoding rack IDs
 101  * A rack number consists of three parts:
 102  *   class      1 bit, 0==CPU/mixed, 1==I/O
 103  *   group      2 bits for CPU/mixed, 3 bits for I/O
 104  *   number     3 bits for CPU/mixed, 2 bits for I/O (1 based)
 105  */
 106 #define RACK_GROUP_BITS(_r)     (RACK_GET_CLASS(_r) ? 3 : 2)
 107 #define RACK_NUM_BITS(_r)       (RACK_GET_CLASS(_r) ? 2 : 3)
 108
 109 #define RACK_CLASS_MASK(_r)     0x20
 110 #define RACK_CLASS_SHFT(_r)     5
 111 #define RACK_ADD_CLASS(_r, _c)  \
 112         ((_r) |= (_c) << RACK_CLASS_SHFT(_r) & RACK_CLASS_MASK(_r))
 113
 114 #define RACK_GROUP_SHFT(_r)     RACK_NUM_BITS(_r)
 115 #define RACK_GROUP_MASK(_r)     \
 116         ( (((unsigned)1<<RACK_GROUP_BITS(_r)) - 1) << RACK_GROUP_SHFT(_r) )
 117 #define RACK_ADD_GROUP(_r, _g)  \
 118         ((_r) |= (_g) << RACK_GROUP_SHFT(_r) & RACK_GROUP_MASK(_r))
 119
 120 #define RACK_NUM_SHFT(_r)       0
 121 #define RACK_NUM_MASK(_r)       \
 122         ( (((unsigned)1<<RACK_NUM_BITS(_r)) - 1) << RACK_NUM_SHFT(_r) )
 123 #define RACK_ADD_NUM(_r, _n)    \
 124         ((_r) |= ((_n) - 1) << RACK_NUM_SHFT(_r) & RACK_NUM_MASK(_r))
 125
 126
 127 /*
 128  * Brick type definitions
 129  */
 130 #define MAX_BRICK_TYPES         256 /* brick type is stored as uchar */
 131
 132 extern char brick_types[];
 133
 134 #define MODULE_CBRICK           0
 135 #define MODULE_RBRICK           1
 136 #define MODULE_IBRICK           2
 137 #define MODULE_KBRICK           3
 138 #define MODULE_XBRICK           4
 139 #define MODULE_DBRICK           5
 140 #define MODULE_PBRICK           6
 141 #define MODULE_NBRICK           7
 142 #define MODULE_PEBRICK          8
 143 #define MODULE_PXBRICK          9
 144
 145 /*
 146  * Moduleid_t comparison macros
 147  */
 148 /* Don't compare the brick type:  only the position is significant */
 149 #define MODULE_CMP(_m1, _m2)    (((_m1)&(MODULE_RACK_MASK|MODULE_BPOS_MASK)) -\
 150                                  ((_m2)&(MODULE_RACK_MASK|MODULE_BPOS_MASK)))
 151 #define MODULE_MATCH(_m1, _m2)  (MODULE_CMP((_m1),(_m2)) == 0)
 152
 153
 154 #else
 155 #if defined(CONFIG_IA64_SGI_SN1) || defined(CONFIG_IA64_GENERIC)
 156
 157 /*
 158  *      Module id format
 159  *
 160  *        15-12 Brick type (enumerated)
 161  *         11-6 Rack ID (encoded class, group, number)
 162  *          5-0 Brick position in rack (0-63)
 163  */
 164 /*
 165  * Macros for getting the brick type
 166  */
 167 #define MODULE_BTYPE_MASK       0xf000
 168 #define MODULE_BTYPE_SHFT       12
 169 #define MODULE_GET_BTYPE(_m)    (((_m) & MODULE_BTYPE_MASK) >> MODULE_BTYPE_SHFT)
 170 #define MODULE_BT_TO_CHAR(_b)   (brick_types[(_b)])
 171 #define MODULE_GET_BTCHAR(_m)   (MODULE_BT_TO_CHAR(MODULE_GET_BTYPE(_m)))
 172
 173 /*
 174  * Macros for getting the rack ID.
 175  */
 176 #define MODULE_RACK_MASK        0x0fc0
 177 #define MODULE_RACK_SHFT        6
 178 #define MODULE_GET_RACK(_m)     (((_m) & MODULE_RACK_MASK) >> MODULE_RACK_SHFT)
 179
 180 /*
 181  * Macros for getting the brick position
 182  */
 183 #define MODULE_BPOS_MASK        0x003f
 184 #define MODULE_BPOS_SHFT        0
 185 #define MODULE_GET_BPOS(_m)     (((_m) & MODULE_BPOS_MASK) >> MODULE_BPOS_SHFT)
 186
 187 /*
 188  * Macros for constructing moduleid_t's
 189  */
 190 #define RBT_TO_MODULE(_r, _b, _t) ((_r) << MODULE_RACK_SHFT | \
 191                                    (_b) << MODULE_BPOS_SHFT | \
 192                                    (_t) << MODULE_BTYPE_SHFT)
 193
 194 /*
 195  * Macros for encoding and decoding rack IDs
 196  * A rack number consists of three parts:
 197  *   class      1 bit, 0==CPU/mixed, 1==I/O
 198  *   group      2 bits for CPU/mixed, 3 bits for I/O
 199  *   number     3 bits for CPU/mixed, 2 bits for I/O (1 based)
 200  */
 201 #define RACK_GROUP_BITS(_r)     (RACK_GET_CLASS(_r) ? 3 : 2)
 202 #define RACK_NUM_BITS(_r)       (RACK_GET_CLASS(_r) ? 2 : 3)
 203
 204 #define RACK_CLASS_MASK(_r)     0x20
 205 #define RACK_CLASS_SHFT(_r)     5
 206 #define RACK_GET_CLASS(_r)      \
 207         (((_r) & RACK_CLASS_MASK(_r)) >> RACK_CLASS_SHFT(_r))
 208 #define RACK_ADD_CLASS(_r, _c)  \
 209         ((_r) |= (_c) << RACK_CLASS_SHFT(_r) & RACK_CLASS_MASK(_r))
 210
 211 #define RACK_GROUP_SHFT(_r)     RACK_NUM_BITS(_r)
 212 #define RACK_GROUP_MASK(_r)     \
 213         ( (((unsigned)1<<RACK_GROUP_BITS(_r)) - 1) << RACK_GROUP_SHFT(_r) )
 214 #define RACK_GET_GROUP(_r)      \
 215         (((_r) & RACK_GROUP_MASK(_r)) >> RACK_GROUP_SHFT(_r))
 216 #define RACK_ADD_GROUP(_r, _g)  \
 217         ((_r) |= (_g) << RACK_GROUP_SHFT(_r) & RACK_GROUP_MASK(_r))
 218
 219 #define RACK_NUM_SHFT(_r)       0
 220 #define RACK_NUM_MASK(_r)       \
 221         ( (((unsigned)1<<RACK_NUM_BITS(_r)) - 1) << RACK_NUM_SHFT(_r) )
 222 #define RACK_GET_NUM(_r)        \
 223         ( (((_r) & RACK_NUM_MASK(_r)) >> RACK_NUM_SHFT(_r)) + 1 )
 224 #define RACK_ADD_NUM(_r, _n)    \
 225         ((_r) |= ((_n) - 1) << RACK_NUM_SHFT(_r) & RACK_NUM_MASK(_r))
 226
 227 /*
 228  * Brick type definitions
 229  */
 230 #define MAX_BRICK_TYPES         16 /* 1 << (MODULE_RACK_SHFT - MODULE_BTYPE_SHFT */
 231
 232 extern char brick_types[];
 233
 234 #define MODULE_CBRICK           0
 235 #define MODULE_RBRICK           1
 236 #define MODULE_IBRICK           2
 237 #define MODULE_KBRICK           3
 238 #define MODULE_XBRICK           4
 239 #define MODULE_DBRICK           5
 240 #define MODULE_PBRICK           6
 241 #define MODULE_NBRICK           7
 242 #define MODULE_PEBRICK          8
 243 #define MODULE_PXBRICK          9
 244
 245 /*
 246  * Moduleid_t comparison macros
 247  */
 248 /* Don't compare the brick type:  only the position is significant */
 249 #define MODULE_CMP(_m1, _m2)    (((_m1)&(MODULE_RACK_MASK|MODULE_BPOS_MASK)) -\
 250                                  ((_m2)&(MODULE_RACK_MASK|MODULE_BPOS_MASK)))
 251 #define MODULE_MATCH(_m1, _m2)  (MODULE_CMP((_m1),(_m2)) == 0)
 252
 253 #else
 254
 255 /*
 256  * Some code that uses this macro will not be conditionally compiled.
 257  */
 258 #define MODULE_GET_BTCHAR(_m)   ('?')
 259 #define MODULE_CMP(_m1, _m2)    ((_m1) - (_m2))
 260 #define MODULE_MATCH(_m1, _m2)  (MODULE_CMP((_m1),(_m2)) == 0)
 261
 262 #endif /* SN1 */
 263 #endif /* SN2 */
 264
 265 typedef struct module_s module_t;
 266
 267 struct module_s {
 268     moduleid_t          id;             /* Module ID of this module        */
 269
 270     spinlock_t          lock;           /* Lock for this structure         */
 271
 272     /* List of nodes in this module */
 273     cnodeid_t           nodes[MODULE_MAX_NODES];
 274 #ifdef CONFIG_IA64_SGI_SN2
 275     geoid_t             geoid[MODULE_MAX_NODES];
 276     struct {
 277                 char    moduleid[8];
 278     } io[MODULE_MAX_NODES];
 279 #endif
 280     int                 nodecnt;        /* Number of nodes in array        */
 281
 282     /* Fields for Module System Controller */
 283     int                 mesgpend;       /* Message pending                 */
 284     int                 shutdown;       /* Shutdown in progress            */
 285     struct semaphore    thdcnt;         /* Threads finished counter        */
 286
 287 #ifdef CONFIG_IA64_SGI_SN1
 288     elsc_t              elsc;
 289     spinlock_t          elsclock;
 290 #endif
 291     time_t              intrhist[MODULE_HIST_CNT];
 292     int                 histptr;
 293
 294     int                 hbt_active;     /* MSC heartbeat monitor active    */
 295     uint64_t            hbt_last;       /* RTC when last heartbeat sent    */
 296
 297     /* Module serial number info */
 298     union {
 299         char            snum_str[MAX_SERIAL_NUM_SIZE];   /* used by CONFIG_SGI_IP27    */
 300         uint64_t        snum_int;                        /* used by speedo */
 301     } snum;
 302     int                 snum_valid;
 303
 304     int                 disable_alert;
 305     int                 count_down;
 306
 307     /* System serial number info (used by SN1) */
 308     char                sys_snum[MAX_SERIAL_NUM_SIZE];
 309     int                 sys_snum_valid;
 310 };
 311
 312 /* module.c */
 313 extern module_t        *modules[MODULE_MAX];    /* Indexed by cmoduleid_t   */
 314 extern int              nummodules;
 315
 316 extern module_t        *module_lookup(moduleid_t id);
 317
 318 #if defined(CONFIG_IA64_SGI_SN1)
 319 extern elsc_t          *get_elsc(void);
 320 #endif
 321
 322 extern int              get_kmod_info(cmoduleid_t cmod,
 323                                       module_info_t *mod_info);
 324 extern int              get_kmod_sys_snum(cmoduleid_t cmod,
 325                                           char *snum);
 326
 327 extern void             format_module_id(char *buffer, moduleid_t m, int fmt);
 328 extern int              parse_module_id(char *buffer);
 329
 330 #ifdef  __cplusplus
 331 }
 332 #endif
 333
 334 #endif /* _ASM_IA64_SN_MODULE_H */