sys/dev/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$
  32  *
  33  */
  34
  35 /*
  36  * Network parameters, used twice in softc to store what we want and what
  37  * we have.
  38  *
  39  * The current parameters are ONLY valid in a function called from the runq
  40  * and should not be accessed directly from ioctls.
  41  */
  42 struct ray_nw_param {
  43     struct ray_cmd_net  p_1;
  44     struct ray_net_params \
  45                         p_2;
  46     u_int8_t            np_ap_status;
  47     int                 np_promisc;     /* Promiscious mode status      */
  48     int                 np_framing;     /* Packet framing types         */
  49     int                 np_auth;        /* Authentication status        */
  50     int                 np_havenet;     /* True if we have a network    */
  51 };
  52 #define np_upd_param    p_1.c_upd_param
  53 #define np_bss_id       p_1.c_bss_id
  54 #define np_inited       p_1.c_inited
  55 #define np_def_txrate   p_1.c_def_txrate
  56 #define np_encrypt      p_1.c_encrypt
  57 #define np_net_type     p_2.p_net_type
  58 #define np_ssid         p_2.p_ssid
  59 #define np_priv_start   p_2.p_privacy_must_start
  60 #define np_priv_join    p_2.p_privacy_can_join
  61
  62 /*
  63  * One of these structures per allocated device
  64  */
  65 struct ray_softc {
  66
  67     device_t dev;                       /* Device */
  68     struct ifnet        *ifp;           /* Ethernet common              */
  69     struct callout_handle
  70                         tx_timerh;      /* Handle for tx timer  */
  71     struct callout_handle
  72                         com_timerh;     /* Handle for command timer     */
  73
  74     bus_space_tag_t     am_bst;         /* Bus space tag for attribute memory */
  75     bus_space_handle_t  am_bsh;         /* Bus space handle for attribute mem */
  76     int                 am_rid;         /* Resource id for attribute memory */
  77     struct resource*    am_res;         /* Resource for attribute memory */
  78     bus_space_tag_t     cm_bst;         /* Bus space tag for common memory */
  79     bus_space_handle_t  cm_bsh;         /* Bus space handle for common memory */
  80     int                 cm_rid;         /* Resource id for common memory */
  81     struct resource*    cm_res;         /* Resource for common memory */
  82     int                 irq_rid;        /* Resource id for irq */
  83     struct resource*    irq_res;        /* Resource for irq */
  84     void *              irq_handle;     /* Handle for irq handler */
  85
  86     u_int8_t            sc_ccsinuse[64];/* ccss' in use -- not for tx   */
  87     u_char              sc_gone;        /* 1 = Card bailed out          */
  88
  89     struct ray_ecf_startup_v5
  90                         sc_ecf_startup; /* Startup info from card       */
  91
  92     TAILQ_HEAD(ray_comq, ray_comq_entry)
  93                         sc_comq;        /* Command queue                */
  94
  95     struct ray_nw_param sc_c;           /* current network params       */
  96     struct ray_nw_param sc_d;           /* desired network params       */
  97
  98     int                 sc_checkcounters;
  99     u_int64_t           sc_rxoverflow;  /* Number of rx overflows       */
 100     u_int64_t           sc_rxcksum;     /* Number of checksum errors    */
 101     u_int64_t           sc_rxhcksum;    /* Number of header checksum errors */
 102     u_int8_t            sc_rxnoise;     /* Average receiver level       */
 103     struct ray_siglev   sc_siglevs[RAY_NSIGLEVRECS]; /* Antenna/levels  */
 104 };
 105
 106 #define sc_station_addr sc_ecf_startup.e_station_addr
 107 #define sc_version      sc_ecf_startup.e_fw_build_string
 108 #define sc_tibsize      sc_ecf_startup.e_tibsize
 109
 110 /*
 111  * Command queue definitions
 112  */
 113 typedef void (*ray_comqfn_t)(struct ray_softc *sc, struct ray_comq_entry *com);
 114 struct ray_comq_entry {
 115         TAILQ_ENTRY(ray_comq_entry) c_chain;    /* Tail queue.          */
 116         ray_comqfn_t    c_function;             /* Function to call */
 117         int             c_flags;                /* Flags                */
 118         u_int8_t        c_retval;               /* Return value         */
 119         void            *c_wakeup;              /* Sleeping on this     */
 120         size_t          c_ccs;                  /* CCS structure        */
 121         struct ray_nw_param
 122                         c_desired;              /* network settings     */
 123         struct ray_param_req
 124                         *c_pr;                  /* MIB report/update    */
 125         char            *c_mesg;
 126 };
 127
 128 /*
 129  * Macro's and constants
 130  */
 131 static int mib_info[RAY_MIB_MAX+1][3] = RAY_MIB_INFO;
 132
 133 /* Indirections for reading/writing memory - from NetBSD/if_ray.c */
 134 #ifndef offsetof
 135 #define offsetof(type, member) \
 136     ((size_t)(&((type *)0)->member))
 137 #endif /* offsetof */
 138
 139 #define ATTR_READ_1(sc, off) \
 140     ((u_int8_t)bus_space_read_1((sc)->am_bst, (sc)->am_bsh, (off)))
 141
 142 #define ATTR_WRITE_1(sc, off, val) \
 143     bus_space_write_1((sc)->am_bst, (sc)->am_bsh, (off), (val))
 144
 145 #define SRAM_READ_1(sc, off) \
 146     ((u_int8_t)bus_space_read_1((sc)->cm_bst, (sc)->cm_bsh, (off)))
 147
 148 #define SRAM_READ_REGION(sc, off, p, n) \
 149     bus_space_read_region_1((sc)->cm_bst, (sc)->cm_bsh, (off), (void *)(p), (n))
 150
 151 #define SRAM_READ_FIELD_1(sc, off, s, f) \
 152     SRAM_READ_1((sc), (off) + offsetof(struct s, f))
 153
 154 #define SRAM_READ_FIELD_2(sc, off, s, f)                        \
 155     ((((u_int16_t)SRAM_READ_1((sc), (off) + offsetof(struct s, f)) << 8) \
 156     |(SRAM_READ_1((sc), (off) + 1 + offsetof(struct s, f)))))
 157
 158 #define SRAM_READ_FIELD_N(sc, off, s, f, p, n)  \
 159     SRAM_READ_REGION((sc), (off) + offsetof(struct s, f), (p), (n))
 160
 161 #define SRAM_WRITE_1(sc, off, val)      \
 162     bus_space_write_1((sc)->cm_bst, (sc)->cm_bsh, (off), (val))
 163
 164 #define SRAM_WRITE_REGION(sc, off, p, n) \
 165     bus_space_write_region_1((sc)->cm_bst, (sc)->cm_bsh, (off), (void *)(p), (n))
 166
 167 #define SRAM_WRITE_FIELD_1(sc, off, s, f, v)    \
 168     SRAM_WRITE_1((sc), (off) + offsetof(struct s, f), (v))
 169
 170 #define SRAM_WRITE_FIELD_2(sc, off, s, f, v) do {       \
 171     SRAM_WRITE_1((sc), (off) + offsetof(struct s, f), (((v) >> 8 ) & 0xff)); \
 172     SRAM_WRITE_1((sc), (off) + 1 + offsetof(struct s, f), ((v) & 0xff)); \
 173 } while (0)
 174
 175 #define SRAM_WRITE_FIELD_N(sc, off, s, f, p, n) \
 176     SRAM_WRITE_REGION((sc), (off) + offsetof(struct s, f), (p), (n))
 177
 178 /* Framing types */
 179 /* XXX maybe better as part of the if structure? */
 180 #define RAY_FRAMING_ENCAPSULATION       0
 181 #define RAY_FRAMING_TRANSLATION         1
 182
 183 /* Authentication states */
 184 #define RAY_AUTH_UNAUTH         0
 185 #define RAY_AUTH_WAITING        1
 186 #define RAY_AUTH_AUTH           2
 187 #define RAY_AUTH_NEEDED         3
 188
 189 /* Flags for runq entries */
 190 #define RAY_COM_FWOK            0x0001          /* Wakeup on completion */
 191 #define RAY_COM_FRUNNING        0x0002          /* This one running     */
 192 #define RAY_COM_FCOMPLETED      0x0004          /* This one completed   */
 193 #define RAY_COM_FWAIT           0x0008          /* Do not run the queue */
 194 #define RAY_COM_FCHKRUNNING     0x0010          /* Check IFF_DRV_RUNNING*/
 195 #define RAY_COM_FDETACHED       0x0020          /* Card is gone         */
 196 #define RAY_COM_FWOKEN          0x0040          /* Woken by detach      */
 197 #define RAY_COM_FLAGS_PRINTFB   \
 198         "\020"                  \
 199         "\001WOK"               \
 200         "\002RUNNING"           \
 201         "\003COMPLETED"         \
 202         "\004WAIT"              \
 203         "\005CHKRUNNING"        \
 204         "\006DETACHED"
 205
 206 #define RAY_COM_NEEDS_TIMO(cmd) (               \
 207          (cmd == RAY_CMD_DOWNLOAD_PARAMS) ||    \
 208          (cmd == RAY_CMD_UPDATE_PARAMS) ||      \
 209          (cmd == RAY_CMD_UPDATE_MCAST)          \
 210         )
 211
 212 #ifndef RAY_COM_TIMEOUT
 213 #define RAY_COM_TIMEOUT         (hz / 2)
 214 #endif
 215
 216 #ifndef RAY_RESET_TIMEOUT
 217 #define RAY_RESET_TIMEOUT       (10 * hz)
 218 #endif
 219
 220 #ifndef RAY_TX_TIMEOUT
 221 #define RAY_TX_TIMEOUT          (hz / 2)
 222 #endif
 223
 224 #define RAY_CCS_FREE(sc, ccs) \
 225     SRAM_WRITE_FIELD_1((sc), (ccs), ray_cmd, c_status, RAY_CCS_STATUS_FREE)
 226
 227 #define RAY_ECF_READY(sc) \
 228     (!(ATTR_READ_1((sc), RAY_ECFIR) & RAY_ECFIR_IRQ))
 229
 230 #define RAY_ECF_START_CMD(sc)   ATTR_WRITE_1((sc), RAY_ECFIR, RAY_ECFIR_IRQ)
 231
 232 #define RAY_HCS_CLEAR_INTR(sc)  ATTR_WRITE_1((sc), RAY_HCSIR, 0)
 233
 234 #define RAY_HCS_INTR(sc)        (ATTR_READ_1((sc), RAY_HCSIR) & RAY_HCSIR_IRQ)
 235
 236 #define RAY_PANIC(sc, fmt, args...) do {                                \
 237     panic("ray%d: %s(%d) " fmt "\n", device_get_unit((sc)->dev),        \
 238         __func__ , __LINE__ , ##args);                                  \
 239 } while (0)
 240
 241 #define RAY_PRINTF(sc, fmt, args...) do {                               \
 242     device_printf((sc)->dev, "%s(%d) " fmt "\n",                        \
 243         __func__ , __LINE__ , ##args);                                  \
 244 } while (0)
 245
 246 #define RAY_COM_MALLOC(function, flags) \
 247     ray_com_malloc((function), (flags), __STRING(function));
 248
 249 #define RAY_COM_FREE(com, ncom) do {                                    \
 250     int i;                                                              \
 251     for (i = 0; i < ncom; i++)                                          \
 252             FREE(com[i], M_RAYCOM);                                     \
 253 } while (0)
 254
 255 /*
 256  * This macro handles adding commands to the runq and quickly
 257  * getting away when the card is detached. The macro returns
 258  * from the current function with ENXIO.
 259  */
 260 #define RAY_COM_RUNQ(sc, com, ncom, mesg, error) do {                   \
 261     (error) = ray_com_runq_add((sc), (com), (ncom), (mesg));            \
 262     if ((error) == ENXIO) {                                             \
 263             RAY_COM_FREE((com), (ncom));                                \
 264             return (error);                                             \
 265     } else if ((error) && ((error) != ENXIO))                           \
 266             RAY_PRINTF(sc, "got error from runq 0x%x", (error));        \
 267 } while (0)
 268
 269 /*
 270  * There are a number of entry points into the ray_init_xxx routines.
 271  * These can be classed into two types: a) those that happen as a result
 272  * of a change to the cards operating parameters (e.g. BSSID change), and
 273  * b) those that happen as a result of a change to the interface parameters
 274  * (e.g. a change to the IP address). The second set of entries need not
 275  * send a command to the card when the card is IFF_DRV_RUNNING. The
 276  * RAY_COM_FCHKRUNNING flags indicates when the RUNNING flag should be
 277  * checked, and this macro does the necessary check and command abort.
 278  */
 279 #define RAY_COM_CHKRUNNING(sc, com, ifp) do {                           \
 280     if (((com)->c_flags & RAY_COM_FCHKRUNNING) &&                       \
 281         ((ifp)->if_drv_flags & IFF_DRV_RUNNING)) {                      \
 282             ray_com_runq_done(sc);                                      \
 283             return;                                                     \
 284 } } while (0)
 285
 286
 287
 288 #define RAY_COM_INIT(com, function, flags)      \
 289     ray_com_init((com), (function), (flags), __STRING(function));
 290
 291 #ifndef RAY_COM_CHECK
 292 #define RAY_COM_CHECK(sc, com)
 293 #endif /* RAY_COM_CHECK */
 294
 295 #ifndef RAY_MBUF_DUMP
 296 #define RAY_MBUF_DUMP(sc, mask, m, s)
 297 #endif /* RAY_MBUF_DUMP */
 298
 299 #ifndef RAY_RECERR
 300 #define RAY_RECERR(sc, fmt, args...) do {                               \
 301     struct ifnet *ifp = (sc)->ifp;                              \
 302     if (ifp->if_flags & IFF_DEBUG) {                                    \
 303             device_printf((sc)->dev, "%s(%d) " fmt "\n",                \
 304                 __func__ , __LINE__ , ##args);                          \
 305 } } while (0)
 306 #endif /* RAY_RECERR */
 307
 308 /* XXX this should be in CCSERR but don't work - probably need to use ##ifp->(iferrcounter)++;                                          \*/
 309 #ifndef RAY_CCSERR
 310 #define RAY_CCSERR(sc, status, iferrcounter) do {                       \
 311     struct ifnet *ifp = (sc)->ifp;                              \
 312     char *ss[] = RAY_CCS_STATUS_STRINGS;                                \
 313     if ((status) != RAY_CCS_STATUS_COMPLETE) {                          \
 314         if (ifp->if_flags & IFF_DEBUG) {                                \
 315             device_printf((sc)->dev,                                    \
 316                 "%s(%d) ECF command completed with status %s\n",        \
 317                 __func__ , __LINE__ , ss[(status)]);                    \
 318 } } } while (0)
 319 #endif /* RAY_CCSERR */
 320
 321 #ifndef RAY_MAP_CM
 322 #define RAY_MAP_CM(sc)
 323 #endif /* RAY_MAP_CM */
 324
 325 /*
 326  * Management information element payloads
 327  */
 328 union ieee80211_information {
 329         char    ssid[IEEE80211_NWID_LEN+1];
 330         struct rates {
 331                 u_int8_t        *p;
 332         } rates;
 333         struct fh {
 334                 u_int16_t       dwell;
 335                 u_int8_t        set;
 336                 u_int8_t        pattern;
 337                 u_int8_t        index;
 338         } fh;
 339         struct ds {
 340                 u_int8_t        channel;
 341         } ds;
 342         struct cf {
 343                 u_int8_t        count;
 344                 u_int8_t        period;
 345                 u_int8_t        maxdur[2];
 346                 u_int8_t        dur[2];
 347         } cf;
 348         struct tim {
 349                 u_int8_t        count;
 350                 u_int8_t        period;
 351                 u_int8_t        bitctl;
 352                 /* u_int8_t     pvt[251]; The driver needs to use this. */
 353         } tim;
 354         struct ibss {
 355                 u_int16_t       atim;
 356         } ibss;
 357         struct challenge {
 358                 u_int8_t        *p;
 359                 u_int8_t        len;
 360         } challenge;
 361 };