sys/dev/netif/ray/if_rayvar.h

   1 /*
   2  * Copyright (C) 2000
   3  * Dr. Duncan McLennan Barclay, dmlb@ragnet.demon.co.uk.
   4  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the author nor the names of any co-contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY DUNCAN BARCLAY AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL DUNCAN BARCLAY OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD: src/sys/dev/ray/if_rayvar.h,v 1.12.2.4 2001/08/14 22:54:07 dmlb Exp $
  32  * $DragonFly: src/sys/dev/netif/ray/Attic/if_rayvar.h,v 1.2 2003/06/17 04:28:29 dillon Exp $
  33  *
  34  */
  35
  36 /*
  37  * Network parameters, used twice in softc to store what we want and what
  38  * we have.
  39  *
  40  * The current parameters are ONLY valid in a function called from the runq
  41  * and should not be accessed directly from ioctls.
  42  */
  43 struct ray_nw_param {
  44     struct ray_cmd_net  p_1;
  45     struct ray_net_params \
  46                         p_2;
  47     u_int8_t            np_ap_status;
  48     int                 np_promisc;     /* Promiscious mode status      */
  49     int                 np_framing;     /* Packet framing types         */
  50     int                 np_auth;        /* Authentication status        */
  51     int                 np_havenet;     /* True if we have a network    */
  52 };
  53 #define np_upd_param    p_1.c_upd_param
  54 #define np_bss_id       p_1.c_bss_id
  55 #define np_inited       p_1.c_inited
  56 #define np_def_txrate   p_1.c_def_txrate
  57 #define np_encrypt      p_1.c_encrypt
  58 #define np_net_type     p_2.p_net_type
  59 #define np_ssid         p_2.p_ssid
  60 #define np_priv_start   p_2.p_privacy_must_start
  61 #define np_priv_join    p_2.p_privacy_can_join
  62
  63 /*
  64  * One of these structures per allocated device
  65  */
  66 struct ray_softc {
  67
  68     device_t dev;                       /* Device */
  69     struct arpcom       arpcom;         /* Ethernet common              */
  70     struct callout_handle
  71                         tx_timerh;      /* Handle for tx timer  */
  72     struct callout_handle
  73                         com_timerh;     /* Handle for command timer     */
  74
  75     bus_space_tag_t     am_bst;         /* Bus space tag for attribute memory */
  76     bus_space_handle_t  am_bsh;         /* Bus space handle for attribute mem */
  77     int                 am_rid;         /* Resource id for attribute memory */
  78     struct resource*    am_res;         /* Resource for attribute memory */
  79     bus_space_tag_t     cm_bst;         /* Bus space tag for common memory */
  80     bus_space_handle_t  cm_bsh;         /* Bus space handle for common memory */
  81     int                 cm_rid;         /* Resource id for common memory */
  82     struct resource*    cm_res;         /* Resource for common memory */
  83     int                 irq_rid;        /* Resource id for irq */
  84     struct resource*    irq_res;        /* Resource for irq */
  85     void *              irq_handle;     /* Handle for irq handler */
  86
  87     u_int8_t            sc_ccsinuse[64];/* ccss' in use -- not for tx   */
  88     u_char              sc_gone;        /* 1 = Card bailed out          */
  89
  90     struct ray_ecf_startup_v5
  91                         sc_ecf_startup; /* Startup info from card       */
  92
  93     TAILQ_HEAD(ray_comq, ray_comq_entry)
  94                         sc_comq;        /* Command queue                */
  95
  96     struct ray_nw_param sc_c;           /* current network params       */
  97     struct ray_nw_param sc_d;           /* desired network params       */
  98
  99     int                 sc_checkcounters;
 100     u_int64_t           sc_rxoverflow;  /* Number of rx overflows       */
 101     u_int64_t           sc_rxcksum;     /* Number of checksum errors    */
 102     u_int64_t           sc_rxhcksum;    /* Number of header checksum errors */
 103     u_int8_t            sc_rxnoise;     /* Average receiver level       */
 104     struct ray_siglev   sc_siglevs[RAY_NSIGLEVRECS]; /* Antenna/levels  */
 105 };
 106
 107 #define sc_station_addr sc_ecf_startup.e_station_addr
 108 #define sc_version      sc_ecf_startup.e_fw_build_string
 109 #define sc_tibsize      sc_ecf_startup.e_tibsize
 110
 111 /*
 112  * Command queue definitions
 113  */
 114 typedef void (*ray_comqfn_t)(struct ray_softc *sc, struct ray_comq_entry *com);
 115 MALLOC_DECLARE(M_RAYCOM);
 116 MALLOC_DEFINE(M_RAYCOM, "raycom", "Raylink command queue entry");
 117 struct ray_comq_entry {
 118         TAILQ_ENTRY(ray_comq_entry) c_chain;    /* Tail queue.          */
 119         ray_comqfn_t    c_function;             /* Function to call */
 120         int             c_flags;                /* Flags                */
 121         u_int8_t        c_retval;               /* Return value         */
 122         void            *c_wakeup;              /* Sleeping on this     */
 123         size_t          c_ccs;                  /* CCS structure        */
 124         struct ray_nw_param
 125                         c_desired;              /* network settings     */
 126         struct ray_param_req
 127                         *c_pr;                  /* MIB report/update    */
 128         char            *c_mesg;
 129 };
 130
 131 /*
 132  * Macro's and constants
 133  */
 134 static int mib_info[RAY_MIB_MAX+1][3] = RAY_MIB_INFO;
 135
 136 /* Indirections for reading/writing memory - from NetBSD/if_ray.c */
 137 #ifndef offsetof
 138 #define offsetof(type, member) \
 139     ((size_t)(&((type *)0)->member))
 140 #endif /* offsetof */
 141
 142 #define ATTR_READ_1(sc, off) \
 143     ((u_int8_t)bus_space_read_1((sc)->am_bst, (sc)->am_bsh, (off)))
 144
 145 #define ATTR_WRITE_1(sc, off, val) \
 146     bus_space_write_1((sc)->am_bst, (sc)->am_bsh, (off), (val))
 147
 148 #define SRAM_READ_1(sc, off) \
 149     ((u_int8_t)bus_space_read_1((sc)->cm_bst, (sc)->cm_bsh, (off)))
 150
 151 #define SRAM_READ_REGION(sc, off, p, n) \
 152     bus_space_read_region_1((sc)->cm_bst, (sc)->cm_bsh, (off), (void *)(p), (n))
 153
 154 #define SRAM_READ_FIELD_1(sc, off, s, f) \
 155     SRAM_READ_1((sc), (off) + offsetof(struct s, f))
 156
 157 #define SRAM_READ_FIELD_2(sc, off, s, f)                        \
 158     ((((u_int16_t)SRAM_READ_1((sc), (off) + offsetof(struct s, f)) << 8) \
 159     |(SRAM_READ_1((sc), (off) + 1 + offsetof(struct s, f)))))
 160
 161 #define SRAM_READ_FIELD_N(sc, off, s, f, p, n)  \
 162     SRAM_READ_REGION((sc), (off) + offsetof(struct s, f), (p), (n))
 163
 164 #define SRAM_WRITE_1(sc, off, val)      \
 165     bus_space_write_1((sc)->cm_bst, (sc)->cm_bsh, (off), (val))
 166
 167 #define SRAM_WRITE_REGION(sc, off, p, n) \
 168     bus_space_write_region_1((sc)->cm_bst, (sc)->cm_bsh, (off), (void *)(p), (n))
 169
 170 #define SRAM_WRITE_FIELD_1(sc, off, s, f, v)    \
 171     SRAM_WRITE_1((sc), (off) + offsetof(struct s, f), (v))
 172
 173 #define SRAM_WRITE_FIELD_2(sc, off, s, f, v) do {       \
 174     SRAM_WRITE_1((sc), (off) + offsetof(struct s, f), (((v) >> 8 ) & 0xff)); \
 175     SRAM_WRITE_1((sc), (off) + 1 + offsetof(struct s, f), ((v) & 0xff)); \
 176 } while (0)
 177
 178 #define SRAM_WRITE_FIELD_N(sc, off, s, f, p, n) \
 179     SRAM_WRITE_REGION((sc), (off) + offsetof(struct s, f), (p), (n))
 180
 181 /* Framing types */
 182 /* XXX maybe better as part of the if structure? */
 183 #define RAY_FRAMING_ENCAPSULATION       0
 184 #define RAY_FRAMING_TRANSLATION         1
 185
 186 /* Authentication states */
 187 #define RAY_AUTH_UNAUTH         0
 188 #define RAY_AUTH_WAITING        1
 189 #define RAY_AUTH_AUTH           2
 190 #define RAY_AUTH_NEEDED         3
 191
 192 /* Flags for runq entries */
 193 #define RAY_COM_FWOK            0x0001          /* Wakeup on completion */
 194 #define RAY_COM_FRUNNING        0x0002          /* This one running     */
 195 #define RAY_COM_FCOMPLETED      0x0004          /* This one completed   */
 196 #define RAY_COM_FWAIT           0x0008          /* Do not run the queue */
 197 #define RAY_COM_FCHKRUNNING     0x0010          /* Check IFF_RUNNING    */
 198 #define RAY_COM_FDETACHED       0x0020          /* Card is gone         */
 199 #define RAY_COM_FWOKEN          0x0040          /* Woken by detach      */
 200 #define RAY_COM_FLAGS_PRINTFB   \
 201         "\020"                  \
 202         "\001WOK"               \
 203         "\002RUNNING"           \
 204         "\003COMPLETED"         \
 205         "\004WAIT"              \
 206         "\005CHKRUNNING"        \
 207         "\006DETACHED"
 208
 209 #define RAY_COM_NEEDS_TIMO(cmd) (               \
 210          (cmd == RAY_CMD_DOWNLOAD_PARAMS) ||    \
 211          (cmd == RAY_CMD_UPDATE_PARAMS) ||      \
 212          (cmd == RAY_CMD_UPDATE_MCAST)          \
 213         )
 214
 215 #ifndef RAY_COM_TIMEOUT
 216 #define RAY_COM_TIMEOUT         (hz / 2)
 217 #endif
 218
 219 #ifndef RAY_RESET_TIMEOUT
 220 #define RAY_RESET_TIMEOUT       (10 * hz)
 221 #endif
 222
 223 #ifndef RAY_TX_TIMEOUT
 224 #define RAY_TX_TIMEOUT          (hz / 2)
 225 #endif
 226
 227 #define RAY_CCS_FREE(sc, ccs) \
 228     SRAM_WRITE_FIELD_1((sc), (ccs), ray_cmd, c_status, RAY_CCS_STATUS_FREE)
 229
 230 #define RAY_ECF_READY(sc) \
 231     (!(ATTR_READ_1((sc), RAY_ECFIR) & RAY_ECFIR_IRQ))
 232
 233 #define RAY_ECF_START_CMD(sc)   ATTR_WRITE_1((sc), RAY_ECFIR, RAY_ECFIR_IRQ)
 234
 235 #define RAY_HCS_CLEAR_INTR(sc)  ATTR_WRITE_1((sc), RAY_HCSIR, 0)
 236
 237 #define RAY_HCS_INTR(sc)        (ATTR_READ_1((sc), RAY_HCSIR) & RAY_HCSIR_IRQ)
 238
 239 #define RAY_PANIC(sc, fmt, args...) do {                                \
 240     panic("ray%d: %s(%d) " fmt "\n", device_get_unit((sc)->dev),        \
 241         __FUNCTION__ , __LINE__ , ##args);                              \
 242 } while (0)
 243
 244 #define RAY_PRINTF(sc, fmt, args...) do {                               \
 245     device_printf((sc)->dev, "%s(%d) " fmt "\n",                        \
 246         __FUNCTION__ , __LINE__ , ##args);                              \
 247 } while (0)
 248
 249 #define RAY_COM_MALLOC(function, flags) \
 250     ray_com_malloc((function), (flags), __STRING(function));
 251
 252 #define RAY_COM_FREE(com, ncom) do {                                    \
 253     int i;                                                              \
 254     for (i = 0; i < ncom; i++)                                          \
 255             FREE(com[i], M_RAYCOM);                                     \
 256 } while (0)
 257
 258 /*
 259  * This macro handles adding commands to the runq and quickly
 260  * getting away when the card is detached. The macro returns
 261  * from the current function with ENXIO.
 262  */
 263 #define RAY_COM_RUNQ(sc, com, ncom, mesg, error) do {                   \
 264     (error) = ray_com_runq_add((sc), (com), (ncom), (mesg));            \
 265     if ((error) == ENXIO) {                                             \
 266             RAY_COM_FREE((com), (ncom));                                \
 267             return (error);                                             \
 268     } else if ((error) && ((error) != ENXIO))                           \
 269             RAY_PRINTF(sc, "got error from runq 0x%x", (error));        \
 270 } while (0)
 271
 272 /*
 273  * There are a number of entry points into the ray_init_xxx routines.
 274  * These can be classed into two types: a) those that happen as a result
 275  * of a change to the cards operating parameters (e.g. BSSID change), and
 276  * b) those that happen as a result of a change to the interface parameters
 277  * (e.g. a change to the IP address). The second set of entries need not
 278  * send a command to the card when the card is IFF_RUNNING. The
 279  * RAY_COM_FCHKRUNNING flags indicates when the RUNNING flag should be
 280  * checked, and this macro does the necessary check and command abort.
 281  */
 282 #define RAY_COM_CHKRUNNING(sc, com, ifp) do {                           \
 283     if (((com)->c_flags & RAY_COM_FCHKRUNNING) &&                       \
 284         ((ifp)->if_flags & IFF_RUNNING)) {                              \
 285             ray_com_runq_done(sc);                                      \
 286             return;                                                     \
 287 } } while (0)
 288
 289
 290
 291 #define RAY_COM_INIT(com, function, flags)      \
 292     ray_com_init((com), (function), (flags), __STRING(function));
 293
 294 #ifndef RAY_COM_CHECK
 295 #define RAY_COM_CHECK(sc, com)
 296 #endif /* RAY_COM_CHECK */
 297
 298 #ifndef RAY_MBUF_DUMP
 299 #define RAY_MBUF_DUMP(sc, mask, m, s)
 300 #endif /* RAY_MBUF_DUMP */
 301
 302 #ifndef RAY_RECERR
 303 #define RAY_RECERR(sc, fmt, args...) do {                               \
 304     struct ifnet *ifp = &(sc)->arpcom.ac_if;                            \
 305     if (ifp->if_flags & IFF_DEBUG) {                                    \
 306             device_printf((sc)->dev, "%s(%d) " fmt "\n",                \
 307                 __FUNCTION__ , __LINE__ , ##args);                      \
 308 } } while (0)
 309 #endif /* RAY_RECERR */
 310
 311 /* XXX this should be in CCSERR but don't work - probably need to use ##ifp->(iferrcounter)++;                                          \*/
 312 #ifndef RAY_CCSERR
 313 #define RAY_CCSERR(sc, status, iferrcounter) do {                       \
 314     struct ifnet *ifp = &(sc)->arpcom.ac_if;                            \
 315     char *ss[] = RAY_CCS_STATUS_STRINGS;                                \
 316     if ((status) != RAY_CCS_STATUS_COMPLETE) {                          \
 317         if (ifp->if_flags & IFF_DEBUG) {                                \
 318             device_printf((sc)->dev,                                    \
 319                 "%s(%d) ECF command completed with status %s\n",        \
 320                 __FUNCTION__ , __LINE__ , ss[(status)]);                \
 321 } } } while (0)
 322 #endif /* RAY_CCSERR */
 323
 324 #ifndef RAY_MAP_CM
 325 #define RAY_MAP_CM(sc)
 326 #endif /* RAY_MAP_CM */