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