?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / sys / dev / pcmcia / if_ray.c
blob06a1e1a28ee21cfb0f74c97bb2a7f83fe49d5849
1 /* $NetBSD: if_ray.c,v 1.76 2009/09/05 14:44:59 tsutsui Exp $ */
2
3 /*
4 * Copyright (c) 2000 Christian E. Hopps
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 THE AUTHOR 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 THE AUTHOR 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
32 /*
33 * Driver for the Raylink (Raytheon) / WebGear IEEE 802.11 (FH) WLANs
34 *
35 * 2-way communication with the card is through command structures
36 * stored in shared ram. To communicate with the card a free
37 * command structure is filled in and then the card is interrupted.
38 * The card does the same with a different set of command structures.
39 * Only one command can be processed at a time. This is indicated
40 * by the interrupt having not been cleared since it was last set.
41 * The bit is cleared when the command has been processed (although
42 * it may not yet be complete).
43 *
44 * This driver was only tested with the Aviator 2.4 wireless
45 * The author didn't have the pro version or raylink to test
46 * with.
47 *
48 * N.B. Its unclear yet whether the Aviator 2.4 cards interoperate
49 * with other 802.11 FH 2Mbps cards, since this was also untested.
50 * Given the nature of the buggy build 4 firmware there may be problems.
51 *
52 * Authentication added by Steve Weiss <srw@alum.mit.edu> based on
53 * advice from Corey Thomas (author of the Linux RayLink driver).
54 * Authentication is currently limited to adhoc networks, and was
55 * added to support a requirement of the newest Windows drivers for
56 * the RayLink. Tested with Aviator Pro (firmware 5.63) on Win98.
57 */
58
59 #include <sys/cdefs.h>
60 __KERNEL_RCSID(0, "$NetBSD: if_ray.c,v 1.76 2009/09/05 14:44:59 tsutsui Exp $");
61
62 #include "opt_inet.h"
63 #include "bpfilter.h"
64
65 #include <sys/param.h>
66 #include <sys/systm.h>
67 #include <sys/callout.h>
68 #include <sys/mbuf.h>
69 #include <sys/socket.h>
70 #include <sys/ioctl.h>
71 #include <sys/errno.h>
72 #include <sys/device.h>
73 #include <sys/kernel.h>
74 #include <sys/proc.h>
75
76 #include <net/if.h>
77 #include <net/if_dl.h>
78 #include <net/if_ether.h>
79 #include <net/if_media.h>
80 #include <net/if_llc.h>
81 #include <net80211/ieee80211.h>
82 #include <net80211/ieee80211_ioctl.h>
83 #include <net/if_media.h>
84
85 #ifdef INET
86 #include <netinet/in.h>
87 #include <netinet/in_systm.h>
88 #include <netinet/in_var.h>
89 #include <netinet/ip.h>
90 #include <netinet/if_inarp.h>
91 #endif
92
93 #if NBPFILTER > 0
94 #include <net/bpf.h>
95 #include <net/bpfdesc.h>
96 #endif
97
98 #include <sys/cpu.h>
99 #include <sys/bus.h>
100 #include <sys/intr.h>
101
102 #include <dev/pcmcia/pcmciareg.h>
103 #include <dev/pcmcia/pcmciavar.h>
104 #include <dev/pcmcia/pcmciadevs.h>
105
106 #include <dev/pcmcia/if_rayreg.h>
107
108 #define RAY_DEBUG
109
110 #ifndef RAY_PID_COUNTRY_CODE_DEFAULT
111 #define RAY_PID_COUNTRY_CODE_DEFAULT RAY_PID_COUNTRY_CODE_USA
112 #endif
113
114 /* amount of time to poll for non-return of certain command status */
115 #ifndef RAY_CHECK_CCS_TIMEOUT
116 #define RAY_CHECK_CCS_TIMEOUT (hz / 2)
117 #endif
118
119 /* ammount of time to consider start/join failed */
120 #ifndef RAY_START_TIMEOUT
121 #define RAY_START_TIMEOUT (30 * hz)
122 #endif
123
124 /*
125 * if a command cannot execute because device is busy try later
126 * this is also done after interrupts and other command timeouts
127 * so we can use a large value safely.
128 */
129 #ifndef RAY_CHECK_SCHED_TIMEOUT
130 #define RAY_CHECK_SCHED_TIMEOUT (hz) /* XXX 5 */
131 #endif
132
133 #ifndef RAY_MODE_DEFAULT
134 #define RAY_MODE_DEFAULT SC_MODE_ADHOC
135 #endif
136
137 #ifndef RAY_DEF_NWID
138 #define RAY_DEF_NWID "NETWORK_NAME"
139 #endif
140
141 /*
142 * The number of times the HW is reset in 30s before disabling.
143 * This is needed because resets take ~2s and currently pcmcia
144 * spins for the reset.
145 */
146 #ifndef RAY_MAX_RESETS
147 #define RAY_MAX_RESETS 3
148 #endif
149
150 /*
151 * Types
152 */
153
154 struct ray_softc {
155 struct device sc_dev;
156 struct ethercom sc_ec;
157 struct ifmedia sc_media;
158
159 struct pcmcia_function *sc_pf;
160 void *sc_ih;
161 int sc_attached;
162
163 int sc_resetloop;
164
165 struct callout sc_check_ccs_ch;
166 struct callout sc_check_scheduled_ch;
167 struct callout sc_reset_resetloop_ch;
168 struct callout sc_disable_ch;
169 struct callout sc_start_join_timo_ch;
170
171 struct ray_ecf_startup sc_ecf_startup;
172 struct ray_startup_params_head sc_startup;
173 union {
174 struct ray_startup_params_tail_5 u_params_5;
175 struct ray_startup_params_tail_4 u_params_4;
176 } sc_u;
177
178 u_int8_t sc_ccsinuse[64]; /* ccs in use -- not for tx */
179 u_int sc_txfree; /* a free count for efficiency */
180
181 u_int8_t sc_bssid[ETHER_ADDR_LEN]; /* current net values */
182 u_int8_t sc_authid[ETHER_ADDR_LEN]; /* ID of authenticating
183 station */
184 struct ieee80211_nwid sc_cnwid; /* last nwid */
185 struct ieee80211_nwid sc_dnwid; /* desired nwid */
186 u_int8_t sc_omode; /* old operating mode SC_MODE_xx */
187 u_int8_t sc_mode; /* current operating mode SC_MODE_xx */
188 u_int8_t sc_countrycode; /* current country code */
189 u_int8_t sc_dcountrycode; /* desired country code */
190 int sc_havenet; /* true if we have acquired a network */
191 bus_size_t sc_txpad; /* tib size plus "phy" size */
192 u_int8_t sc_deftxrate; /* default transfer rate */
193 u_int8_t sc_encrypt;
194 u_int8_t sc_authstate; /* authentication state */
195
196 int sc_promisc; /* current set value */
197 int sc_running; /* things we are doing */
198 int sc_scheduled; /* things we need to do */
199 int sc_timoneed; /* set if timeout is sched */
200 int sc_timocheck; /* set if timeout is sched */
201 bus_size_t sc_startccs; /* ccs of start/join */
202 u_int sc_startcmd; /* cmd (start | join) */
203
204 int sc_checkcounters;
205 u_int64_t sc_rxoverflow;
206 u_int64_t sc_rxcksum;
207 u_int64_t sc_rxhcksum;
208 u_int8_t sc_rxnoise;
209
210 /* use to return values to the user */
211 struct ray_param_req *sc_repreq;
212 struct ray_param_req *sc_updreq;
213
214 bus_space_tag_t sc_memt;
215 bus_space_handle_t sc_memh;
216
217 #ifdef RAY_DO_SIGLEV
218 struct ray_siglev sc_siglevs[RAY_NSIGLEVRECS];
219 #endif
220 };
221 #define sc_ccrt sc_pf->pf_ccrt
222 #define sc_ccrh sc_pf->pf_ccrh
223 #define sc_ccroff sc_pf->pf_ccr_offset
224 #define sc_startup_4 sc_u.u_params_4
225 #define sc_startup_5 sc_u.u_params_5
226 #define sc_version sc_ecf_startup.e_fw_build_string
227 #define sc_tibsize sc_ecf_startup.e_tib_size
228 #define sc_if sc_ec.ec_if
229
230 /* modes of operation */
231 #define SC_MODE_ADHOC 0 /* ad-hoc mode */
232 #define SC_MODE_INFRA 1 /* infrastructure mode */
233
234 /* commands -- priority given to LSB */
235 #define SCP_FIRST 0x0001
236 #define SCP_UPDATESUBCMD 0x0001
237 #define SCP_STARTASSOC 0x0002
238 #define SCP_REPORTPARAMS 0x0004
239 #define SCP_IFSTART 0x0008
240
241 /* update sub commands -- issues are serialized priority to LSB */
242 #define SCP_UPD_FIRST 0x0100
243 #define SCP_UPD_STARTUP 0x0100
244 #define SCP_UPD_STARTJOIN 0x0200
245 #define SCP_UPD_PROMISC 0x0400
246 #define SCP_UPD_MCAST 0x0800
247 #define SCP_UPD_UPDATEPARAMS 0x1000
248 #define SCP_UPD_SHIFT 8
249 #define SCP_UPD_MASK 0xff00
250
251 /* these command (a subset of the update set) require timeout checking */
252 #define SCP_TIMOCHECK_CMD_MASK \
253 (SCP_UPD_UPDATEPARAMS | SCP_UPD_STARTUP | SCP_UPD_MCAST | \
254 SCP_UPD_PROMISC)
255
256
257 #define IFM_ADHOC \
258 IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_FH2, IFM_IEEE80211_ADHOC, 0)
259 #define IFM_INFRA \
260 IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_FH2, 0, 0)
261
262 typedef void (*ray_cmd_func_t)(struct ray_softc *);
263
264 #define SC_BUILD_5 0x5
265 #define SC_BUILD_4 0x55
266
267 /* sc_authstate */
268 #define RAY_AUTH_UNAUTH 0
269 #define RAY_AUTH_WAITING 1
270 #define RAY_AUTH_AUTH 2
271 #define RAY_AUTH_NEEDED 3
272
273 #define OPEN_AUTH_REQUEST 1
274 #define OPEN_AUTH_RESPONSE 2
275 #define BROADCAST_DEAUTH 0xc0
276
277 static int ray_alloc_ccs(struct ray_softc *, bus_size_t *, u_int, u_int);
278 static bus_size_t ray_fill_in_tx_ccs(struct ray_softc *, size_t,
279 u_int, u_int);
280 static int ray_validate_config(struct pcmcia_config_entry *);
281 static void ray_attach(device_t, device_t, void *);
282 static ray_cmd_func_t ray_ccs_done(struct ray_softc *, bus_size_t);
283 static void ray_check_ccs(void *);
284 static void ray_check_scheduled(void *);
285 static void ray_cmd_cancel(struct ray_softc *, int);
286 static void ray_cmd_schedule(struct ray_softc *, int);
287 static void ray_cmd_ran(struct ray_softc *, int);
288 static int ray_cmd_is_running(struct ray_softc *, int);
289 static int ray_cmd_is_scheduled(struct ray_softc *, int);
290 static void ray_cmd_done(struct ray_softc *, int);
291 static int ray_detach(device_t, int);
292 static int ray_activate(device_t, enum devact);
293 static void ray_disable(struct ray_softc *);
294 static void ray_download_params(struct ray_softc *);
295 static int ray_enable(struct ray_softc *);
296 static u_int ray_find_free_tx_ccs(struct ray_softc *, u_int);
297 static u_int8_t ray_free_ccs(struct ray_softc *, bus_size_t);
298 static void ray_free_ccs_chain(struct ray_softc *, u_int);
299 static void ray_if_start(struct ifnet *);
300 static void ray_if_stop(struct ifnet *, int);
301 static int ray_init(struct ray_softc *);
302 static int ray_intr(void *);
303 static void ray_intr_start(struct ray_softc *);
304 static int ray_ioctl(struct ifnet *, u_long, void *);
305 static int ray_issue_cmd(struct ray_softc *, bus_size_t, u_int);
306 static int ray_match(device_t, cfdata_t, void *);
307 static int ray_media_change(struct ifnet *);
308 static void ray_media_status(struct ifnet *, struct ifmediareq *);
309 static ray_cmd_func_t ray_rccs_intr(struct ray_softc *, bus_size_t);
310 static void ray_read_region(struct ray_softc *, bus_size_t,void *,size_t);
311 static void ray_recv(struct ray_softc *, bus_size_t);
312 static void ray_recv_auth(struct ray_softc *, struct ieee80211_frame *);
313 static void ray_report_params(struct ray_softc *);
314 static void ray_reset(struct ray_softc *);
315 static void ray_reset_resetloop(void *);
316 static int ray_send_auth(struct ray_softc *, u_int8_t *, u_int8_t);
317 static void ray_set_pending(struct ray_softc *, u_int);
318 static int ray_simple_cmd(struct ray_softc *, u_int, u_int);
319 static void ray_start_assoc(struct ray_softc *);
320 static void ray_start_join_net(struct ray_softc *);
321 static ray_cmd_func_t ray_start_join_net_done(struct ray_softc *,
322 u_int, bus_size_t, u_int);
323 static void ray_start_join_timo(void *);
324 static void ray_stop(struct ray_softc *);
325 static void ray_update_error_counters(struct ray_softc *);
326 static void ray_update_mcast(struct ray_softc *);
327 static ray_cmd_func_t ray_update_params_done(struct ray_softc *,
328 bus_size_t, u_int);
329 static void ray_update_params(struct ray_softc *);
330 static void ray_update_promisc(struct ray_softc *);
331 static void ray_update_subcmd(struct ray_softc *);
332 static int ray_user_report_params(struct ray_softc *,
333 struct ray_param_req *);
334 static int ray_user_update_params(struct ray_softc *,
335 struct ray_param_req *);
336 static void ray_write_region(struct ray_softc *,bus_size_t,void *,size_t);
337
338 #ifdef RAY_DO_SIGLEV
339 static void ray_update_siglev(struct ray_softc *, u_int8_t *, u_int8_t);
340 #endif
341
342 #ifdef RAY_DEBUG
343 static int ray_debug = 0;
344 static int ray_debug_xmit_sum = 0;
345 static int ray_debug_dump_desc = 0;
346 static int ray_debug_dump_rx = 0;
347 static int ray_debug_dump_tx = 0;
348 static struct timeval rtv, tv1, tv2, *ttp, *ltp;
349 #define RAY_DPRINTF(x) do { if (ray_debug) { \
350 struct timeval *ttmp; \
351 microtime(ttp); \
352 timersub(ttp, ltp, &rtv); \
353 ttmp = ttp; ttp = ltp; ltp = ttmp; \
354 printf("%ld:%ld %ld:%06ld: ", \
355 (long int)ttp->tv_sec, \
356 (long int)ttp->tv_usec, \
357 (long int)rtv.tv_sec, \
358 (long int)rtv.tv_usec); \
359 printf x ; \
360 } } while (0)
361 #define RAY_DPRINTF_XMIT(x) do { if (ray_debug_xmit_sum) { \
362 struct timeval *ttmp; \
363 microtime(ttp); \
364 timersub(ttp, ltp, &rtv); \
365 ttmp = ttp; ttp = ltp; ltp = ttmp; \
366 printf("%ld:%ld %ld:%06ld: ", \
367 (long int)ttp->tv_sec, \
368 (long int)ttp->tv_usec, \
369 (long int)rtv.tv_sec, \
370 (long int)rtv.tv_usec); \
371 printf x ; \
372 } } while (0)
373
374 #define HEXDF_NOCOMPRESS 0x1
375 #define HEXDF_NOOFFSET 0x2
376 #define HEXDF_NOASCII 0x4
377 void hexdump(const u_int8_t *, int, int, int, int);
378 static void ray_dump_mbuf(struct ray_softc *, struct mbuf *);
379
380 #else /* !RAY_DEBUG */
381
382 #define RAY_DPRINTF(x)
383 #define RAY_DPRINTF_XMIT(x)
384
385 #endif /* !RAY_DEBUG */
386
387 /*
388 * macros for writing to various regions in the mapped memory space
389 */
390
391 /* use already mapped ccrt */
392 #define REG_WRITE(sc, off, val) \
393 bus_space_write_1((sc)->sc_ccrt, (sc)->sc_ccrh, ((sc)->sc_ccroff + (off)), (val))
394
395 #define REG_READ(sc, off) \
396 bus_space_read_1((sc)->sc_ccrt, (sc)->sc_ccrh, ((sc)->sc_ccroff + (off)))
397
398 #define SRAM_READ_1(sc, off) \
399 ((u_int8_t)bus_space_read_1((sc)->sc_memt, (sc)->sc_memh, (off)))
400
401 #define SRAM_READ_FIELD_1(sc, off, s, f) \
402 SRAM_READ_1(sc, (off) + offsetof(struct s, f))
403
404 #define SRAM_READ_FIELD_2(sc, off, s, f) \
405 ((((u_int16_t)SRAM_READ_1(sc, (off) + offsetof(struct s, f)) << 8) \
406 |(SRAM_READ_1(sc, (off) + 1 + offsetof(struct s, f)))))
407
408 #define SRAM_READ_FIELD_N(sc, off, s, f, p, n) \
409 ray_read_region(sc, (off) + offsetof(struct s, f), (p), (n))
410
411 #define SRAM_WRITE_1(sc, off, val) \
412 bus_space_write_1((sc)->sc_memt, (sc)->sc_memh, (off), (val))
413
414 #define SRAM_WRITE_FIELD_1(sc, off, s, f, v) \
415 SRAM_WRITE_1(sc, (off) + offsetof(struct s, f), (v))
416
417 #define SRAM_WRITE_FIELD_2(sc, off, s, f, v) do { \
418 SRAM_WRITE_1(sc, (off) + offsetof(struct s, f), (((v) >> 8 ) & 0xff)); \
419 SRAM_WRITE_1(sc, (off) + 1 + offsetof(struct s, f), ((v) & 0xff)); \
420 } while (0)
421
422 #define SRAM_WRITE_FIELD_N(sc, off, s, f, p, n) \
423 ray_write_region(sc, (off) + offsetof(struct s, f), (p), (n))
424
425 /*
426 * Macros of general usefulness
427 */
428
429 #define M_PULLUP(m, s) do { \
430 if ((m)->m_len < (s)) \
431 (m) = m_pullup((m), (s)); \
432 } while (0)
433
434 #define RAY_ECF_READY(sc) (!(REG_READ(sc, RAY_ECFIR) & RAY_ECSIR_IRQ))
435 #define RAY_ECF_START_CMD(sc) REG_WRITE(sc, RAY_ECFIR, RAY_ECSIR_IRQ)
436 #define RAY_GET_INDEX(ccs) (((ccs) - RAY_CCS_BASE) / RAY_CCS_SIZE)
437 #define RAY_GET_CCS(i) (RAY_CCS_BASE + (i) * RAY_CCS_SIZE)
438
439 /*
440 * Globals
441 */
442
443 static u_int8_t llc_snapid[6] = { LLC_SNAP_LSAP, LLC_SNAP_LSAP, LLC_UI, };
444
445 /* based on bit index in SCP_xx */
446 static ray_cmd_func_t ray_cmdtab[] = {
447 ray_update_subcmd, /* SCP_UPDATESUBCMD */
448 ray_start_assoc, /* SCP_STARTASSOC */
449 ray_report_params, /* SCP_REPORTPARAMS */
450 ray_intr_start /* SCP_IFSTART */
451 };
452 static int ray_ncmdtab = sizeof(ray_cmdtab) / sizeof(*ray_cmdtab);
453
454 static ray_cmd_func_t ray_subcmdtab[] = {
455 ray_download_params, /* SCP_UPD_STARTUP */
456 ray_start_join_net, /* SCP_UPD_STARTJOIN */
457 ray_update_promisc, /* SCP_UPD_PROMISC */
458 ray_update_mcast, /* SCP_UPD_MCAST */
459 ray_update_params /* SCP_UPD_UPDATEPARAMS */
460 };
461 static int ray_nsubcmdtab = sizeof(ray_subcmdtab) / sizeof(*ray_subcmdtab);
462
463 /* autoconf information */
464 CFATTACH_DECL(ray, sizeof(struct ray_softc),
465 ray_match, ray_attach, ray_detach, ray_activate);
466
467 /*
468 * Config Routines
469 */
470
471 static int
472 ray_match(device_t parent, cfdata_t match,
473 void *aux)
474 {
475 struct pcmcia_attach_args *pa = aux;
476
477 #ifdef RAY_DEBUG
478 if (!ltp) {
479 /* initialize timestamp XXX */
480 ttp = &tv1;
481 ltp = &tv2;
482 microtime(ltp);
483 }
484 #endif
485 return (pa->manufacturer == PCMCIA_VENDOR_RAYTHEON
486 && pa->product == PCMCIA_PRODUCT_RAYTHEON_WLAN);
487 }
488
489 static int
490 ray_validate_config(struct pcmcia_config_entry *cfe)
491 {
492 if (cfe->iftype != PCMCIA_IFTYPE_IO ||
493 cfe->num_memspace != 1 ||
494 cfe->num_iospace != 0 ||
495 cfe->memspace[0].length != RAY_SRAM_MEM_SIZE)
496 return (EINVAL);
497 return (0);
498 }
499
500 static void
501 ray_attach(device_t parent, device_t self, void *aux)
502 {
503 struct ray_softc *sc = (void *)self;
504 struct pcmcia_attach_args *pa = aux;
505 struct ifnet *ifp = &sc->sc_if;
506 struct pcmcia_config_entry *cfe;
507 struct ray_ecf_startup *ep;
508 int error;
509
510 sc->sc_pf = pa->pf;
511
512 /*XXXmem8|common*/
513 error = pcmcia_function_configure(pa->pf, ray_validate_config);
514 if (error) {
515 aprint_error_dev(self, "configure failed, error=%d\n",
516 error);
517 return;
518 }
519
520 cfe = pa->pf->cfe;
521 sc->sc_memt = cfe->memspace[0].handle.memt;
522 sc->sc_memh = cfe->memspace[0].handle.memh;
523
524 callout_init(&sc->sc_reset_resetloop_ch, 0);
525 callout_init(&sc->sc_disable_ch, 0);
526 callout_init(&sc->sc_start_join_timo_ch, 0);
527
528 error = ray_enable(sc);
529 if (error)
530 goto fail;
531
532 /* get startup results */
533 ep = &sc->sc_ecf_startup;
534 ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep,
535 sizeof(sc->sc_ecf_startup));
536
537 /* check to see that card initialized properly */
538 if (ep->e_status != RAY_ECFS_CARD_OK) {
539 aprint_error_dev(self, "card failed self test: status %d\n",
540 sc->sc_ecf_startup.e_status);
541 goto fail2;
542 }
543
544 /* check firmware version */
545 if (sc->sc_version != SC_BUILD_4 && sc->sc_version != SC_BUILD_5) {
546 aprint_error_dev(self, "unsupported firmware version %d\n",
547 ep->e_fw_build_string);
548 goto fail2;
549 }
550
551 /* clear any interrupt if present */
552 REG_WRITE(sc, RAY_HCSIR, 0);
553
554 /*
555 * set the parameters that will survive stop/init
556 */
557 memset(&sc->sc_dnwid, 0, sizeof(sc->sc_dnwid));
558 sc->sc_dnwid.i_len = strlen(RAY_DEF_NWID);
559 if (sc->sc_dnwid.i_len > IEEE80211_NWID_LEN)
560 sc->sc_dnwid.i_len = IEEE80211_NWID_LEN;
561 if (sc->sc_dnwid.i_len > 0)
562 memcpy(sc->sc_dnwid.i_nwid, RAY_DEF_NWID, sc->sc_dnwid.i_len);
563 memcpy(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid));
564 sc->sc_omode = sc->sc_mode = RAY_MODE_DEFAULT;
565 sc->sc_countrycode = sc->sc_dcountrycode =
566 RAY_PID_COUNTRY_CODE_DEFAULT;
567
568 /*
569 * attach the interface
570 */
571 /* The version isn't the most accurate way, but it's easy. */
572 aprint_normal_dev(self, "firmware version %d\n",
573 sc->sc_version);
574 if (sc->sc_version != SC_BUILD_4)
575 aprint_normal_dev(self, "supported rates %0x:%0x:%0x:%0x:%0x:%0x:%0x:%0x\n",
576 ep->e_rates[0], ep->e_rates[1],
577 ep->e_rates[2], ep->e_rates[3], ep->e_rates[4],
578 ep->e_rates[5], ep->e_rates[6], ep->e_rates[7]);
579 aprint_normal_dev(self, "802.11 address %s\n",
580 ether_sprintf(ep->e_station_addr));
581
582 memcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
583 ifp->if_softc = sc;
584 ifp->if_start = ray_if_start;
585 ifp->if_stop = ray_if_stop;
586 ifp->if_ioctl = ray_ioctl;
587 ifp->if_mtu = ETHERMTU;
588 ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST;
589 IFQ_SET_READY(&ifp->if_snd);
590
591 if_attach(ifp);
592 ether_ifattach(ifp, ep->e_station_addr);
593 /* need enough space for ieee80211_header + (snap or e2) */
594 ifp->if_hdrlen =
595 sizeof(struct ieee80211_frame) + sizeof(struct ether_header);
596
597 ifmedia_init(&sc->sc_media, 0, ray_media_change, ray_media_status);
598 ifmedia_add(&sc->sc_media, IFM_ADHOC, 0, 0);
599 ifmedia_add(&sc->sc_media, IFM_INFRA, 0, 0);
600 if (sc->sc_mode == SC_MODE_ADHOC)
601 ifmedia_set(&sc->sc_media, IFM_ADHOC);
602 else
603 ifmedia_set(&sc->sc_media, IFM_INFRA);
604
605 if (pmf_device_register(self, NULL, NULL))
606 pmf_class_network_register(self, ifp);
607 else
608 aprint_error_dev(self, "couldn't establish power handler\n");
609
610 /* The attach is successful. */
611 sc->sc_attached = 1;
612 ray_disable(sc);
613 return;
614
615 fail2:
616 ray_disable(sc);
617 fail:
618 pcmcia_function_unconfigure(pa->pf);
619 }
620
621 static int
622 ray_activate(device_t self, enum devact act)
623 {
624 struct ray_softc *sc = device_private(self);
625 struct ifnet *ifp = &sc->sc_if;
626
627 RAY_DPRINTF(("%s: activate\n", device_xname(self)));
628
629 switch (act) {
630 case DVACT_DEACTIVATE:
631 if_deactivate(ifp);
632 return 0;
633 default:
634 return EOPNOTSUPP;
635 }
636 }
637
638 static int
639 ray_detach(device_t self, int flags)
640 {
641 struct ray_softc *sc;
642 struct ifnet *ifp;
643
644 sc = device_private(self);
645 ifp = &sc->sc_if;
646 RAY_DPRINTF(("%s: detach\n", device_xname(&sc->sc_dev)));
647
648 if (!sc->sc_attached)
649 return (0);
650
651 pmf_device_deregister(self);
652
653 if (sc->sc_if.if_flags & IFF_UP)
654 ray_disable(sc);
655
656 ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY);
657 ether_ifdetach(ifp);
658 if_detach(ifp);
659
660 pcmcia_function_unconfigure(sc->sc_pf);
661
662 return (0);
663 }
664
665 /*
666 * start the card running
667 */
668 static int
669 ray_enable(struct ray_softc *sc)
670 {
671 int error;
672
673 RAY_DPRINTF(("%s: enable\n", device_xname(&sc->sc_dev)));
674
675 sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET,
676 ray_intr, sc);
677 if (!sc->sc_ih)
678 return (EIO);
679
680 error = ray_init(sc);
681 if (error) {
682 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
683 sc->sc_ih = 0;
684 }
685
686 return (error);
687 }
688
689 /*
690 * stop the card running
691 */
692 static void
693 ray_disable(struct ray_softc *sc)
694 {
695 RAY_DPRINTF(("%s: disable\n", device_xname(&sc->sc_dev)));
696
697 ray_stop(sc);
698
699 sc->sc_resetloop = 0;
700 sc->sc_rxoverflow = 0;
701 sc->sc_rxcksum = 0;
702 sc->sc_rxhcksum = 0;
703 sc->sc_rxnoise = 0;
704
705 if (sc->sc_ih) {
706 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
707 sc->sc_ih = 0;
708 }
709 }
710
711 /*
712 * start the card running
713 */
714 static int
715 ray_init(struct ray_softc *sc)
716 {
717 struct ray_ecf_startup *ep;
718 bus_size_t ccs;
719 int i;
720
721 RAY_DPRINTF(("%s: init\n", device_xname(&sc->sc_dev)));
722
723 if ((sc->sc_if.if_flags & IFF_RUNNING))
724 ray_stop(sc);
725
726 if (pcmcia_function_enable(sc->sc_pf))
727 return (EIO);
728
729 RAY_DPRINTF(("%s: init post-enable\n", device_xname(&sc->sc_dev)));
730
731 /* reset some values */
732 memset(sc->sc_ccsinuse, 0, sizeof(sc->sc_ccsinuse));
733 sc->sc_havenet = 0;
734 memset(sc->sc_bssid, 0, sizeof(sc->sc_bssid));
735 sc->sc_deftxrate = 0;
736 sc->sc_encrypt = 0;
737 sc->sc_txpad = 0;
738 sc->sc_promisc = 0;
739 sc->sc_scheduled = 0;
740 sc->sc_running = 0;
741 sc->sc_txfree = RAY_CCS_NTX;
742 sc->sc_checkcounters = 0;
743 sc->sc_authstate = RAY_AUTH_UNAUTH;
744
745 /* get startup results */
746 ep = &sc->sc_ecf_startup;
747 ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep,
748 sizeof(sc->sc_ecf_startup));
749
750 /* check to see that card initialized properly */
751 if (ep->e_status != RAY_ECFS_CARD_OK) {
752 pcmcia_function_disable(sc->sc_pf);
753 printf("%s: card failed self test: status %d\n",
754 device_xname(&sc->sc_dev), sc->sc_ecf_startup.e_status);
755 return (EIO);
756 }
757
758 /* fixup tib size to be correct */
759 if (sc->sc_version == SC_BUILD_4 && sc->sc_tibsize == 0x55)
760 sc->sc_tibsize = 32;
761 sc->sc_txpad = sc->sc_tibsize;
762
763 /* set all ccs to be free */
764 ccs = RAY_GET_CCS(0);
765 for (i = 0; i < RAY_CCS_LAST; ccs += RAY_CCS_SIZE, i++)
766 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status,
767 RAY_CCS_STATUS_FREE);
768
769 /* clear the interrupt if present */
770 REG_WRITE(sc, RAY_HCSIR, 0);
771
772 callout_init(&sc->sc_check_ccs_ch, 0);
773 callout_init(&sc->sc_check_scheduled_ch, 0);
774
775 /* we are now up and running -- and are busy until download is cplt */
776 sc->sc_if.if_flags |= IFF_RUNNING | IFF_OACTIVE;
777
778 /* set this now so it gets set in the download */
779 if (sc->sc_if.if_flags & IFF_ALLMULTI)
780 sc->sc_if.if_flags |= IFF_PROMISC;
781 else if (sc->sc_if.if_pcount == 0)
782 sc->sc_if.if_flags &= ~IFF_PROMISC;
783 sc->sc_promisc = !!(sc->sc_if.if_flags & IFF_PROMISC);
784
785 /* call after we mark ourselves running */
786 ray_download_params(sc);
787
788 return (0);
789 }
790
791 /*
792 * stop the card running
793 */
794 static void
795 ray_stop(struct ray_softc *sc)
796 {
797 RAY_DPRINTF(("%s: stop\n", device_xname(&sc->sc_dev)));
798
799 callout_stop(&sc->sc_check_ccs_ch);
800 sc->sc_timocheck = 0;
801
802 callout_stop(&sc->sc_check_scheduled_ch);
803 sc->sc_timoneed = 0;
804
805 if (sc->sc_repreq) {
806 sc->sc_repreq->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
807 wakeup(ray_report_params);
808 }
809 if (sc->sc_updreq) {
810 sc->sc_updreq->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
811 wakeup(ray_update_params);
812 }
813
814 sc->sc_if.if_flags &= ~IFF_RUNNING;
815 pcmcia_function_disable(sc->sc_pf);
816 }
817
818 /*
819 * reset the card
820 */
821 static void
822 ray_reset(struct ray_softc *sc)
823 {
824 if (++sc->sc_resetloop >= RAY_MAX_RESETS) {
825 if (sc->sc_resetloop == RAY_MAX_RESETS) {
826 aprint_error_dev(&sc->sc_dev, "unable to correct, disabling\n");
827 callout_stop(&sc->sc_reset_resetloop_ch);
828 callout_reset(&sc->sc_disable_ch, 1,
829 (void (*)(void *))ray_disable, sc);
830 }
831 } else {
832 aprint_error_dev(&sc->sc_dev, "unexpected failure resetting hw [%d more]\n",
833 RAY_MAX_RESETS - sc->sc_resetloop);
834 callout_stop(&sc->sc_reset_resetloop_ch);
835 ray_init(sc);
836 callout_reset(&sc->sc_reset_resetloop_ch, 30 * hz,
837 ray_reset_resetloop, sc);
838 }
839 }
840
841 /*
842 * return resetloop to zero (enough time has expired to allow user to
843 * disable a whacked interface) the main reason for all this nonesense
844 * is that resets take ~2 seconds and currently the pcmcia code spins
845 * on these resets
846 */
847 static void
848 ray_reset_resetloop(void *arg)
849 {
850 struct ray_softc *sc;
851
852 sc = arg;
853 sc->sc_resetloop = 0;
854 }
855
856 static int
857 ray_ioctl(struct ifnet *ifp, u_long cmd, void *data)
858 {
859 struct ieee80211_nwid nwid;
860 struct ray_param_req pr;
861 struct ray_softc *sc;
862 struct ifreq *ifr;
863 struct ifaddr *ifa;
864 int error, error2, s, i;
865
866 sc = ifp->if_softc;
867 error = 0;
868
869 ifr = (struct ifreq *)data;
870
871 s = splnet();
872
873 RAY_DPRINTF(("%s: ioctl: cmd 0x%lx data 0x%lx\n", ifp->if_xname,
874 cmd, (long)data));
875 switch (cmd) {
876 case SIOCINITIFADDR:
877 RAY_DPRINTF(("%s: ioctl: cmd SIOCINITIFADDR\n", ifp->if_xname));
878 if ((ifp->if_flags & IFF_RUNNING) == 0)
879 if ((error = ray_enable(sc)))
880 break;
881 ifp->if_flags |= IFF_UP;
882 ifa = (struct ifaddr *)data;
883 switch (ifa->ifa_addr->sa_family) {
884 #ifdef INET
885 case AF_INET:
886 arp_ifinit(&sc->sc_if, ifa);
887 break;
888 #endif
889 default:
890 break;
891 }
892 break;
893 case SIOCSIFFLAGS:
894 RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFFLAGS\n", ifp->if_xname));
895 if ((error = ifioctl_common(ifp, cmd, data)) != 0)
896 break;
897 if (ifp->if_flags & IFF_UP) {
898 if ((ifp->if_flags & IFF_RUNNING) == 0) {
899 if ((error = ray_enable(sc)))
900 break;
901 } else
902 ray_update_promisc(sc);
903 } else if (ifp->if_flags & IFF_RUNNING)
904 ray_disable(sc);
905 break;
906 case SIOCADDMULTI:
907 RAY_DPRINTF(("%s: ioctl: cmd SIOCADDMULTI\n", ifp->if_xname));
908 case SIOCDELMULTI:
909 if (cmd == SIOCDELMULTI)
910 RAY_DPRINTF(("%s: ioctl: cmd SIOCDELMULTI\n",
911 ifp->if_xname));
912 if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) {
913 if (ifp->if_flags & IFF_RUNNING)
914 ray_update_mcast(sc);
915 error = 0;
916 }
917 break;
918 case SIOCSIFMEDIA:
919 RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFMEDIA\n", ifp->if_xname));
920 case SIOCGIFMEDIA:
921 if (cmd == SIOCGIFMEDIA)
922 RAY_DPRINTF(("%s: ioctl: cmd SIOCGIFMEDIA\n",
923 ifp->if_xname));
924 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
925 break;
926 case SIOCSRAYPARAM:
927 RAY_DPRINTF(("%s: ioctl: cmd SIOCSRAYPARAM\n", ifp->if_xname));
928 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
929 break;
930 /* disallow certain command that have another interface */
931 switch (pr.r_paramid) {
932 case RAY_PID_NET_TYPE: /* through media opt */
933 case RAY_PID_AP_STATUS: /* unsupported */
934 case RAY_PID_SSID: /* use SIOC80211[GS]NWID */
935 case RAY_PID_MAC_ADDR: /* XXX need interface? */
936 case RAY_PID_PROMISC: /* bpf */
937 error = EINVAL;
938 break;
939 }
940 error = ray_user_update_params(sc, &pr);
941 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
942 error = error2 ? error2 : error;
943 break;
944 case SIOCGRAYPARAM:
945 RAY_DPRINTF(("%s: ioctl: cmd SIOCGRAYPARAM\n", ifp->if_xname));
946 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
947 break;
948 error = ray_user_report_params(sc, &pr);
949 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
950 error = error2 ? error2 : error;
951 break;
952 case SIOCS80211NWID:
953 RAY_DPRINTF(("%s: ioctl: cmd SIOCS80211NWID\n", ifp->if_xname));
954 /*
955 * if later people overwrite thats ok -- the latest version
956 * will always get start/joined even if it was set by
957 * a previous command
958 */
959 if ((error = copyin(ifr->ifr_data, &nwid, sizeof(nwid))))
960 break;
961 if (nwid.i_len > IEEE80211_NWID_LEN) {
962 error = EINVAL;
963 break;
964 }
965 /* clear trailing garbages */
966 for (i = nwid.i_len; i < IEEE80211_NWID_LEN; i++)
967 nwid.i_nwid[i] = 0;
968 if (!memcmp(&sc->sc_dnwid, &nwid, sizeof(nwid)))
969 break;
970 memcpy(&sc->sc_dnwid, &nwid, sizeof(nwid));
971 if (ifp->if_flags & IFF_RUNNING)
972 ray_start_join_net(sc);
973 break;
974 case SIOCG80211NWID:
975 RAY_DPRINTF(("%s: ioctl: cmd SIOCG80211NWID\n", ifp->if_xname));
976 error = copyout(&sc->sc_cnwid, ifr->ifr_data,
977 sizeof(sc->sc_cnwid));
978 break;
979 #ifdef RAY_DO_SIGLEV
980 case SIOCGRAYSIGLEV:
981 error = copyout(sc->sc_siglevs, ifr->ifr_data,
982 sizeof sc->sc_siglevs);
983 break;
984 #endif
985 default:
986 RAY_DPRINTF(("%s: ioctl: unknown\n", ifp->if_xname));
987 error = ether_ioctl(ifp, cmd, data);
988 break;
989 }
990
991 RAY_DPRINTF(("%s: ioctl: returns %d\n", ifp->if_xname, error));
992
993 splx(s);
994
995 return (error);
996 }
997
998 /*
999 * ifnet interface to start transmission on the interface
1000 */
1001 static void
1002 ray_if_start(struct ifnet *ifp)
1003 {
1004 struct ray_softc *sc;
1005
1006 sc = ifp->if_softc;
1007 ray_intr_start(sc);
1008 }
1009
1010 static void
1011 ray_if_stop(struct ifnet *ifp, int disable)
1012 {
1013 struct ray_softc *sc = ifp->if_softc;
1014
1015 ray_stop(sc);
1016 }
1017
1018 static int
1019 ray_media_change(struct ifnet *ifp)
1020 {
1021 struct ray_softc *sc;
1022
1023 sc = ifp->if_softc;
1024 RAY_DPRINTF(("%s: media change cur %d\n", ifp->if_xname,
1025 sc->sc_media.ifm_cur->ifm_media));
1026 if (sc->sc_media.ifm_cur->ifm_media & IFM_IEEE80211_ADHOC)
1027 sc->sc_mode = SC_MODE_ADHOC;
1028 else
1029 sc->sc_mode = SC_MODE_INFRA;
1030 if (sc->sc_mode != sc->sc_omode)
1031 ray_start_join_net(sc);
1032 return (0);
1033 }
1034
1035 static void
1036 ray_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1037 {
1038 struct ray_softc *sc;
1039
1040 sc = ifp->if_softc;
1041
1042 RAY_DPRINTF(("%s: media status\n", ifp->if_xname));
1043
1044 imr->ifm_status = IFM_AVALID;
1045 if (sc->sc_havenet)
1046 imr->ifm_status |= IFM_ACTIVE;
1047
1048 if (sc->sc_mode == SC_MODE_ADHOC)
1049 imr->ifm_active = IFM_ADHOC;
1050 else
1051 imr->ifm_active = IFM_INFRA;
1052 }
1053
1054 /*
1055 * called to start from ray_intr. We don't check for pending
1056 * interrupt as a result
1057 */
1058 static void
1059 ray_intr_start(struct ray_softc *sc)
1060 {
1061 struct ieee80211_frame *iframe;
1062 struct ether_header *eh;
1063 size_t len, pktlen, tmplen;
1064 bus_size_t bufp, ebufp;
1065 struct mbuf *m0, *m;
1066 struct ifnet *ifp;
1067 u_int firsti, hinti, previ, i, pcount;
1068 u_int16_t et;
1069 u_int8_t *d;
1070
1071 ifp = &sc->sc_if;
1072
1073 RAY_DPRINTF(("%s: start free %d\n",
1074 ifp->if_xname, sc->sc_txfree));
1075
1076 ray_cmd_cancel(sc, SCP_IFSTART);
1077
1078 if ((ifp->if_flags & IFF_RUNNING) == 0 || !sc->sc_havenet)
1079 return;
1080
1081 if (IFQ_IS_EMPTY(&ifp->if_snd))
1082 return;
1083
1084 firsti = i = previ = RAY_CCS_LINK_NULL;
1085 hinti = RAY_CCS_TX_FIRST;
1086
1087 if (!RAY_ECF_READY(sc)) {
1088 ray_cmd_schedule(sc, SCP_IFSTART);
1089 return;
1090 }
1091
1092 /* Check to see if we need to authenticate before sending packets. */
1093 if (sc->sc_authstate == RAY_AUTH_NEEDED) {
1094 RAY_DPRINTF(("%s: Sending auth request.\n", ifp->if_xname));
1095 sc->sc_authstate = RAY_AUTH_WAITING;
1096 ray_send_auth(sc, sc->sc_authid, OPEN_AUTH_REQUEST);
1097 return;
1098 }
1099
1100 pcount = 0;
1101 for (;;) {
1102 /* if we have no descriptors be done */
1103 if (i == RAY_CCS_LINK_NULL) {
1104 i = ray_find_free_tx_ccs(sc, hinti);
1105 if (i == RAY_CCS_LINK_NULL) {
1106 RAY_DPRINTF(("%s: no descriptors.\n",
1107 ifp->if_xname));
1108 ifp->if_flags |= IFF_OACTIVE;
1109 break;
1110 }
1111 }
1112
1113 IFQ_DEQUEUE(&ifp->if_snd, m0);
1114 if (!m0) {
1115 RAY_DPRINTF(("%s: dry queue.\n", ifp->if_xname));
1116 break;
1117 }
1118 RAY_DPRINTF(("%s: gotmbuf 0x%lx\n", ifp->if_xname, (long)m0));
1119 pktlen = m0->m_pkthdr.len;
1120 if (pktlen > ETHER_MAX_LEN - ETHER_CRC_LEN) {
1121 RAY_DPRINTF((
1122 "%s: mbuf too long %ld\n", ifp->if_xname,
1123 (u_long)pktlen));
1124 ifp->if_oerrors++;
1125 m_freem(m0);
1126 continue;
1127 }
1128 RAY_DPRINTF(("%s: mbuf.m_pkthdr.len %d\n", ifp->if_xname,
1129 (int)pktlen));
1130
1131 /* we need the ether_header now for pktlen adjustments */
1132 M_PULLUP(m0, sizeof(struct ether_header));
1133 if (!m0) {
1134 RAY_DPRINTF(( "%s: couldn\'t pullup ether header\n",
1135 ifp->if_xname));
1136 ifp->if_oerrors++;
1137 continue;
1138 }
1139 RAY_DPRINTF(("%s: got pulled up mbuf 0x%lx\n", ifp->if_xname,
1140 (long)m0));
1141
1142 /* first peek at the type of packet and figure out what to do */
1143 eh = mtod(m0, struct ether_header *);
1144 et = ntohs(eh->ether_type);
1145 if (ifp->if_flags & IFF_LINK0) {
1146 /* don't support llc for windows compat operation */
1147 if (et <= ETHERMTU) {
1148 m_freem(m0);
1149 ifp->if_oerrors++;
1150 continue;
1151 }
1152 tmplen = sizeof(struct ieee80211_frame);
1153 } else if (et > ETHERMTU) {
1154 /* adjust for LLC/SNAP header */
1155 tmplen = sizeof(struct ieee80211_frame) - ETHER_ADDR_LEN;
1156 } else {
1157 tmplen = 0;
1158 }
1159 /* now get our space for the 802.11 frame */
1160 M_PREPEND(m0, tmplen, M_DONTWAIT);
1161 if (m0)
1162 M_PULLUP(m0, sizeof(struct ether_header) + tmplen);
1163 if (!m0) {
1164 RAY_DPRINTF(("%s: couldn\'t prepend header\n",
1165 ifp->if_xname));
1166 ifp->if_oerrors++;
1167 continue;
1168 }
1169 /* copy the frame into the mbuf for tapping */
1170 iframe = mtod(m0, struct ieee80211_frame *);
1171 eh = (struct ether_header *)((u_int8_t *)iframe + tmplen);
1172 iframe->i_fc[0] =
1173 (IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA);
1174 if (sc->sc_mode == SC_MODE_ADHOC) {
1175 iframe->i_fc[1] = IEEE80211_FC1_DIR_NODS;
1176 memcpy(iframe->i_addr1, eh->ether_dhost,ETHER_ADDR_LEN);
1177 memcpy(iframe->i_addr2, eh->ether_shost,ETHER_ADDR_LEN);
1178 memcpy(iframe->i_addr3, sc->sc_bssid, ETHER_ADDR_LEN);
1179 } else {
1180 iframe->i_fc[1] = IEEE80211_FC1_DIR_TODS;
1181 memcpy(iframe->i_addr1, sc->sc_bssid,ETHER_ADDR_LEN);
1182 memcpy(iframe->i_addr2, eh->ether_shost,ETHER_ADDR_LEN);
1183 memmove(iframe->i_addr3,eh->ether_dhost,ETHER_ADDR_LEN);
1184 }
1185 iframe->i_dur[0] = iframe->i_dur[1] = 0;
1186 iframe->i_seq[0] = iframe->i_seq[1] = 0;
1187
1188 /* if not using crummy E2 in 802.11 make it LLC/SNAP */
1189 if ((ifp->if_flags & IFF_LINK0) == 0 && et > ETHERMTU)
1190 memcpy(iframe + 1, llc_snapid, sizeof(llc_snapid));
1191
1192 RAY_DPRINTF(("%s: i %d previ %d\n", ifp->if_xname, i, previ));
1193
1194 if (firsti == RAY_CCS_LINK_NULL)
1195 firsti = i;
1196
1197 pktlen = m0->m_pkthdr.len;
1198 bufp = ray_fill_in_tx_ccs(sc, pktlen, i, previ);
1199 previ = hinti = i;
1200 i = RAY_CCS_LINK_NULL;
1201
1202 RAY_DPRINTF(("%s: bufp 0x%lx new pktlen %d\n",
1203 ifp->if_xname, (long)bufp, (int)pktlen));
1204
1205 /* copy out mbuf */
1206 for (m = m0; m; m = m->m_next) {
1207 if ((len = m->m_len) == 0)
1208 continue;
1209 RAY_DPRINTF((
1210 "%s: copying mbuf 0x%lx bufp 0x%lx len %d\n",
1211 ifp->if_xname, (long)m, (long)bufp, (int)len));
1212 d = mtod(m, u_int8_t *);
1213 ebufp = bufp + len;
1214 if (ebufp <= RAY_TX_END)
1215 ray_write_region(sc, bufp, d, len);
1216 else {
1217 panic("ray_intr_start"); /* XXX */
1218 /* wrapping */
1219 tmplen = ebufp - bufp;
1220 len -= tmplen;
1221 ray_write_region(sc, bufp, d, tmplen);
1222 d += tmplen;
1223 bufp = RAY_TX_BASE;
1224 ray_write_region(sc, bufp, d, len);
1225 }
1226 bufp += len;
1227 }
1228 #if NBPFILTER > 0
1229 if (ifp->if_bpf) {
1230 if (ifp->if_flags & IFF_LINK0) {
1231 m0->m_data += sizeof(struct ieee80211_frame);
1232 m0->m_len -= sizeof(struct ieee80211_frame);
1233 m0->m_pkthdr.len -= sizeof(struct ieee80211_frame);
1234 }
1235 bpf_mtap(ifp->if_bpf, m0);
1236 if (ifp->if_flags & IFF_LINK0) {
1237 m0->m_data -= sizeof(struct ieee80211_frame);
1238 m0->m_len += sizeof(struct ieee80211_frame);
1239 m0->m_pkthdr.len += sizeof(struct ieee80211_frame);
1240 }
1241 }
1242 #endif
1243
1244 #ifdef RAY_DEBUG
1245 if (ray_debug && ray_debug_dump_tx)
1246 ray_dump_mbuf(sc, m0);
1247 #endif
1248 pcount++;
1249 m_freem(m0);
1250
1251 RAY_DPRINTF_XMIT(("%s: sent packet: len %ld\n", device_xname(&sc->sc_dev),
1252 (u_long)pktlen));
1253 }
1254
1255 if (firsti == RAY_CCS_LINK_NULL)
1256 return;
1257 i = 0;
1258 if (!RAY_ECF_READY(sc)) {
1259 /*
1260 * if this can really happen perhaps we need to save
1261 * the chain and use it later. I think this might
1262 * be a confused state though because we check above
1263 * and don't issue any commands between.
1264 */
1265 printf("%s: dropping tx packets device busy\n", device_xname(&sc->sc_dev));
1266 ray_free_ccs_chain(sc, firsti);
1267 ifp->if_oerrors += pcount;
1268 return;
1269 }
1270
1271 /* send it off */
1272 RAY_DPRINTF(("%s: ray_start issuing %d \n", device_xname(&sc->sc_dev), firsti));
1273 SRAM_WRITE_1(sc, RAY_SCB_CCSI, firsti);
1274 RAY_ECF_START_CMD(sc);
1275
1276 ifp->if_opackets += pcount;
1277 }
1278
1279 /*
1280 * recevice a packet from the card
1281 */
1282 static void
1283 ray_recv(struct ray_softc *sc, bus_size_t ccs)
1284 {
1285 struct ieee80211_frame *frame;
1286 struct ether_header *eh;
1287 struct mbuf *m;
1288 size_t pktlen, fudge, len, lenread = 0;
1289 bus_size_t bufp, ebufp, tmp;
1290 struct ifnet *ifp;
1291 u_int8_t *src, *d;
1292 u_int frag = 0, ni, i, issnap, first;
1293 u_int8_t fc0;
1294 #ifdef RAY_DO_SIGLEV
1295 u_int8_t siglev;
1296 #endif
1297
1298 #ifdef RAY_DEBUG
1299 /* have a look if you want to see how the card rx works :) */
1300 if (ray_debug && ray_debug_dump_desc)
1301 hexdump((char *)sc->sc_memh + RAY_RCS_BASE, 0x400,
1302 16, 4, 0);
1303 #endif
1304
1305 m = 0;
1306 ifp = &sc->sc_if;
1307
1308 /*
1309 * If we're expecting the E2-in-802.11 encapsulation that the
1310 * WebGear Windows driver produces, fudge the packet forward
1311 * in the mbuf by 2 bytes so that the payload after the
1312 * Ethernet header will be aligned. If we end up getting a
1313 * packet that's not of this type, we'll just drop it anyway.
1314 */
1315 if (ifp->if_flags & IFF_LINK0)
1316 fudge = 2;
1317 else
1318 fudge = 0;
1319
1320 /* it looks like at least with build 4 there is no CRC in length */
1321 first = RAY_GET_INDEX(ccs);
1322 pktlen = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_pktlen);
1323 #ifdef RAY_DO_SIGLEV
1324 siglev = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_siglev);
1325 #endif
1326
1327 RAY_DPRINTF(("%s: recv pktlen %ld frag %d\n", device_xname(&sc->sc_dev),
1328 (u_long)pktlen, frag));
1329 RAY_DPRINTF_XMIT(("%s: received packet: len %ld\n", device_xname(&sc->sc_dev),
1330 (u_long)pktlen));
1331 if (pktlen > MCLBYTES || pktlen < sizeof(*frame)) {
1332 RAY_DPRINTF(("%s: PKTLEN TOO BIG OR TOO SMALL\n",
1333 device_xname(&sc->sc_dev)));
1334 ifp->if_ierrors++;
1335 goto done;
1336 }
1337 MGETHDR(m, M_DONTWAIT, MT_DATA);
1338 if (!m) {
1339 RAY_DPRINTF(("%s: MGETHDR FAILED\n", device_xname(&sc->sc_dev)));
1340 ifp->if_ierrors++;
1341 goto done;
1342 }
1343 if ((pktlen + fudge) > MHLEN) {
1344 /* XXX should allow chaining? */
1345 MCLGET(m, M_DONTWAIT);
1346 if ((m->m_flags & M_EXT) == 0) {
1347 RAY_DPRINTF(("%s: MCLGET FAILED\n", device_xname(&sc->sc_dev)));
1348 ifp->if_ierrors++;
1349 m_freem(m);
1350 m = 0;
1351 goto done;
1352 }
1353 }
1354 m->m_pkthdr.rcvif = ifp;
1355 m->m_pkthdr.len = pktlen;
1356 m->m_len = pktlen;
1357 m->m_data += fudge;
1358 d = mtod(m, u_int8_t *);
1359
1360 RAY_DPRINTF(("%s: recv ccs index %d\n", device_xname(&sc->sc_dev), first));
1361 i = ni = first;
1362 while ((i = ni) && i != RAY_CCS_LINK_NULL) {
1363 ccs = RAY_GET_CCS(i);
1364 bufp = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_bufp);
1365 len = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_len);
1366 /* remove the CRC */
1367 #if 0
1368 /* at least with build 4 no crc seems to be here */
1369 if (frag++ == 0)
1370 len -= 4;
1371 #endif
1372 ni = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_nextfrag);
1373 RAY_DPRINTF((
1374 "%s: recv frag index %d len %ld bufp 0x%llx ni %d\n",
1375 device_xname(&sc->sc_dev), i, (u_long)len, (unsigned long long)bufp,
1376 ni));
1377 if (len + lenread > pktlen) {
1378 RAY_DPRINTF(("%s: BAD LEN current 0x%lx pktlen 0x%lx\n",
1379 device_xname(&sc->sc_dev), (u_long)(len + lenread),
1380 (u_long)pktlen));
1381 ifp->if_ierrors++;
1382 m_freem(m);
1383 m = 0;
1384 goto done;
1385 }
1386 if (i < RAY_RCCS_FIRST) {
1387 printf("ray_recv: bad ccs index 0x%x\n", i);
1388 m_freem(m);
1389 m = 0;
1390 goto done;
1391 }
1392
1393 ebufp = bufp + len;
1394 if (ebufp <= RAY_RX_END)
1395 ray_read_region(sc, bufp, d, len);
1396 else {
1397 /* wrapping */
1398 ray_read_region(sc, bufp, d, (tmp = RAY_RX_END - bufp));
1399 ray_read_region(sc, RAY_RX_BASE, d + tmp, ebufp - RAY_RX_END);
1400 }
1401 d += len;
1402 lenread += len;
1403 }
1404 done:
1405
1406 RAY_DPRINTF(("%s: recv frag count %d\n", device_xname(&sc->sc_dev), frag));
1407
1408 /* free the rcss */
1409 ni = first;
1410 while ((i = ni) && (i != RAY_CCS_LINK_NULL)) {
1411 ccs = RAY_GET_CCS(i);
1412 ni = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_nextfrag);
1413 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status,
1414 RAY_CCS_STATUS_FREE);
1415 }
1416
1417 if (!m)
1418 return;
1419
1420 RAY_DPRINTF(("%s: recv got packet pktlen %ld actual %ld\n",
1421 device_xname(&sc->sc_dev), (u_long)pktlen, (u_long)lenread));
1422 #ifdef RAY_DEBUG
1423 if (ray_debug && ray_debug_dump_rx)
1424 ray_dump_mbuf(sc, m);
1425 #endif
1426 /* receivce the packet */
1427 frame = mtod(m, struct ieee80211_frame *);
1428 fc0 = frame->i_fc[0]
1429 & (IEEE80211_FC0_VERSION_MASK|IEEE80211_FC0_TYPE_MASK);
1430 if ((fc0 & IEEE80211_FC0_VERSION_MASK) != IEEE80211_FC0_VERSION_0) {
1431 RAY_DPRINTF(("%s: pkt not version 0 fc 0x%x\n",
1432 device_xname(&sc->sc_dev), fc0));
1433 m_freem(m);
1434 return;
1435 }
1436 if ((fc0 & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_MGT) {
1437 switch (frame->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
1438 case IEEE80211_FC0_SUBTYPE_BEACON:
1439 /* Ignore beacon silently. */
1440 break;
1441 case IEEE80211_FC0_SUBTYPE_AUTH:
1442 ray_recv_auth(sc, frame);
1443 break;
1444 case IEEE80211_FC0_SUBTYPE_DEAUTH:
1445 sc->sc_authstate = RAY_AUTH_UNAUTH;
1446 break;
1447 default:
1448 RAY_DPRINTF(("%s: mgt packet not supported\n",
1449 device_xname(&sc->sc_dev)));
1450 #ifdef RAY_DEBUG
1451 hexdump((const u_int8_t*)frame, pktlen, 16, 4, 0);
1452 #endif
1453 RAY_DPRINTF(("\n"));
1454 break;
1455 }
1456 m_freem(m);
1457 return;
1458 } else if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) {
1459 RAY_DPRINTF(("%s: pkt not type data fc0 0x%x\n",
1460 device_xname(&sc->sc_dev), fc0));
1461 m_freem(m);
1462 return;
1463 }
1464
1465 if (pktlen < sizeof(*frame) + sizeof(struct llc)) {
1466 RAY_DPRINTF(("%s: pkt too small for llc (%ld)\n",
1467 device_xname(&sc->sc_dev), (u_long)pktlen));
1468 m_freem(m);
1469 return;
1470 }
1471
1472 if (!memcmp(frame + 1, llc_snapid, sizeof(llc_snapid)))
1473 issnap = 1;
1474 else {
1475 /*
1476 * if user has link0 flag set we allow the weird
1477 * Ethernet2 in 802.11 encapsulation produced by
1478 * the windows driver for the WebGear card
1479 */
1480 RAY_DPRINTF(("%s: pkt not snap 0\n", device_xname(&sc->sc_dev)));
1481 if ((ifp->if_flags & IFF_LINK0) == 0) {
1482 m_freem(m);
1483 return;
1484 }
1485 issnap = 0;
1486 }
1487 switch (frame->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
1488 case IEEE80211_FC1_DIR_NODS:
1489 src = frame->i_addr2;
1490 break;
1491 case IEEE80211_FC1_DIR_FROMDS:
1492 src = frame->i_addr3;
1493 break;
1494 case IEEE80211_FC1_DIR_TODS:
1495 RAY_DPRINTF(("%s: pkt ap2ap\n", device_xname(&sc->sc_dev)));
1496 m_freem(m);
1497 return;
1498 default:
1499 RAY_DPRINTF(("%s: pkt type unknown\n", device_xname(&sc->sc_dev)));
1500 m_freem(m);
1501 return;
1502 }
1503
1504 #ifdef RAY_DO_SIGLEV
1505 ray_update_siglev(sc, src, siglev);
1506 #endif
1507
1508 /*
1509 * This is a mess.. we should support other LLC frame types
1510 */
1511 if (issnap) {
1512 /* create an ether_header over top of the 802.11+SNAP header */
1513 eh = (struct ether_header *)((char *)(frame + 1) - 6);
1514 memcpy(eh->ether_shost, src, ETHER_ADDR_LEN);
1515 memcpy(eh->ether_dhost, frame->i_addr1, ETHER_ADDR_LEN);
1516 } else {
1517 /* this is the weird e2 in 802.11 encapsulation */
1518 eh = (struct ether_header *)(frame + 1);
1519 }
1520 m_adj(m, (char *)eh - (char *)frame);
1521 #if NBPFILTER > 0
1522 if (ifp->if_bpf)
1523 bpf_mtap(ifp->if_bpf, m);
1524 #endif
1525 /* XXX doesn't appear to be included m->m_flags |= M_HASFCS; */
1526 ifp->if_ipackets++;
1527 (*ifp->if_input)(ifp, m);
1528 }
1529
1530 /*
1531 * receive an auth packet
1532 */
1533 static void
1534 ray_recv_auth(struct ray_softc *sc, struct ieee80211_frame *frame)
1535 {
1536 u_int8_t *var = (u_int8_t *)(frame + 1);
1537
1538 if (sc->sc_mode == SC_MODE_ADHOC) {
1539 RAY_DPRINTF(("%s: recv auth packet:\n", device_xname(&sc->sc_dev)));
1540 #ifdef RAY_DEBUG
1541 hexdump((const u_int8_t *)frame, sizeof(*frame) + 6, 16, 4, 0);
1542 #endif
1543 RAY_DPRINTF(("\n"));
1544
1545 if (var[2] == OPEN_AUTH_REQUEST) {
1546 RAY_DPRINTF(("%s: Sending authentication response.\n",
1547 device_xname(&sc->sc_dev)));
1548 if (ray_send_auth(sc, frame->i_addr2,
1549 OPEN_AUTH_RESPONSE) == 0) {
1550 sc->sc_authstate = RAY_AUTH_NEEDED;
1551 memcpy(sc->sc_authid, frame->i_addr2,
1552 ETHER_ADDR_LEN);
1553 }
1554 } else if (var[2] == OPEN_AUTH_RESPONSE) {
1555 RAY_DPRINTF(("%s: Authenticated!\n",
1556 device_xname(&sc->sc_dev)));
1557 sc->sc_authstate = RAY_AUTH_AUTH;
1558 }
1559 }
1560 }
1561
1562 /*
1563 * send an auth packet
1564 */
1565 static int
1566 ray_send_auth(struct ray_softc *sc, u_int8_t *dest, u_int8_t auth_type)
1567 {
1568 u_int8_t packet[sizeof(struct ieee80211_frame) + ETHER_ADDR_LEN], *var;
1569 struct ieee80211_frame *frame;
1570 bus_size_t bufp;
1571 int ccsindex;
1572
1573 ccsindex = ray_find_free_tx_ccs(sc, RAY_CCS_TX_FIRST);
1574 if (ccsindex == RAY_CCS_LINK_NULL) {
1575 RAY_DPRINTF(("%s: send auth failed -- no free tx slots\n",
1576 device_xname(&sc->sc_dev)));
1577 return (ENOMEM);
1578 }
1579
1580 bufp = ray_fill_in_tx_ccs(sc, sizeof(packet), ccsindex,
1581 RAY_CCS_LINK_NULL);
1582 frame = (struct ieee80211_frame *) packet;
1583 frame->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_SUBTYPE_AUTH;
1584 frame->i_fc[1] = 0;
1585 memcpy(frame->i_addr1, dest, ETHER_ADDR_LEN);
1586 memcpy(frame->i_addr2, sc->sc_ecf_startup.e_station_addr,
1587 ETHER_ADDR_LEN);
1588 memcpy(frame->i_addr3, sc->sc_bssid, ETHER_ADDR_LEN);
1589
1590 var = (u_int8_t *)(frame + 1);
1591 memset(var, 0, ETHER_ADDR_LEN);
1592 var[2] = auth_type;
1593
1594 ray_write_region(sc, bufp, packet, sizeof(packet));
1595
1596 SRAM_WRITE_1(sc, RAY_SCB_CCSI, ccsindex);
1597 RAY_ECF_START_CMD(sc);
1598
1599 RAY_DPRINTF_XMIT(("%s: sent auth packet: len %lu\n",
1600 device_xname(&sc->sc_dev), (u_long) sizeof(packet)));
1601
1602 return (0);
1603 }
1604
1605 /*
1606 * scan for free buffers
1607 *
1608 * Note: do _not_ try to optimize this away, there is some kind of
1609 * horrible interaction with receiving tx interrupts and they
1610 * have to be done as fast as possible, which means zero processing.
1611 * this took ~ever to figure out, don't make someone do it again!
1612 */
1613 static u_int
1614 ray_find_free_tx_ccs(struct ray_softc *sc, u_int hint)
1615 {
1616 u_int i, stat;
1617
1618 for (i = hint; i <= RAY_CCS_TX_LAST; i++) {
1619 stat = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status);
1620 if (stat == RAY_CCS_STATUS_FREE)
1621 return (i);
1622 }
1623
1624 if (hint == RAY_CCS_TX_FIRST)
1625 return (RAY_CCS_LINK_NULL);
1626
1627 for (i = RAY_CCS_TX_FIRST; i < hint; i++) {
1628 stat = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status);
1629 if (stat == RAY_CCS_STATUS_FREE)
1630 return (i);
1631 }
1632 return (RAY_CCS_LINK_NULL);
1633 }
1634
1635 /*
1636 * allocate, initialize and link in a tx ccs for the given
1637 * page and the current chain values
1638 */
1639 static bus_size_t
1640 ray_fill_in_tx_ccs(struct ray_softc *sc, size_t pktlen, u_int i, u_int pi)
1641 {
1642 bus_size_t ccs, bufp;
1643
1644 /* pktlen += RAY_TX_PHY_SIZE; */
1645 bufp = RAY_TX_BASE + i * RAY_TX_BUF_SIZE;
1646 bufp += sc->sc_txpad;
1647 ccs = RAY_GET_CCS(i);
1648 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_status, RAY_CCS_STATUS_BUSY);
1649 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_cmd, RAY_CMD_TX_REQ);
1650 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_link, RAY_CCS_LINK_NULL);
1651 SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_bufp, bufp);
1652 SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_len, pktlen);
1653 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_tx_rate, sc->sc_deftxrate);
1654 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_apm_mode, 0);
1655 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_antenna, 0);
1656
1657 /* link us in */
1658 if (pi != RAY_CCS_LINK_NULL)
1659 SRAM_WRITE_FIELD_1(sc, RAY_GET_CCS(pi), ray_cmd_tx, c_link, i);
1660
1661 RAY_DPRINTF(("%s: ray_alloc_tx_ccs bufp 0x%llx idx %u pidx %u\n",
1662 device_xname(&sc->sc_dev), (unsigned long long)bufp, i, pi));
1663
1664 return (bufp + RAY_TX_PHY_SIZE);
1665 }
1666
1667 /*
1668 * an update params command has completed lookup which command and
1669 * the status
1670 */
1671 static ray_cmd_func_t
1672 ray_update_params_done(struct ray_softc *sc, bus_size_t ccs, u_int stat)
1673 {
1674 ray_cmd_func_t rcmd;
1675
1676 rcmd = 0;
1677
1678 RAY_DPRINTF(("%s: ray_update_params_done stat %d\n",
1679 device_xname(&sc->sc_dev), stat));
1680
1681 /* this will get more complex as we add commands */
1682 if (stat == RAY_CCS_STATUS_FAIL) {
1683 printf("%s: failed to update a promisc\n", device_xname(&sc->sc_dev));
1684 /* XXX should probably reset */
1685 /* rcmd = ray_reset; */
1686 }
1687
1688 if (sc->sc_running & SCP_UPD_PROMISC) {
1689 ray_cmd_done(sc, SCP_UPD_PROMISC);
1690 sc->sc_promisc = SRAM_READ_1(sc, RAY_HOST_TO_ECF_BASE);
1691 RAY_DPRINTF(("%s: new promisc value %d\n", device_xname(&sc->sc_dev),
1692 sc->sc_promisc));
1693 } else if (sc->sc_updreq) {
1694 ray_cmd_done(sc, SCP_UPD_UPDATEPARAMS);
1695 /* get the update parameter */
1696 sc->sc_updreq->r_failcause =
1697 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_failcause);
1698 sc->sc_updreq = 0;
1699 wakeup(ray_update_params);
1700
1701 rcmd = ray_start_join_net;
1702 }
1703 return (rcmd);
1704 }
1705
1706 /*
1707 * check too see if we have any pending commands.
1708 */
1709 static void
1710 ray_check_scheduled(void *arg)
1711 {
1712 struct ray_softc *sc;
1713 int s, i, mask;
1714
1715 s = splnet();
1716
1717 sc = arg;
1718 RAY_DPRINTF((
1719 "%s: ray_check_scheduled enter schd 0x%x running 0x%x ready %d\n",
1720 device_xname(&sc->sc_dev), sc->sc_scheduled, sc->sc_running, RAY_ECF_READY(sc)));
1721
1722 if (sc->sc_timoneed) {
1723 callout_stop(&sc->sc_check_scheduled_ch);
1724 sc->sc_timoneed = 0;
1725 }
1726
1727 /* if update subcmd is running -- clear it in scheduled */
1728 if (sc->sc_running & SCP_UPDATESUBCMD)
1729 sc->sc_scheduled &= ~SCP_UPDATESUBCMD;
1730
1731 mask = SCP_FIRST;
1732 for (i = 0; i < ray_ncmdtab; mask <<= 1, i++) {
1733 if ((sc->sc_scheduled & ~SCP_UPD_MASK) == 0)
1734 break;
1735 if (!RAY_ECF_READY(sc))
1736 break;
1737 if (sc->sc_scheduled & mask)
1738 (*ray_cmdtab[i])(sc);
1739 }
1740
1741 RAY_DPRINTF((
1742 "%s: ray_check_scheduled exit sched 0x%x running 0x%x ready %d\n",
1743 device_xname(&sc->sc_dev), sc->sc_scheduled, sc->sc_running, RAY_ECF_READY(sc)));
1744
1745 if (sc->sc_scheduled & ~SCP_UPD_MASK)
1746 ray_set_pending(sc, sc->sc_scheduled);
1747
1748 splx(s);
1749 }
1750
1751 /*
1752 * check for unreported returns
1753 *
1754 * this routine is coded to only expect one outstanding request for the
1755 * timed out requests at a time, but thats all that can be outstanding
1756 * per hardware limitations
1757 */
1758 static void
1759 ray_check_ccs(void *arg)
1760 {
1761 ray_cmd_func_t fp;
1762 struct ray_softc *sc;
1763 u_int i, cmd, stat = 0;
1764 bus_size_t ccs = 0;
1765 int s;
1766
1767 s = splnet();
1768 sc = arg;
1769
1770 RAY_DPRINTF(("%s: ray_check_ccs\n", device_xname(&sc->sc_dev)));
1771
1772 sc->sc_timocheck = 0;
1773 for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) {
1774 if (!sc->sc_ccsinuse[i])
1775 continue;
1776 ccs = RAY_GET_CCS(i);
1777 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
1778 switch (cmd) {
1779 case RAY_CMD_START_PARAMS:
1780 case RAY_CMD_UPDATE_MCAST:
1781 case RAY_CMD_UPDATE_PARAMS:
1782 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
1783 RAY_DPRINTF(("%s: check ccs idx %u ccs 0x%llx "
1784 "cmd 0x%x stat %u\n", device_xname(&sc->sc_dev), i,
1785 (unsigned long long)ccs, cmd, stat));
1786 goto breakout;
1787 }
1788 }
1789 breakout:
1790 /* see if we got one of the commands we are looking for */
1791 if (i > RAY_CCS_CMD_LAST)
1792 ; /* nothing */
1793 else if (stat == RAY_CCS_STATUS_FREE) {
1794 stat = RAY_CCS_STATUS_COMPLETE;
1795 if ((fp = ray_ccs_done(sc, ccs)))
1796 (*fp)(sc);
1797 } else if (stat != RAY_CCS_STATUS_BUSY) {
1798 if (sc->sc_ccsinuse[i] == 1) {
1799 /* give a chance for the interrupt to occur */
1800 sc->sc_ccsinuse[i] = 2;
1801 if (!sc->sc_timocheck) {
1802 callout_reset(&sc->sc_check_ccs_ch, 1,
1803 ray_check_ccs, sc);
1804 sc->sc_timocheck = 1;
1805 }
1806 } else if ((fp = ray_ccs_done(sc, ccs)))
1807 (*fp)(sc);
1808 } else {
1809 callout_reset(&sc->sc_check_ccs_ch, RAY_CHECK_CCS_TIMEOUT,
1810 ray_check_ccs, sc);
1811 sc->sc_timocheck = 1;
1812 }
1813 splx(s);
1814 }
1815
1816 /*
1817 * read the counters, the card implements the following protocol
1818 * to keep the values from being changed while read: It checks
1819 * the `own' bit and if zero writes the current internal counter
1820 * value, it then sets the `own' bit to 1. If the `own' bit was 1 it
1821 * increments its internal counter. The user thus reads the counter
1822 * if the `own' bit is one and then sets the own bit to 0.
1823 */
1824 static void
1825 ray_update_error_counters(struct ray_softc *sc)
1826 {
1827 bus_size_t csc;
1828
1829 /* try and update the error counters */
1830 csc = RAY_STATUS_BASE;
1831 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxo_own)) {
1832 sc->sc_rxoverflow +=
1833 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
1834 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxo_own, 0);
1835 }
1836 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxc_own)) {
1837 sc->sc_rxcksum +=
1838 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
1839 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxc_own, 0);
1840 }
1841 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rxhc_own)) {
1842 sc->sc_rxhcksum +=
1843 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_rx_hcksum);
1844 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_rxhc_own, 0);
1845 }
1846 sc->sc_rxnoise = SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rx_noise);
1847 }
1848
1849 /*
1850 * one of the commands we issued has completed, process.
1851 */
1852 static ray_cmd_func_t
1853 ray_ccs_done(struct ray_softc *sc, bus_size_t ccs)
1854 {
1855 ray_cmd_func_t rcmd;
1856 u_int cmd, stat;
1857
1858 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
1859 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
1860
1861 RAY_DPRINTF(("%s: ray_ccs_done idx %llu cmd 0x%x stat %u\n",
1862 device_xname(&sc->sc_dev), (unsigned long long)RAY_GET_INDEX(ccs), cmd, stat));
1863
1864 rcmd = 0;
1865 switch (cmd) {
1866 /*
1867 * solicited commands
1868 */
1869 case RAY_CMD_START_PARAMS:
1870 /* start network */
1871 ray_cmd_done(sc, SCP_UPD_STARTUP);
1872
1873 /* ok to start queueing packets */
1874 sc->sc_if.if_flags &= ~IFF_OACTIVE;
1875
1876 sc->sc_omode = sc->sc_mode;
1877 memcpy(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid));
1878
1879 rcmd = ray_start_join_net;
1880 break;
1881 case RAY_CMD_UPDATE_PARAMS:
1882 rcmd = ray_update_params_done(sc, ccs, stat);
1883 break;
1884 case RAY_CMD_REPORT_PARAMS:
1885 /* get the reported parameters */
1886 ray_cmd_done(sc, SCP_REPORTPARAMS);
1887 if (!sc->sc_repreq)
1888 break;
1889 sc->sc_repreq->r_failcause =
1890 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_failcause);
1891 sc->sc_repreq->r_len =
1892 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_len);
1893 ray_read_region(sc, RAY_ECF_TO_HOST_BASE, sc->sc_repreq->r_data,
1894 sc->sc_repreq->r_len);
1895 sc->sc_repreq = 0;
1896 wakeup(ray_report_params);
1897 break;
1898 case RAY_CMD_UPDATE_MCAST:
1899 ray_cmd_done(sc, SCP_UPD_MCAST);
1900 if (stat == RAY_CCS_STATUS_FAIL)
1901 rcmd = ray_reset;
1902 break;
1903 case RAY_CMD_START_NET:
1904 case RAY_CMD_JOIN_NET:
1905 rcmd = ray_start_join_net_done(sc, cmd, ccs, stat);
1906 break;
1907 case RAY_CMD_TX_REQ:
1908 if (sc->sc_if.if_flags & IFF_OACTIVE) {
1909 sc->sc_if.if_flags &= ~IFF_OACTIVE;
1910 /* this may also be a problem */
1911 rcmd = ray_intr_start;
1912 }
1913 /* free it -- no tracking */
1914 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status,
1915 RAY_CCS_STATUS_FREE);
1916 goto done;
1917 case RAY_CMD_START_ASSOC:
1918 ray_cmd_done(sc, SCP_STARTASSOC);
1919 if (stat == RAY_CCS_STATUS_FAIL)
1920 rcmd = ray_start_join_net; /* XXX check */
1921 else {
1922 sc->sc_havenet = 1;
1923 rcmd = ray_intr_start;
1924 }
1925 break;
1926 case RAY_CMD_UPDATE_APM:
1927 case RAY_CMD_TEST_MEM:
1928 case RAY_CMD_SHUTDOWN:
1929 case RAY_CMD_DUMP_MEM:
1930 case RAY_CMD_START_TIMER:
1931 break;
1932 default:
1933 printf("%s: intr: unknown command 0x%x\n",
1934 sc->sc_if.if_xname, cmd);
1935 break;
1936 }
1937 ray_free_ccs(sc, ccs);
1938 done:
1939 /*
1940 * see if needed things can be done now that a command
1941 * has completed
1942 */
1943 ray_check_scheduled(sc);
1944
1945 return (rcmd);
1946 }
1947
1948 /*
1949 * an unsolicited interrupt, i.e., the ECF is sending us a command
1950 */
1951 static ray_cmd_func_t
1952 ray_rccs_intr(struct ray_softc *sc, bus_size_t ccs)
1953 {
1954 ray_cmd_func_t rcmd;
1955 u_int cmd, stat;
1956
1957 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
1958 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
1959
1960 RAY_DPRINTF(("%s: ray_rccs_intr idx %llu cmd 0x%x stat %u\n",
1961 device_xname(&sc->sc_dev), (unsigned long long)RAY_GET_INDEX(ccs), cmd, stat));
1962
1963 rcmd = 0;
1964 switch (cmd) {
1965 /*
1966 * unsolicited commands
1967 */
1968 case RAY_ECMD_RX_DONE:
1969 ray_recv(sc, ccs);
1970 goto done;
1971 case RAY_ECMD_REJOIN_DONE:
1972 if (sc->sc_mode == SC_MODE_ADHOC)
1973 break;
1974 /* get the current ssid */
1975 SRAM_READ_FIELD_N(sc, ccs, ray_cmd_net, c_bss_id,
1976 sc->sc_bssid, sizeof(sc->sc_bssid));
1977 rcmd = ray_start_assoc;
1978 break;
1979 case RAY_ECMD_ROAM_START:
1980 /* no longer have network */
1981 sc->sc_havenet = 0;
1982 break;
1983 case RAY_ECMD_JAPAN_CALL_SIGNAL:
1984 break;
1985 default:
1986 ray_update_error_counters(sc);
1987
1988 /* this is a bogus return from build 4 don't free 0x55 */
1989 if (sc->sc_version == SC_BUILD_4 && cmd == 0x55
1990 && RAY_GET_INDEX(ccs) == 0x55) {
1991 goto done;
1992 }
1993 printf("%s: intr: unknown command 0x%x\n",
1994 sc->sc_if.if_xname, cmd);
1995 break;
1996 }
1997 /* free the ccs */
1998 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE);
1999 done:
2000 return (rcmd);
2001 }
2002
2003 /*
2004 * process an interrupt
2005 */
2006 static int
2007 ray_intr(void *arg)
2008 {
2009 struct ray_softc *sc;
2010 ray_cmd_func_t rcmd;
2011 u_int i, count;
2012
2013 sc = arg;
2014
2015 RAY_DPRINTF(("%s: ray_intr\n", device_xname(&sc->sc_dev)));
2016
2017 if ((++sc->sc_checkcounters % 32) == 0)
2018 ray_update_error_counters(sc);
2019
2020 count = 0;
2021 rcmd = 0;
2022 if (!REG_READ(sc, RAY_HCSIR))
2023 count = 0;
2024 else {
2025 count = 1;
2026 i = SRAM_READ_1(sc, RAY_SCB_RCCSI);
2027 if (i <= RAY_CCS_LAST)
2028 rcmd = ray_ccs_done(sc, RAY_GET_CCS(i));
2029 else if (i <= RAY_RCCS_LAST)
2030 rcmd = ray_rccs_intr(sc, RAY_GET_CCS(i));
2031 else
2032 printf("%s: intr: bad cmd index %d\n", device_xname(&sc->sc_dev), i);
2033 }
2034
2035 if (rcmd)
2036 (*rcmd)(sc);
2037
2038 if (count)
2039 REG_WRITE(sc, RAY_HCSIR, 0);
2040
2041 RAY_DPRINTF(("%s: interrupt handled %d\n", device_xname(&sc->sc_dev), count));
2042
2043 return (count ? 1 : 0);
2044 }
2045
2046
2047 /*
2048 * Generic CCS handling
2049 */
2050
2051 /*
2052 * free the chain of descriptors -- used for freeing allocated tx chains
2053 */
2054 static void
2055 ray_free_ccs_chain(struct ray_softc *sc, u_int ni)
2056 {
2057 u_int i;
2058
2059 while ((i = ni) != RAY_CCS_LINK_NULL) {
2060 ni = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_link);
2061 SRAM_WRITE_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status,
2062 RAY_CCS_STATUS_FREE);
2063 }
2064 }
2065
2066 /*
2067 * free up a cmd and return the old status
2068 * this routine is only used for commands
2069 */
2070 static u_int8_t
2071 ray_free_ccs(struct ray_softc *sc, bus_size_t ccs)
2072 {
2073 u_int8_t stat;
2074
2075 RAY_DPRINTF(("%s: free_ccs idx %llu\n", device_xname(&sc->sc_dev),
2076 (unsigned long long)RAY_GET_INDEX(ccs)));
2077
2078 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
2079 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE);
2080 if (ccs <= RAY_GET_CCS(RAY_CCS_LAST))
2081 sc->sc_ccsinuse[RAY_GET_INDEX(ccs)] = 0;
2082
2083 return (stat);
2084 }
2085
2086 /*
2087 * returns 1 and in `ccb' the bus offset of the free ccb
2088 * or 0 if none are free
2089 *
2090 * If `track' is not zero, handles tracking this command
2091 * possibly indicating a callback is needed and setting a timeout
2092 * also if ECF isn't ready we terminate earlier to avoid overhead.
2093 *
2094 * this routine is only used for commands
2095 */
2096 static int
2097 ray_alloc_ccs(struct ray_softc *sc, bus_size_t *ccsp, u_int cmd, u_int track)
2098 {
2099 bus_size_t ccs;
2100 u_int i;
2101
2102 RAY_DPRINTF(("%s: alloc_ccs cmd %d\n", device_xname(&sc->sc_dev), cmd));
2103
2104 /* for tracked commands, if not ready just set pending */
2105 if (track && !RAY_ECF_READY(sc)) {
2106 ray_cmd_schedule(sc, track);
2107 return (0);
2108 }
2109
2110 /* first scan our inuse array */
2111 for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) {
2112 /* XXX wonder if we have to probe here to make the card go */
2113 (void)SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status);
2114 if (!sc->sc_ccsinuse[i])
2115 break;
2116 }
2117 if (i > RAY_CCS_CMD_LAST) {
2118 if (track)
2119 ray_cmd_schedule(sc, track);
2120 return (0);
2121 }
2122 sc->sc_ccsinuse[i] = 1;
2123 ccs = RAY_GET_CCS(i);
2124 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_BUSY);
2125 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_cmd, cmd);
2126 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_link, RAY_CCS_LINK_NULL);
2127
2128 *ccsp = ccs;
2129 return (1);
2130 }
2131
2132
2133 /*
2134 * this function sets the pending bit for the command given in 'need'
2135 * and schedules a timeout if none is scheduled already. Any command
2136 * that uses the `host to ecf' region must be serialized.
2137 */
2138 static void
2139 ray_set_pending(struct ray_softc *sc, u_int cmdf)
2140 {
2141 RAY_DPRINTF(("%s: ray_set_pending 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2142
2143 sc->sc_scheduled |= cmdf;
2144 if (!sc->sc_timoneed) {
2145 RAY_DPRINTF(("%s: ray_set_pending new timo\n", device_xname(&sc->sc_dev)));
2146 callout_reset(&sc->sc_check_scheduled_ch,
2147 RAY_CHECK_SCHED_TIMEOUT, ray_check_scheduled, sc);
2148 sc->sc_timoneed = 1;
2149 }
2150 }
2151
2152 /*
2153 * schedule the `cmdf' for completion later
2154 */
2155 static void
2156 ray_cmd_schedule(struct ray_softc *sc, int cmdf)
2157 {
2158 int track;
2159
2160 RAY_DPRINTF(("%s: ray_cmd_schedule 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2161
2162 track = cmdf;
2163 if ((cmdf & SCP_UPD_MASK) == 0)
2164 ray_set_pending(sc, track);
2165 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
2166 /* don't do timeout mechanism if subcmd already going */
2167 sc->sc_scheduled |= cmdf;
2168 } else
2169 ray_set_pending(sc, cmdf | SCP_UPDATESUBCMD);
2170 }
2171
2172 /*
2173 * check to see if `cmdf' has been scheduled
2174 */
2175 static int
2176 ray_cmd_is_scheduled(struct ray_softc *sc, int cmdf)
2177 {
2178 RAY_DPRINTF(("%s: ray_cmd_is_scheduled 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2179
2180 return ((sc->sc_scheduled & cmdf) ? 1 : 0);
2181 }
2182
2183 /*
2184 * cancel a scheduled command (not a running one though!)
2185 */
2186 static void
2187 ray_cmd_cancel(struct ray_softc *sc, int cmdf)
2188 {
2189 RAY_DPRINTF(("%s: ray_cmd_cancel 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2190
2191 sc->sc_scheduled &= ~cmdf;
2192 if ((cmdf & SCP_UPD_MASK) && (sc->sc_scheduled & SCP_UPD_MASK) == 0)
2193 sc->sc_scheduled &= ~SCP_UPDATESUBCMD;
2194
2195 /* if nothing else needed cancel the timer */
2196 if (sc->sc_scheduled == 0 && sc->sc_timoneed) {
2197 callout_stop(&sc->sc_check_scheduled_ch);
2198 sc->sc_timoneed = 0;
2199 }
2200 }
2201
2202 /*
2203 * called to indicate the 'cmdf' has been issued
2204 */
2205 static void
2206 ray_cmd_ran(struct ray_softc *sc, int cmdf)
2207 {
2208 RAY_DPRINTF(("%s: ray_cmd_ran 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2209
2210 if (cmdf & SCP_UPD_MASK)
2211 sc->sc_running |= cmdf | SCP_UPDATESUBCMD;
2212 else
2213 sc->sc_running |= cmdf;
2214
2215 if ((cmdf & SCP_TIMOCHECK_CMD_MASK) && !sc->sc_timocheck) {
2216 callout_reset(&sc->sc_check_ccs_ch, RAY_CHECK_CCS_TIMEOUT,
2217 ray_check_ccs, sc);
2218 sc->sc_timocheck = 1;
2219 }
2220 }
2221
2222 /*
2223 * check to see if `cmdf' has been issued
2224 */
2225 static int
2226 ray_cmd_is_running(struct ray_softc *sc, int cmdf)
2227 {
2228 RAY_DPRINTF(("%s: ray_cmd_is_running 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2229
2230 return ((sc->sc_running & cmdf) ? 1 : 0);
2231 }
2232
2233 /*
2234 * the given `cmdf' that was issued has completed
2235 */
2236 static void
2237 ray_cmd_done(struct ray_softc *sc, int cmdf)
2238 {
2239 RAY_DPRINTF(("%s: ray_cmd_done 0x%x\n", device_xname(&sc->sc_dev), cmdf));
2240
2241 sc->sc_running &= ~cmdf;
2242 if (cmdf & SCP_UPD_MASK) {
2243 sc->sc_running &= ~SCP_UPDATESUBCMD;
2244 if (sc->sc_scheduled & SCP_UPD_MASK)
2245 ray_cmd_schedule(sc, sc->sc_scheduled & SCP_UPD_MASK);
2246 }
2247 if ((sc->sc_running & SCP_TIMOCHECK_CMD_MASK) == 0 && sc->sc_timocheck){
2248 callout_stop(&sc->sc_check_ccs_ch);
2249 sc->sc_timocheck = 0;
2250 }
2251 }
2252
2253 /*
2254 * issue the command
2255 * only used for commands not tx
2256 */
2257 static int
2258 ray_issue_cmd(struct ray_softc *sc, bus_size_t ccs, u_int track)
2259 {
2260 u_int i;
2261
2262 RAY_DPRINTF(("%s: ray_cmd_issue 0x%x\n", device_xname(&sc->sc_dev), track));
2263
2264 /*
2265 * XXX other drivers did this, but I think
2266 * what we really want to do is just make sure we don't
2267 * get here or that spinning is ok
2268 */
2269 i = 0;
2270 while (!RAY_ECF_READY(sc))
2271 if (++i > 50) {
2272 ray_free_ccs(sc, ccs);
2273 if (track)
2274 ray_cmd_schedule(sc, track);
2275 return (0);
2276 }
2277
2278 SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_GET_INDEX(ccs));
2279 RAY_ECF_START_CMD(sc);
2280 ray_cmd_ran(sc, track);
2281
2282 return (1);
2283 }
2284
2285 /*
2286 * send a simple command if we can
2287 */
2288 static int
2289 ray_simple_cmd(struct ray_softc *sc, u_int cmd, u_int track)
2290 {
2291 bus_size_t ccs;
2292
2293 return (ray_alloc_ccs(sc, &ccs, cmd, track) &&
2294 ray_issue_cmd(sc, ccs, track));
2295 }
2296
2297 /*
2298 * Functions based on CCS commands
2299 */
2300
2301 /*
2302 * run a update subcommand
2303 */
2304 static void
2305 ray_update_subcmd(struct ray_softc *sc)
2306 {
2307 int submask, i;
2308
2309 RAY_DPRINTF(("%s: ray_update_subcmd\n", device_xname(&sc->sc_dev)));
2310
2311 ray_cmd_cancel(sc, SCP_UPDATESUBCMD);
2312 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2313 return;
2314 submask = SCP_UPD_FIRST;
2315 for (i = 0; i < ray_nsubcmdtab; submask <<= 1, i++) {
2316 if ((sc->sc_scheduled & SCP_UPD_MASK) == 0)
2317 break;
2318 /* when done the next command will be scheduled */
2319 if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD))
2320 break;
2321 if (!RAY_ECF_READY(sc))
2322 break;
2323 /*
2324 * give priority to LSB -- e.g., if previous loop rescheduled
2325 * doing this command after calling the function won't catch
2326 * if a later command sets an earlier bit
2327 */
2328 if (sc->sc_scheduled & ((submask - 1) & SCP_UPD_MASK))
2329 break;
2330 if (sc->sc_scheduled & submask)
2331 (*ray_subcmdtab[i])(sc);
2332 }
2333 }
2334
2335 /*
2336 * report a parameter
2337 */
2338 static void
2339 ray_report_params(struct ray_softc *sc)
2340 {
2341 bus_size_t ccs;
2342
2343 ray_cmd_cancel(sc, SCP_REPORTPARAMS);
2344
2345 if (!sc->sc_repreq)
2346 return;
2347
2348 /* do the issue check before equality check */
2349 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2350 return;
2351 else if (ray_cmd_is_running(sc, SCP_REPORTPARAMS)) {
2352 ray_cmd_schedule(sc, SCP_REPORTPARAMS);
2353 return;
2354 } else if (!ray_alloc_ccs(sc, &ccs, RAY_CMD_REPORT_PARAMS,
2355 SCP_REPORTPARAMS))
2356 return;
2357
2358 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_report, c_paramid,
2359 sc->sc_repreq->r_paramid);
2360 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_report, c_nparam, 1);
2361 (void)ray_issue_cmd(sc, ccs, SCP_REPORTPARAMS);
2362 }
2363
2364 /*
2365 * start an association
2366 */
2367 static void
2368 ray_start_assoc(struct ray_softc *sc)
2369 {
2370 ray_cmd_cancel(sc, SCP_STARTASSOC);
2371 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2372 return;
2373 else if (ray_cmd_is_running(sc, SCP_STARTASSOC))
2374 return;
2375 (void)ray_simple_cmd(sc, RAY_CMD_START_ASSOC, SCP_STARTASSOC);
2376 }
2377
2378 /*
2379 * Subcommand functions that use the SCP_UPDATESUBCMD command
2380 * (and are serialized with respect to other update sub commands
2381 */
2382
2383 /*
2384 * download the startup parameters to the card
2385 * -- no outstanding commands expected
2386 */
2387 static void
2388 ray_download_params(struct ray_softc *sc)
2389 {
2390 struct ray_startup_params_head *sp;
2391 struct ray_startup_params_tail_5 *sp5;
2392 struct ray_startup_params_tail_4 *sp4;
2393 bus_size_t off;
2394
2395 RAY_DPRINTF(("%s: init_startup_params\n", device_xname(&sc->sc_dev)));
2396
2397 ray_cmd_cancel(sc, SCP_UPD_STARTUP);
2398
2399 #define PUT2(p, v) \
2400 do { (p)[0] = ((v >> 8) & 0xff); (p)[1] = (v & 0xff); } while(0)
2401
2402 sp = &sc->sc_startup;
2403 sp4 = &sc->sc_startup_4;
2404 sp5 = &sc->sc_startup_5;
2405 memset(sp, 0, sizeof(*sp));
2406 if (sc->sc_version == SC_BUILD_4)
2407 memset(sp4, 0, sizeof(*sp4));
2408 else
2409 memset(sp5, 0, sizeof(*sp5));
2410 /* XXX: Raylink firmware doesn't have length field for ssid */
2411 memcpy(sp->sp_ssid, sc->sc_dnwid.i_nwid, sizeof(sp->sp_ssid));
2412 sp->sp_scan_mode = 0x1;
2413 memcpy(sp->sp_mac_addr, sc->sc_ecf_startup.e_station_addr,
2414 ETHER_ADDR_LEN);
2415 PUT2(sp->sp_frag_thresh, 0x7fff); /* disabled */
2416 if (sc->sc_version == SC_BUILD_4) {
2417 #if 1
2418 /* linux/fbsd */
2419 PUT2(sp->sp_dwell_time, 0x200);
2420 PUT2(sp->sp_beacon_period, 1);
2421 #else
2422 /* divined */
2423 PUT2(sp->sp_dwell_time, 0x400);
2424 PUT2(sp->sp_beacon_period, 0);
2425 #endif
2426 } else {
2427 PUT2(sp->sp_dwell_time, 128);
2428 PUT2(sp->sp_beacon_period, 256);
2429 }
2430 sp->sp_dtim_interval = 1;
2431 #if 0
2432 /* these are the documented defaults for build 5/6 */
2433 sp->sp_max_retry = 0x1f;
2434 sp->sp_ack_timo = 0x86;
2435 sp->sp_sifs = 0x1c;
2436 #elif 1
2437 /* these were scrounged from the linux driver */
2438 sp->sp_max_retry = 0x07;
2439
2440 sp->sp_ack_timo = 0xa3;
2441 sp->sp_sifs = 0x1d;
2442 #else
2443 /* these were divined */
2444 sp->sp_max_retry = 0x03;
2445
2446 sp->sp_ack_timo = 0xa3;
2447 sp->sp_sifs = 0x1d;
2448 #endif
2449 #if 0
2450 /* these are the documented defaults for build 5/6 */
2451 sp->sp_difs = 0x82;
2452 sp->sp_pifs = 0;
2453 #else
2454 /* linux/fbsd */
2455 sp->sp_difs = 0x82;
2456
2457 if (sc->sc_version == SC_BUILD_4)
2458 sp->sp_pifs = 0xce;
2459 else
2460 sp->sp_pifs = 0x4e;
2461 #endif
2462
2463 PUT2(sp->sp_rts_thresh, 0x7fff); /* disabled */
2464 if (sc->sc_version == SC_BUILD_4) {
2465 PUT2(sp->sp_scan_dwell, 0xfb1e);
2466 PUT2(sp->sp_scan_max_dwell, 0xc75c);
2467 } else {
2468 PUT2(sp->sp_scan_dwell, 0x4e2);
2469 PUT2(sp->sp_scan_max_dwell, 0x38a4);
2470 }
2471 sp->sp_assoc_timo = 0x5;
2472 if (sc->sc_version == SC_BUILD_4) {
2473 #if 0
2474 /* linux/fbsd */
2475 sp->sp_adhoc_scan_cycle = 0x4;
2476 sp->sp_infra_scan_cycle = 0x2;
2477 sp->sp_infra_super_scan_cycle = 0x4;
2478 #else
2479 /* divined */
2480 sp->sp_adhoc_scan_cycle = 0x8;
2481 sp->sp_infra_scan_cycle = 0x1;
2482 sp->sp_infra_super_scan_cycle = 0x18;
2483 #endif
2484 } else {
2485 sp->sp_adhoc_scan_cycle = 0x8;
2486 sp->sp_infra_scan_cycle = 0x2;
2487 sp->sp_infra_super_scan_cycle = 0x8;
2488 }
2489 sp->sp_promisc = sc->sc_promisc;
2490 PUT2(sp->sp_uniq_word, 0x0cbd);
2491 if (sc->sc_version == SC_BUILD_4) {
2492 /* XXX what is this value anyway..? the std says 50us */
2493 /* XXX sp->sp_slot_time = 0x4e; */
2494 sp->sp_slot_time = 0x4e;
2495 #if 1
2496 /*linux/fbsd*/
2497 sp->sp_roam_low_snr_thresh = 0xff;
2498 #else
2499 /*divined*/
2500 sp->sp_roam_low_snr_thresh = 0x30;
2501 #endif
2502 } else {
2503 sp->sp_slot_time = 0x32;
2504 sp->sp_roam_low_snr_thresh = 0xff; /* disabled */
2505 }
2506 #if 1
2507 sp->sp_low_snr_count = 0xff; /* disabled */
2508 #else
2509 /* divined -- check */
2510 sp->sp_low_snr_count = 0x07; /* disabled */
2511 #endif
2512 #if 0
2513 sp->sp_infra_missed_beacon_count = 0x2;
2514 #elif 1
2515 /* linux/fbsd */
2516 sp->sp_infra_missed_beacon_count = 0x5;
2517 #else
2518 /* divined -- check, looks fishy */
2519 sp->sp_infra_missed_beacon_count = 0x7;
2520 #endif
2521 sp->sp_adhoc_missed_beacon_count = 0xff;
2522 sp->sp_country_code = sc->sc_dcountrycode;
2523 sp->sp_hop_seq = 0x0b;
2524 if (sc->sc_version == SC_BUILD_4) {
2525 sp->sp_hop_seq_len = 0x4e;
2526 sp4->sp_cw_max = 0x3f; /* single byte on build 4 */
2527 sp4->sp_cw_min = 0x0f; /* single byte on build 4 */
2528 sp4->sp_noise_filter_gain = 0x4;
2529 sp4->sp_noise_limit_offset = 0x8;
2530 sp4->sp_rssi_thresh_offset = 0x28;
2531 sp4->sp_busy_thresh_offset = 0x28;
2532 sp4->sp_sync_thresh = 0x07;
2533 sp4->sp_test_mode = 0x0;
2534 sp4->sp_test_min_chan = 0x2;
2535 sp4->sp_test_max_chan = 0x2;
2536 } else {
2537 sp->sp_hop_seq_len = 0x4f;
2538 PUT2(sp5->sp_cw_max, 0x3f);
2539 PUT2(sp5->sp_cw_min, 0x0f);
2540 sp5->sp_noise_filter_gain = 0x4;
2541 sp5->sp_noise_limit_offset = 0x8;
2542 sp5->sp_rssi_thresh_offset = 0x28;
2543 sp5->sp_busy_thresh_offset = 0x28;
2544 sp5->sp_sync_thresh = 0x07;
2545 sp5->sp_test_mode = 0x0;
2546 sp5->sp_test_min_chan = 0x2;
2547 sp5->sp_test_max_chan = 0x2;
2548 #if 0
2549 sp5->sp_allow_probe_resp = 0x1;
2550 #else
2551 sp5->sp_allow_probe_resp = 0x0;
2552 #endif
2553 sp5->sp_privacy_must_start = 0x0;
2554 sp5->sp_privacy_can_join = 0x0;
2555 sp5->sp_basic_rate_set[0] = 0x2;
2556 /* 2 = 1Mbps, 3 = old 2Mbps 4 = 2Mbps */
2557 }
2558
2559 /* we shouldn't be called with some command pending */
2560 if (!RAY_ECF_READY(sc))
2561 panic("ray_download_params busy");
2562
2563 /* write the compatible part */
2564 off = RAY_HOST_TO_ECF_BASE;
2565 ray_write_region(sc, off, sp, sizeof(sc->sc_startup));
2566 off += sizeof(sc->sc_startup);
2567 if (sc->sc_version == SC_BUILD_4)
2568 ray_write_region(sc, off, sp4, sizeof(*sp4));
2569 else
2570 ray_write_region(sc, off, sp5, sizeof(*sp5));
2571 if (!ray_simple_cmd(sc, RAY_CMD_START_PARAMS, SCP_UPD_STARTUP))
2572 panic("ray_download_params issue");
2573 }
2574
2575 /*
2576 * start or join a network
2577 */
2578 static void
2579 ray_start_join_net(struct ray_softc *sc)
2580 {
2581 struct ray_net_params np;
2582 bus_size_t ccs;
2583 int cmd;
2584
2585 ray_cmd_cancel(sc, SCP_UPD_STARTJOIN);
2586 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2587 return;
2588
2589 /* XXX check we may not want to re-issue */
2590 if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
2591 ray_cmd_schedule(sc, SCP_UPD_STARTJOIN);
2592 return;
2593 }
2594
2595 if (sc->sc_mode == SC_MODE_ADHOC)
2596 cmd = RAY_CMD_START_NET;
2597 else
2598 cmd = RAY_CMD_JOIN_NET;
2599
2600 if (!ray_alloc_ccs(sc, &ccs, cmd, SCP_UPD_STARTJOIN))
2601 return;
2602 sc->sc_startccs = ccs;
2603 sc->sc_startcmd = cmd;
2604 if (!memcmp(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid))
2605 && sc->sc_omode == sc->sc_mode)
2606 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 0);
2607 else {
2608 sc->sc_havenet = 0;
2609 memset(&np, 0, sizeof(np));
2610 np.p_net_type = sc->sc_mode;
2611 memcpy(np.p_ssid, sc->sc_dnwid.i_nwid, sizeof(np.p_ssid));
2612 ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np));
2613 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 1);
2614 }
2615 if (ray_issue_cmd(sc, ccs, SCP_UPD_STARTJOIN))
2616 callout_reset(&sc->sc_start_join_timo_ch, RAY_START_TIMEOUT,
2617 ray_start_join_timo, sc);
2618 }
2619
2620 static void
2621 ray_start_join_timo(void *arg)
2622 {
2623 struct ray_softc *sc;
2624 u_int stat;
2625
2626 sc = arg;
2627 stat = SRAM_READ_FIELD_1(sc, sc->sc_startccs, ray_cmd, c_status);
2628 ray_start_join_net_done(sc, sc->sc_startcmd, sc->sc_startccs, stat);
2629 }
2630
2631 /*
2632 * The start/join has completed. Note: we timeout the start
2633 * command because it seems to fail to work at least on the
2634 * build 4 firmware without reporting an error. This actually
2635 * may be a result of not putting the correct params in the
2636 * initial download. If this is a timeout `stat' will be
2637 * marked busy.
2638 */
2639 static ray_cmd_func_t
2640 ray_start_join_net_done(struct ray_softc *sc, u_int cmd, bus_size_t ccs, u_int stat)
2641 {
2642 int i;
2643 struct ray_net_params np;
2644
2645 callout_stop(&sc->sc_start_join_timo_ch);
2646 ray_cmd_done(sc, SCP_UPD_STARTJOIN);
2647
2648 if (stat == RAY_CCS_STATUS_FAIL) {
2649 /* XXX poke ifmedia when it supports this */
2650 sc->sc_havenet = 0;
2651 return (ray_start_join_net);
2652 }
2653 if (stat == RAY_CCS_STATUS_BUSY || stat == RAY_CCS_STATUS_FREE) {
2654 /* handle the timeout condition */
2655 callout_reset(&sc->sc_start_join_timo_ch, RAY_START_TIMEOUT,
2656 ray_start_join_timo, sc);
2657
2658 /* be safe -- not a lot occurs with no net though */
2659 if (!RAY_ECF_READY(sc))
2660 return (0);
2661
2662 /* see if our nwid is up to date */
2663 if (!memcmp(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid))
2664 && sc->sc_omode == sc->sc_mode)
2665 SRAM_WRITE_FIELD_1(sc,ccs, ray_cmd_net, c_upd_param, 0);
2666 else {
2667 memset(&np, 0, sizeof(np));
2668 np.p_net_type = sc->sc_mode;
2669 memcpy(np.p_ssid, sc->sc_dnwid.i_nwid,
2670 sizeof(np.p_ssid));
2671 ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &np,
2672 sizeof(np));
2673 SRAM_WRITE_FIELD_1(sc,ccs, ray_cmd_net, c_upd_param, 1);
2674 }
2675
2676 if (sc->sc_mode == SC_MODE_ADHOC)
2677 cmd = RAY_CMD_START_NET;
2678 else
2679 cmd = RAY_CMD_JOIN_NET;
2680 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_cmd,
2681 RAY_CCS_STATUS_BUSY);
2682 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_status,
2683 RAY_CCS_STATUS_BUSY);
2684
2685 /* we simply poke the card again issuing the same ccs */
2686 SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_GET_INDEX(ccs));
2687 RAY_ECF_START_CMD(sc);
2688 ray_cmd_ran(sc, SCP_UPD_STARTJOIN);
2689 return (0);
2690 }
2691 /* get the current ssid */
2692 SRAM_READ_FIELD_N(sc, ccs, ray_cmd_net, c_bss_id, sc->sc_bssid,
2693 sizeof(sc->sc_bssid));
2694
2695 sc->sc_deftxrate = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net,c_def_txrate);
2696 sc->sc_encrypt = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_encrypt);
2697
2698 /* adjust values for buggy build 4 */
2699 if (sc->sc_deftxrate == 0x55)
2700 sc->sc_deftxrate = RAY_PID_BASIC_RATE_1500K;
2701 if (sc->sc_encrypt == 0x55)
2702 sc->sc_encrypt = 0;
2703
2704 if (SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param)) {
2705 ray_read_region(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np));
2706 /* XXX: Raylink firmware doesn't have length field for ssid */
2707 for (i = 0; i < sizeof(np.p_ssid); i++) {
2708 if (np.p_ssid[i] == '\0')
2709 break;
2710 }
2711 sc->sc_cnwid.i_len = i;
2712 memcpy(sc->sc_cnwid.i_nwid, np.p_ssid, sizeof(sc->sc_cnwid));
2713 sc->sc_omode = sc->sc_mode;
2714 if (np.p_net_type != sc->sc_mode)
2715 return (ray_start_join_net);
2716 }
2717 RAY_DPRINTF(("%s: net start/join nwid %.32s bssid %s inited %d\n",
2718 device_xname(&sc->sc_dev), sc->sc_cnwid.i_nwid, ether_sprintf(sc->sc_bssid),
2719 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_inited)));
2720
2721 /* network is now active */
2722 ray_cmd_schedule(sc, SCP_UPD_MCAST|SCP_UPD_PROMISC);
2723 if (cmd == RAY_CMD_JOIN_NET)
2724 return (ray_start_assoc);
2725 else {
2726 sc->sc_havenet = 1;
2727 return (ray_intr_start);
2728 }
2729 }
2730
2731 /*
2732 * set the card in/out of promiscuous mode
2733 */
2734 static void
2735 ray_update_promisc(struct ray_softc *sc)
2736 {
2737 bus_size_t ccs;
2738 int promisc;
2739
2740 ray_cmd_cancel(sc, SCP_UPD_PROMISC);
2741
2742 /* do the issue check before equality check */
2743 if (sc->sc_if.if_flags & IFF_ALLMULTI)
2744 sc->sc_if.if_flags |= IFF_PROMISC;
2745 else if (sc->sc_if.if_pcount == 0)
2746 sc->sc_if.if_flags &= ~IFF_PROMISC;
2747 promisc = !!(sc->sc_if.if_flags & IFF_PROMISC);
2748 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2749 return;
2750 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
2751 ray_cmd_schedule(sc, SCP_UPD_PROMISC);
2752 return;
2753 } else if (promisc == sc->sc_promisc)
2754 return;
2755 else if (!ray_alloc_ccs(sc,&ccs,RAY_CMD_UPDATE_PARAMS, SCP_UPD_PROMISC))
2756 return;
2757 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_paramid, RAY_PID_PROMISC);
2758 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_nparam, 1);
2759 SRAM_WRITE_1(sc, RAY_HOST_TO_ECF_BASE, promisc);
2760 (void)ray_issue_cmd(sc, ccs, SCP_UPD_PROMISC);
2761 }
2762
2763 /*
2764 * update the parameter based on what the user passed in
2765 */
2766 static void
2767 ray_update_params(struct ray_softc *sc)
2768 {
2769 bus_size_t ccs;
2770
2771 ray_cmd_cancel(sc, SCP_UPD_UPDATEPARAMS);
2772 if (!sc->sc_updreq) {
2773 /* XXX do we need to wakeup here? */
2774 return;
2775 }
2776
2777 /* do the issue check before equality check */
2778 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2779 return;
2780 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
2781 ray_cmd_schedule(sc, SCP_UPD_UPDATEPARAMS);
2782 return;
2783 } else if (!ray_alloc_ccs(sc, &ccs, RAY_CMD_UPDATE_PARAMS,
2784 SCP_UPD_UPDATEPARAMS))
2785 return;
2786
2787 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_paramid,
2788 sc->sc_updreq->r_paramid);
2789 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_nparam, 1);
2790 ray_write_region(sc, RAY_HOST_TO_ECF_BASE, sc->sc_updreq->r_data,
2791 sc->sc_updreq->r_len);
2792
2793 (void)ray_issue_cmd(sc, ccs, SCP_UPD_UPDATEPARAMS);
2794 }
2795
2796 /*
2797 * set the multicast filter list
2798 */
2799 static void
2800 ray_update_mcast(struct ray_softc *sc)
2801 {
2802 bus_size_t ccs;
2803 struct ether_multistep step;
2804 struct ether_multi *enm;
2805 struct ethercom *ec;
2806 bus_size_t bufp;
2807 int count;
2808
2809 ec = &sc->sc_ec;
2810 ray_cmd_cancel(sc, SCP_UPD_MCAST);
2811
2812 /* see if we have any ranges */
2813 if ((count = sc->sc_ec.ec_multicnt) < 17) {
2814 ETHER_FIRST_MULTI(step, ec, enm);
2815 while (enm) {
2816 /* see if this is a range */
2817 if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
2818 ETHER_ADDR_LEN)) {
2819 count = 17;
2820 break;
2821 }
2822 ETHER_NEXT_MULTI(step, enm);
2823 }
2824 }
2825
2826 /* track this stuff even when not running */
2827 if (count > 16) {
2828 sc->sc_if.if_flags |= IFF_ALLMULTI;
2829 ray_update_promisc(sc);
2830 return;
2831 } else if (sc->sc_if.if_flags & IFF_ALLMULTI) {
2832 sc->sc_if.if_flags &= ~IFF_ALLMULTI;
2833 ray_update_promisc(sc);
2834 }
2835
2836 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
2837 return;
2838 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
2839 ray_cmd_schedule(sc, SCP_UPD_MCAST);
2840 return;
2841 } else if (!ray_alloc_ccs(sc,&ccs, RAY_CMD_UPDATE_MCAST, SCP_UPD_MCAST))
2842 return;
2843 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update_mcast, c_nmcast, count);
2844 bufp = RAY_HOST_TO_ECF_BASE;
2845 ETHER_FIRST_MULTI(step, ec, enm);
2846 while (enm) {
2847 ray_write_region(sc, bufp, enm->enm_addrlo, ETHER_ADDR_LEN);
2848 bufp += ETHER_ADDR_LEN;
2849 ETHER_NEXT_MULTI(step, enm);
2850 }
2851 (void)ray_issue_cmd(sc, ccs, SCP_UPD_MCAST);
2852 }
2853
2854 /*
2855 * User issued commands
2856 */
2857
2858 /*
2859 * issue an "update params"
2860 *
2861 * expected to be called in sleepable context -- intended for user stuff
2862 */
2863 static int
2864 ray_user_update_params(struct ray_softc *sc, struct ray_param_req *pr)
2865 {
2866 int rv;
2867
2868 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
2869 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
2870 return (EIO);
2871 }
2872
2873 /* wait to be able to issue the command */
2874 rv = 0;
2875 while (ray_cmd_is_running(sc, SCP_UPD_UPDATEPARAMS) ||
2876 ray_cmd_is_scheduled(sc, SCP_UPD_UPDATEPARAMS)) {
2877 rv = tsleep(ray_update_params, 0|PCATCH, "cmd in use", 0);
2878 if (rv)
2879 return (rv);
2880 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
2881 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
2882 return (EIO);
2883 }
2884 }
2885
2886 pr->r_failcause = RAY_FAILCAUSE_WAITING;
2887 sc->sc_updreq = pr;
2888 ray_cmd_schedule(sc, SCP_UPD_UPDATEPARAMS);
2889 ray_check_scheduled(sc);
2890
2891 while (pr->r_failcause == RAY_FAILCAUSE_WAITING)
2892 (void)tsleep(ray_update_params, 0, "waiting cmd", 0);
2893 wakeup(ray_update_params);
2894
2895 return (0);
2896 }
2897
2898 /*
2899 * issue a report params
2900 *
2901 * expected to be called in sleepable context -- intended for user stuff
2902 */
2903 static int
2904 ray_user_report_params(struct ray_softc *sc, struct ray_param_req *pr)
2905 {
2906 int rv;
2907
2908 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
2909 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
2910 return (EIO);
2911 }
2912
2913 /* wait to be able to issue the command */
2914 rv = 0;
2915 while (ray_cmd_is_running(sc, SCP_REPORTPARAMS)
2916 || ray_cmd_is_scheduled(sc, SCP_REPORTPARAMS)) {
2917 rv = tsleep(ray_report_params, 0|PCATCH, "cmd in use", 0);
2918 if (rv)
2919 return (rv);
2920 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
2921 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
2922 return (EIO);
2923 }
2924 }
2925
2926 pr->r_failcause = RAY_FAILCAUSE_WAITING;
2927 sc->sc_repreq = pr;
2928 ray_cmd_schedule(sc, SCP_REPORTPARAMS);
2929 ray_check_scheduled(sc);
2930
2931 while (pr->r_failcause == RAY_FAILCAUSE_WAITING)
2932 (void)tsleep(ray_report_params, 0, "waiting cmd", 0);
2933 wakeup(ray_report_params);
2934
2935 return (0);
2936 }
2937
2938
2939 /*
2940 * this is a temporary wrapper around bus_space_read_region_1
2941 * as it seems to mess with gcc. the line numbers get offset
2942 * presumably this is related to the inline asm on i386.
2943 */
2944
2945 static void
2946 ray_read_region(struct ray_softc *sc, bus_size_t off, void *vp, size_t c)
2947 {
2948 #ifdef RAY_USE_OPTIMIZED_COPY
2949 u_int n2, n4, tmp;
2950 u_int8_t *p;
2951
2952 p = vp;
2953
2954 /* XXX we may be making poor assumptions here but lets hope */
2955 switch ((off|(bus_addr_t)p) & 0x03) {
2956 case 0:
2957 if ((n4 = c / 4)) {
2958 bus_space_read_region_4(sc->sc_memt, sc->sc_memh, off,
2959 p, n4);
2960 tmp = c & ~0x3;
2961 c &= 0x3;
2962 p += tmp;
2963 off += tmp;
2964 }
2965 switch (c) {
2966 case 3:
2967 *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off);
2968 p++, off++;
2969 case 2:
2970 *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off);
2971 p++, off++;
2972 case 1:
2973 *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off);
2974 }
2975 break;
2976 case 2:
2977 if ((n2 = (c >> 1)))
2978 bus_space_read_region_2(sc->sc_memt, sc->sc_memh, off,
2979 p, n2);
2980 if (c & 1) {
2981 c &= ~0x1;
2982 *(p + c) = bus_space_read_1(sc->sc_memt, sc->sc_memh,
2983 off + c);
2984 }
2985 break;
2986 case 1:
2987 case 3:
2988 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, off, p, c);
2989 break;
2990 }
2991 #else
2992 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, off, vp, c);
2993 #endif
2994 }
2995
2996 /*
2997 * this is a temporary wrapper around bus_space_write_region_1
2998 * as it seems to mess with gcc. the line numbers get offset
2999 * presumably this is related to the inline asm on i386.
3000 */
3001 static void
3002 ray_write_region(struct ray_softc *sc, bus_size_t off, void *vp, size_t c)
3003 {
3004 #ifdef RAY_USE_OPTIMIZED_COPY
3005 size_t n2, n4, tmp;
3006 u_int8_t *p;
3007
3008 p = vp;
3009 /* XXX we may be making poor assumptions here but lets hope */
3010 switch ((off|(bus_addr_t)p) & 0x03) {
3011 case 0:
3012 if ((n4 = (c >> 2))) {
3013 bus_space_write_region_4(sc->sc_memt, sc->sc_memh, off,
3014 p, n4);
3015 tmp = c & ~0x3;
3016 c &= 0x3;
3017 p += tmp;
3018 off += tmp;
3019 }
3020 switch (c) {
3021 case 3:
3022 bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p);
3023 p++, off++;
3024 case 2:
3025 bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p);
3026 p++, off++;
3027 case 1:
3028 bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p);
3029 }
3030 break;
3031 case 2:
3032 if ((n2 = (c >> 1)))
3033 bus_space_write_region_2(sc->sc_memt, sc->sc_memh, off,
3034 p, n2);
3035 if (c & 0x1) {
3036 c &= ~0x1;
3037 bus_space_write_1(sc->sc_memt, sc->sc_memh,
3038 off + c, *(p + c));
3039 }
3040 break;
3041 case 1:
3042 case 3:
3043 bus_space_write_region_1(sc->sc_memt, sc->sc_memh, off, p, c);
3044 break;
3045 }
3046 #else
3047 bus_space_write_region_1(sc->sc_memt, sc->sc_memh, off, vp, c);
3048 #endif
3049 }
3050
3051 #ifdef RAY_DEBUG
3052
3053 #define PRINTABLE(c) ((c) >= 0x20 && (c) <= 0x7f)
3054
3055 void
3056 hexdump(const u_int8_t *d, int len, int br, int div, int fl)
3057 {
3058 int i, j, offw, first, tlen, ni, nj, sp;
3059
3060 sp = br / div;
3061 offw = 0;
3062 if (len && (fl & HEXDF_NOOFFSET) == 0) {
3063 tlen = len;
3064 do {
3065 offw++;
3066 } while (tlen /= br);
3067 }
3068 if (offw)
3069 printf("%0*x: ", offw, 0);
3070 for (i = 0; i < len; i++, d++) {
3071 if (i && (i % br) == 0) {
3072 if ((fl & HEXDF_NOASCII) == 0) {
3073 printf(" ");
3074 d -= br;
3075 for (j = 0; j < br; d++, j++) {
3076 if (j && (j % sp) == 0)
3077 printf(" ");
3078 if (PRINTABLE(*d))
3079 printf("%c", (int)*d);
3080 else
3081 printf(".");
3082 }
3083 }
3084 if (offw)
3085 printf("\n%0*x: ", offw, i);
3086 else
3087 printf("\n");
3088 if ((fl & HEXDF_NOCOMPRESS) == 0) {
3089 first = 1;
3090 while (len - i >= br) {
3091 if (memcmp(d, d - br, br))
3092 break;
3093 d += br;
3094 i += br;
3095 if (first) {
3096 printf("*");
3097 first = 0;
3098 }
3099 }
3100 if (len == i) {
3101 printf("\n%0*x", offw, i);
3102 return;
3103 }
3104 }
3105 } else if (i && (i % sp) == 0)
3106 printf(" ");
3107 printf("%02x ", *d);
3108 }
3109 if (len && (((i - 1) % br) || i == 1)) {
3110 if ((fl & HEXDF_NOASCII) == 0) {
3111 i = i % br ? i % br : br;
3112 ni = (br - i) % br;
3113 j = (i - 1) / sp;
3114 nj = (div - j - 1) % div;
3115 j = 3 * ni + nj + 3;
3116 printf("%*s", j, "");
3117 d -= i;
3118 for (j = 0; j < i; d++, j++) {
3119 if (j && (j % sp) == 0)
3120 printf(" ");
3121 if (PRINTABLE(*d))
3122 printf("%c", (int)*d);
3123 else
3124 printf(".");
3125 }
3126 }
3127 printf("\n");
3128 }
3129 }
3130
3131
3132
3133 static void
3134 ray_dump_mbuf(struct ray_softc *sc, struct mbuf *m)
3135 {
3136 u_int8_t *d, *ed;
3137 u_int i;
3138
3139 printf("%s: pkt dump:", device_xname(&sc->sc_dev));
3140 i = 0;
3141 for (; m; m = m->m_next) {
3142 d = mtod(m, u_int8_t *);
3143 ed = d + m->m_len;
3144
3145 for (; d < ed; i++, d++) {
3146 if ((i % 16) == 0)
3147 printf("\n\t");
3148 else if ((i % 8) == 0)
3149 printf(" ");
3150 printf(" %02x", *d);
3151 }
3152 }
3153 if ((i - 1) % 16)
3154 printf("\n");
3155 }
3156 #endif /* RAY_DEBUG */
3157
3158 #ifdef RAY_DO_SIGLEV
3159 static void
3160 ray_update_siglev(struct ray_softc *sc, u_int8_t *src, u_int8_t siglev)
3161 {
3162 int i, mini;
3163 struct timeval mint;
3164 struct ray_siglev *sl;
3165
3166 /* try to find host */
3167 for (i = 0; i < RAY_NSIGLEVRECS; i++) {
3168 sl = &sc->sc_siglevs[i];
3169 if (memcmp(sl->rsl_host, src, ETHER_ADDR_LEN) == 0)
3170 goto found;
3171 }
3172 /* not found, find oldest slot */
3173 mini = 0;
3174 mint.tv_sec = LONG_MAX;
3175 mint.tv_usec = 0;
3176 for (i = 0; i < RAY_NSIGLEVRECS; i++) {
3177 sl = &sc->sc_siglevs[i];
3178 if (timercmp(&sl->rsl_time, &mint, <)) {
3179 mini = i;
3180 mint = sl->rsl_time;
3181 }
3182 }
3183 sl = &sc->sc_siglevs[mini];
3184 memset(sl->rsl_siglevs, 0, RAY_NSIGLEV);
3185 memcpy(sl->rsl_host, src, ETHER_ADDR_LEN);
3186
3187 found:
3188 microtime(&sl->rsl_time);
3189 memmove(&sl->rsl_siglevs[1], sl->rsl_siglevs, RAY_NSIGLEV-1);
3190 sl->rsl_siglevs[0] = siglev;
3191 }
3192 #endif
NetBSD on the FriendlyARM MINI2440