Merge from vendor branch AWK:
[dragonfly.git] / 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 */