Merge from vendor branch GPERF:
[dragonfly.git] / sys / dev / netif / ray / if_ray.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (C) 2000
3 * Dr. Duncan McLennan Barclay, dmlb@ragnet.demon.co.uk.
4 *
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the author nor the names of any co-contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY DUNCAN BARCLAY AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL DUNCAN BARCLAY OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * $FreeBSD: src/sys/dev/ray/if_ray.c,v 1.47.2.4 2001/08/14 22:54:05 dmlb Exp $
751c3dcc 32 * $DragonFly: src/sys/dev/netif/ray/Attic/if_ray.c,v 1.17 2005/02/19 22:24:13 joerg Exp $
984263bc
MD
33 *
34 */
35
36/* $NetBSD: if_ray.c,v 1.12 2000/02/07 09:36:27 augustss Exp $ */
37/*
38 * Copyright (c) 2000 Christian E. Hopps
39 * All rights reserved.
40 *
41 * Redistribution and use in source and binary forms, with or without
42 * modification, are permitted provided that the following conditions
43 * are met:
44 * 1. Redistributions of source code must retain the above copyright
45 * notice, this list of conditions and the following disclaimer.
46 * 2. Redistributions in binary form must reproduce the above copyright
47 * notice, this list of conditions and the following disclaimer in the
48 * documentation and/or other materials provided with the distribution.
49 * 3. Neither the name of the author nor the names of any co-contributors
50 * may be used to endorse or promote products derived from this software
51 * without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63 * SUCH DAMAGE.
64 */
65
66/*
67 * Card configuration
68 * ==================
69 *
70 * This card is unusual in that it uses both common and attribute
71 * memory whilst working. It should use common memory and an IO port.
72 *
73 * The bus resource allocations need to work around the brain deadness
74 * of pccardd (where it reads the CIS for common memory, sets it all
75 * up and then throws it all away assuming the card is an ed
76 * driver...). Note that this could be dangerous (because it doesn't
77 * interact with pccardd) if you use other memory mapped cards in the
78 * same pccard slot as currently old mappings are not cleaned up very well
79 * by the bus_release_resource methods or pccardd.
80 *
81 * There is no support for running this driver on 4.0.
82 *
83 * Ad-hoc and infra-structure modes
84 * ================================
85 *
86 * The driver supports ad-hoc mode for V4 firmware and infrastructure
87 * mode for V5 firmware. V5 firmware in ad-hoc mode is untested and should
88 * work.
89 *
90 * The Linux driver also seems to have the capability to act as an AP.
91 * I wonder what facilities the "AP" can provide within a driver? We can
92 * probably use the BRIDGE code to form an ESS but I don't think
93 * power saving etc. is easy.
94 *
95 *
96 * Packet framing/encapsulation/translation
97 * ========================================
98 *
99 * Currently we support the Webgear encapsulation:
100 * 802.11 header <net/if_ieee80211.h>struct ieee80211_frame
101 * 802.3 header <net/ethernet.h>struct ether_header
102 * IP/ARP payload
103 *
104 * and RFC1042 encapsulation of IP datagrams (translation):
105 * 802.11 header <net/if_ieee80211.h>struct ieee80211_frame
106 * 802.2 LLC header
107 * 802.2 SNAP header
108 * 802.3 Ethertype
109 * IP/ARP payload
110 *
111 * Framing should be selected via if_media stuff or link types but
112 * is currently hardcoded to:
113 * V4 encapsulation
114 * V5 translation
115 *
116 *
117 * Authentication
118 * ==============
119 *
120 * 802.11 provides two authentication mechanisms. The first is a very
121 * simple host based mechanism (like xhost) called Open System and the
122 * second is a more complex challenge/response called Shared Key built
123 * ontop of WEP.
124 *
125 * This driver only supports Open System and does not implement any
126 * host based control lists. In otherwords authentication is always
127 * granted to hosts wanting to authenticate with this station. This is
128 * the only sensible behaviour as the Open System mechanism uses MAC
129 * addresses to identify hosts. Send me patches if you need it!
130 */
131
132/*
133 * ***check all XXX_INFRA code - reassoc not done well at all!
134 * ***watchdog to catch screwed up removals?
135 * ***error handling of RAY_COM_RUNQ
136 * ***error handling of ECF command completions
137 * ***can't seem to create a n/w that Win95 wants to see.
138 * ***remove panic in ray_com_ecf by re-quing or timeout
139 * ***use new ioctl stuff - probably need to change RAY_COM_FCHKRUNNING things?
140 * consider user doing:
141 * ifconfig ray0 192.168.200.38 -bssid "freed"
142 * ifconfig ray0 192.168.200.38 -bssid "fred"
143 * here the second one would be missed in this code
144 * check that v5 needs timeouts on ecf commands
145 * write up driver structure in comments above
146 * UPDATE_PARAMS seems to return via an interrupt - maybe the timeout
147 * is needed for wrong values?
148 * proper setting of mib_hop_seq_len with country code for v4 firmware
149 * best done with raycontrol?
150 * countrycode setting is broken I think
151 * userupdate should trap and do via startjoin etc.
152 * fragmentation when rx level drops?
153 * v5 might not need download
154 * defaults are as documented apart from hop_seq_length
155 * settings are sane for ad-hoc not infra
156 *
157 * driver state
158 * most state is implied by the sequence of commands in the runq
159 * but in fact any of the rx and tx path that uses variables
160 * in the sc_c are potentially going to get screwed?
161 *
162 * infra mode stuff
163 * proper handling of the basic rate set - see the manual
164 * all ray_sj, ray_assoc sequencues need a "nicer" solution as we
165 * remember association and authentication
166 * need to consider WEP
167 * acting as ap - should be able to get working from the manual
168 * need to finish RAY_ECMD_REJOIN_DONE
169 * finish authenitcation code, it doesn't handle errors/timeouts/
170 * REJOIN etc.
171 *
172 * ray_nw_param
173 * promisc in here too? - done
174 * should be able to update the parameters before we download to the
175 * device. This means we must attach a desired struct to the
176 * runq entry and maybe have another big case statement to
177 * move these desired into current when not running.
178 * init must then use the current settings (pre-loaded
179 * in attach now!) and pass to download. But we can't access
180 * current nw params outside of the runq - ahhh
181 * differeniate between parameters set in attach and init
182 * sc_station_addr in here too (for changing mac address)
183 * move desired into the command structure?
184 * take downloaded MIB from a complete nw_param?
185 * longer term need to attach a desired nw params to the runq entry
186 *
187 *
188 * RAY_COM_RUNQ errors
189 *
190 * if sleeping in ccs_alloc with eintr/erestart/enxio/enodev
191 * erestart try again from the top
192 * XXX do not malloc more comqs
193 * XXX ccs allocation hard
194 * eintr clean up and return
195 * enxio clean up and return - done in macro
196 *
197 * if sleeping in runq_arr itself with eintr/erestart/enxio/enodev
198 * erestart try again from the top
199 * XXX do not malloc more comqs
200 * XXX ccs allocation hard
201 * XXX reinsert comqs at head of list
202 * eintr clean up and return
203 * enxio clean up and return - done in macro
204 */
205
206#define XXX 0
207#define XXX_ACTING_AP 0
208#define XXX_INFRA 0
209#define RAY_DEBUG ( \
210 /* RAY_DBG_AUTH | */ \
211 /* RAY_DBG_SUBR | */ \
212 /* RAY_DBG_BOOTPARAM | */ \
213 /* RAY_DBG_STARTJOIN | */ \
214 /* RAY_DBG_CCS | */ \
215 /* RAY_DBG_IOCTL | */ \
216 /* RAY_DBG_MBUF | */ \
217 /* RAY_DBG_RX | */ \
218 /* RAY_DBG_CM | */ \
219 /* RAY_DBG_COM | */ \
220 /* RAY_DBG_STOP | */ \
221 /* RAY_DBG_CTL | */ \
222 /* RAY_DBG_MGT | */ \
223 /* RAY_DBG_TX | */ \
224 /* RAY_DBG_DCOM | */ \
225 0 \
226 )
227
228/*
229 * XXX build options - move to LINT
230 */
231#define RAY_CM_RID 0 /* pccardd abuses windows 0 and 1 */
232#define RAY_AM_RID 3 /* pccardd abuses windows 0 and 1 */
233#define RAY_COM_TIMEOUT (hz/2) /* Timeout for CCS commands */
234#define RAY_TX_TIMEOUT (hz/2) /* Timeout for rescheduling TX */
235#define RAY_ECF_SPIN_DELAY 1000 /* Wait 1ms before checking ECF ready */
236#define RAY_ECF_SPIN_TRIES 10 /* Wait this many times for ECF ready */
237/*
238 * XXX build options - move to LINT
239 */
240
241#ifndef RAY_DEBUG
242#define RAY_DEBUG 0x0000
243#endif /* RAY_DEBUG */
244
245#include <sys/param.h>
246#include <sys/systm.h>
247#include <sys/malloc.h>
248#include <sys/kernel.h>
249
250#include <machine/bus.h>
251#include <machine/resource.h>
252#include <machine/clock.h>
253#include <sys/bus.h>
254#include <sys/rman.h>
255
256#include <sys/mbuf.h>
257#include <sys/socket.h>
258#include <sys/sockio.h>
259
260#include <net/bpf.h>
261#include <net/ethernet.h>
262#include <net/if.h>
751c3dcc 263#include <net/ifq_var.h>
984263bc
MD
264#include <net/if_arp.h>
265#include <net/if_dl.h>
984263bc
MD
266#include <net/if_llc.h>
267
273af899
JS
268#include <netproto/802_11/ieee80211.h>
269#include <netproto/802_11/ieee80211_ioctl.h>
270
984263bc
MD
271#include <machine/limits.h>
272
1f2de5d4 273#include <bus/pccard/pccardvar.h>
984263bc
MD
274#include "card_if.h"
275
1f2de5d4
MD
276#include "if_rayreg.h"
277#include "if_raymib.h"
278#include "if_raydbg.h"
279#include "if_rayvar.h"
984263bc
MD
280
281/*
282 * Prototyping
283 */
284static int ray_attach (device_t);
285static int ray_ccs_alloc (struct ray_softc *sc, size_t *ccsp, char *wmesg);
286static void ray_ccs_fill (struct ray_softc *sc, size_t ccs, u_int cmd);
287static void ray_ccs_free (struct ray_softc *sc, size_t ccs);
288static int ray_ccs_tx (struct ray_softc *sc, size_t *ccsp, size_t *bufpp);
289static void ray_com_ecf (struct ray_softc *sc, struct ray_comq_entry *com);
290static void ray_com_ecf_done (struct ray_softc *sc);
291static void ray_com_ecf_timo (void *xsc);
292static struct ray_comq_entry *
293 ray_com_init (struct ray_comq_entry *com, ray_comqfn_t function, int flags, char *mesg);
294static struct ray_comq_entry *
295 ray_com_malloc (ray_comqfn_t function, int flags, char *mesg);
296static void ray_com_runq (struct ray_softc *sc);
297static int ray_com_runq_add (struct ray_softc *sc, struct ray_comq_entry *com[], int ncom, char *wmesg);
298static void ray_com_runq_done (struct ray_softc *sc);
299static int ray_detach (device_t);
300static void ray_init (void *xsc);
301static int ray_init_user (struct ray_softc *sc);
302static void ray_init_assoc (struct ray_softc *sc, struct ray_comq_entry *com);
303static void ray_init_assoc_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
304static void ray_init_auth (struct ray_softc *sc, struct ray_comq_entry *com);
305static int ray_init_auth_send (struct ray_softc *sc, u_int8_t *dst, int sequence);
306static void ray_init_auth_done (struct ray_softc *sc, u_int8_t status);
307static void ray_init_download (struct ray_softc *sc, struct ray_comq_entry *com);
308static void ray_init_download_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
309static void ray_init_download_v4 (struct ray_softc *sc, struct ray_comq_entry *com);
310static void ray_init_download_v5 (struct ray_softc *sc, struct ray_comq_entry *com);
311static void ray_init_mcast (struct ray_softc *sc, struct ray_comq_entry *com);
312static void ray_init_sj (struct ray_softc *sc, struct ray_comq_entry *com);
313static void ray_init_sj_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
314static void ray_intr (void *xsc);
315static void ray_intr_ccs (struct ray_softc *sc, u_int8_t cmd, u_int8_t status, size_t ccs);
316static void ray_intr_rcs (struct ray_softc *sc, u_int8_t cmd, size_t ccs);
317static void ray_intr_updt_errcntrs (struct ray_softc *sc);
bd4539cc 318static int ray_ioctl (struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr);
984263bc
MD
319static void ray_mcast (struct ray_softc *sc, struct ray_comq_entry *com);
320static void ray_mcast_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
321static int ray_mcast_user (struct ray_softc *sc);
322static int ray_probe (device_t);
323static void ray_promisc (struct ray_softc *sc, struct ray_comq_entry *com);
324static void ray_repparams (struct ray_softc *sc, struct ray_comq_entry *com);
325static void ray_repparams_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
326static int ray_repparams_user (struct ray_softc *sc, struct ray_param_req *pr);
327static int ray_repstats_user (struct ray_softc *sc, struct ray_stats_req *sr);
328static int ray_res_alloc_am (struct ray_softc *sc);
329static int ray_res_alloc_cm (struct ray_softc *sc);
330static int ray_res_alloc_irq (struct ray_softc *sc);
331static void ray_res_release (struct ray_softc *sc);
332static void ray_rx (struct ray_softc *sc, size_t rcs);
333static void ray_rx_ctl (struct ray_softc *sc, struct mbuf *m0);
334static void ray_rx_data (struct ray_softc *sc, struct mbuf *m0, u_int8_t siglev, u_int8_t antenna);
335static void ray_rx_mgt (struct ray_softc *sc, struct mbuf *m0);
336static void ray_rx_mgt_auth (struct ray_softc *sc, struct mbuf *m0);
337static void ray_rx_mgt_beacon (struct ray_softc *sc, struct mbuf *m0);
338static void ray_rx_mgt_info (struct ray_softc *sc, struct mbuf *m0, struct ieee80211_information *elements);
339static void ray_rx_update_cache (struct ray_softc *sc, u_int8_t *src, u_int8_t siglev, u_int8_t antenna);
340static void ray_stop (struct ray_softc *sc, struct ray_comq_entry *com);
341static int ray_stop_user (struct ray_softc *sc);
342static void ray_tx (struct ifnet *ifp);
343static void ray_tx_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
344static void ray_tx_timo (void *xsc);
345static int ray_tx_send (struct ray_softc *sc, size_t ccs, int pktlen, u_int8_t *dst);
346static size_t ray_tx_wrhdr (struct ray_softc *sc, size_t bufp, u_int8_t type, u_int8_t fc1, u_int8_t *addr1, u_int8_t *addr2, u_int8_t *addr3);
347static void ray_upparams (struct ray_softc *sc, struct ray_comq_entry *com);
348static void ray_upparams_done (struct ray_softc *sc, u_int8_t status, size_t ccs);
349static int ray_upparams_user (struct ray_softc *sc, struct ray_param_req *pr);
350static void ray_watchdog (struct ifnet *ifp);
351static u_int8_t ray_tx_best_antenna (struct ray_softc *sc, u_int8_t *dst);
352
353#if RAY_DEBUG & RAY_DBG_COM
354static void ray_com_ecf_check (struct ray_softc *sc, size_t ccs, char *mesg);
355#endif /* RAY_DEBUG & RAY_DBG_COM */
356#if RAY_DEBUG & RAY_DBG_MBUF
357static void ray_dump_mbuf (struct ray_softc *sc, struct mbuf *m, char *s);
358#endif /* RAY_DEBUG & RAY_DBG_MBUF */
359
360/*
361 * PC-Card (PCMCIA) driver definition
362 */
363static device_method_t ray_methods[] = {
364 /* Device interface */
365 DEVMETHOD(device_probe, ray_probe),
366 DEVMETHOD(device_attach, ray_attach),
367 DEVMETHOD(device_detach, ray_detach),
368
369 { 0, 0 }
370};
371
372static driver_t ray_driver = {
373 "ray",
374 ray_methods,
375 sizeof(struct ray_softc)
376};
377
378static devclass_t ray_devclass;
379
32832096
MD
380DECLARE_DUMMY_MODULE(if_ray);
381DRIVER_MODULE(if_ray, pccard, ray_driver, ray_devclass, 0, 0);
984263bc
MD
382
383/*
384 * Probe for the card by checking its startup results.
385 *
386 * Fixup any bugs/quirks for different firmware.
387 */
388static int
389ray_probe(device_t dev)
390{
391 struct ray_softc *sc = device_get_softc(dev);
392 struct ray_ecf_startup_v5 *ep = &sc->sc_ecf_startup;
393 int error;
394
395 sc->dev = dev;
396 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
397
398 /*
399 * Read startup results from the card.
400 */
401 error = ray_res_alloc_cm(sc);
402 if (error)
403 return (error);
404 error = ray_res_alloc_am(sc);
405 if (error) {
406 ray_res_release(sc);
407 return (error);
408 }
409 RAY_MAP_CM(sc);
410 SRAM_READ_REGION(sc, RAY_ECF_TO_HOST_BASE, ep,
411 sizeof(sc->sc_ecf_startup));
412 ray_res_release(sc);
413
414 /*
415 * Check the card is okay and work out what version we are using.
416 */
417 if (ep->e_status != RAY_ECFS_CARD_OK) {
418 RAY_PRINTF(sc, "card failed self test 0x%b",
419 ep->e_status, RAY_ECFS_PRINTFB);
420 return (ENXIO);
421 }
422 if (sc->sc_version != RAY_ECFS_BUILD_4 &&
423 sc->sc_version != RAY_ECFS_BUILD_5) {
424 RAY_PRINTF(sc, "unsupported firmware version 0x%0x",
425 ep->e_fw_build_string);
426 return (ENXIO);
427 }
428 RAY_DPRINTF(sc, RAY_DBG_BOOTPARAM, "found a card");
429 sc->sc_gone = 0;
430
431 /*
432 * Fixup tib size to be correct - on build 4 it is garbage
433 */
434 if (sc->sc_version == RAY_ECFS_BUILD_4 && sc->sc_tibsize == 0x55)
435 sc->sc_tibsize = sizeof(struct ray_tx_tib);
436
437 return (0);
438}
439
440/*
441 * Attach the card into the kernel
442 */
443static int
444ray_attach(device_t dev)
445{
446 struct ray_softc *sc = device_get_softc(dev);
447 struct ray_ecf_startup_v5 *ep = &sc->sc_ecf_startup;
448 struct ifnet *ifp = &sc->arpcom.ac_if;
449 size_t ccs;
450 int i, error;
451
452 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
453
454 if ((sc == NULL) || (sc->sc_gone))
455 return (ENXIO);
456
457 /*
458 * Grab the resources I need
459 */
460 error = ray_res_alloc_cm(sc);
461 if (error)
462 return (error);
463 error = ray_res_alloc_am(sc);
464 if (error) {
465 ray_res_release(sc);
466 return (error);
467 }
468 error = ray_res_alloc_irq(sc);
469 if (error) {
470 ray_res_release(sc);
471 return (error);
472 }
473
474 /*
475 * Reset any pending interrupts
476 */
477 RAY_HCS_CLEAR_INTR(sc);
478
479 /*
480 * Set the parameters that will survive stop/init and
481 * reset a few things on the card.
482 *
483 * Do not update these in ray_init_download's parameter setup
484 *
485 * XXX see the ray_init_download section for stuff to move
486 */
487 RAY_MAP_CM(sc);
488 bzero(&sc->sc_d, sizeof(struct ray_nw_param));
489 bzero(&sc->sc_c, sizeof(struct ray_nw_param));
490
491 /* Clear statistics counters */
492 sc->sc_rxoverflow = 0;
493 sc->sc_rxcksum = 0;
494 sc->sc_rxhcksum = 0;
495 sc->sc_rxnoise = 0;
496
497 /* Clear signal and antenna cache */
498 bzero(sc->sc_siglevs, sizeof(sc->sc_siglevs));
499
500 /* Set all ccs to be free */
501 bzero(sc->sc_ccsinuse, sizeof(sc->sc_ccsinuse));
502 ccs = RAY_CCS_ADDRESS(0);
503 for (i = 0; i < RAY_CCS_LAST; ccs += RAY_CCS_SIZE, i++)
504 RAY_CCS_FREE(sc, ccs);
505
506 /*
507 * Initialise the network interface structure
508 */
cdb7d804 509 if_initname(ifp, "ray", device_get_unit(dev));
984263bc 510 ifp->if_softc = sc;
984263bc
MD
511 ifp->if_timer = 0;
512 ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
513 ifp->if_hdrlen = sizeof(struct ieee80211_frame) +
514 sizeof(struct ether_header);
515 ifp->if_baudrate = 1000000; /* Is this baud or bps ;-) */
984263bc
MD
516 ifp->if_start = ray_tx;
517 ifp->if_ioctl = ray_ioctl;
518 ifp->if_watchdog = ray_watchdog;
519 ifp->if_init = ray_init;
751c3dcc
JS
520 ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
521 ifq_set_ready(&ifp->if_snd);
984263bc 522
984263bc
MD
523 /*
524 * Initialise the timers and driver
525 */
b3a81bea
JS
526 callout_init(&sc->com_timer);
527 callout_init(&sc->tx_timer);
984263bc
MD
528 TAILQ_INIT(&sc->sc_comq);
529
b3a81bea
JS
530 ether_ifattach(ifp, ep->e_station_addr);
531
984263bc
MD
532 /*
533 * Print out some useful information
534 */
535 if (bootverbose || (RAY_DEBUG & RAY_DBG_BOOTPARAM)) {
536 RAY_PRINTF(sc, "start up results");
537 if (sc->sc_version == RAY_ECFS_BUILD_4)
538 printf(". Firmware version 4\n");
539 else
540 printf(". Firmware version 5\n");
541 printf(". Status 0x%b\n", ep->e_status, RAY_ECFS_PRINTFB);
984263bc
MD
542 if (sc->sc_version == RAY_ECFS_BUILD_4) {
543 printf(". Program checksum %0x\n", ep->e_resv0);
544 printf(". CIS checksum %0x\n", ep->e_rates[0]);
545 } else {
546 printf(". (reserved word) %0x\n", ep->e_resv0);
547 printf(". Supported rates %8D\n", ep->e_rates, ":");
548 }
549 printf(". Japan call sign %12D\n", ep->e_japan_callsign, ":");
550 if (sc->sc_version == RAY_ECFS_BUILD_5) {
551 printf(". Program checksum %0x\n", ep->e_prg_cksum);
552 printf(". CIS checksum %0x\n", ep->e_cis_cksum);
553 printf(". Firmware version %0x\n",
554 ep->e_fw_build_string);
555 printf(". Firmware revision %0x\n", ep->e_fw_build);
556 printf(". (reserved word) %0x\n", ep->e_fw_resv);
557 printf(". ASIC version %0x\n", ep->e_asic_version);
558 printf(". TIB size %0x\n", ep->e_tibsize);
559 }
560 }
561
562 return (0);
563}
564
565/*
566 * Detach the card
567 *
568 * This is usually called when the card is ejected, but
569 * can be caused by a modunload of a controller driver.
570 * The idea is to reset the driver's view of the device
571 * and ensure that any driver entry points such as
572 * read and write do not hang.
573 */
574static int
575ray_detach(device_t dev)
576{
577 struct ray_softc *sc = device_get_softc(dev);
578 struct ifnet *ifp = &sc->arpcom.ac_if;
579 struct ray_comq_entry *com;
580 int s;
581
582 s = splimp();
583
584 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STOP, "");
585
586 if ((sc == NULL) || (sc->sc_gone))
587 return (0);
588
589 /*
590 * Mark as not running and detach the interface.
591 *
592 * N.B. if_detach can trigger ioctls so we do it first and
593 * then clean the runq.
594 */
595 sc->sc_gone = 1;
596 sc->sc_c.np_havenet = 0;
597 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
0a8b5977 598 ether_ifdetach(ifp);
984263bc
MD
599
600 /*
601 * Stop the runq and wake up anyone sleeping for us.
602 */
b3a81bea
JS
603 callout_stop(&sc->com_timer);
604 callout_stop(&sc->tx_timer);
984263bc
MD
605 com = TAILQ_FIRST(&sc->sc_comq);
606 for (com = TAILQ_FIRST(&sc->sc_comq); com != NULL;
607 com = TAILQ_NEXT(com, c_chain)) {
608 com->c_flags |= RAY_COM_FDETACHED;
609 com->c_retval = 0;
610 RAY_DPRINTF(sc, RAY_DBG_STOP, "looking at com %p %b",
611 com, com->c_flags, RAY_COM_FLAGS_PRINTFB);
612 if (com->c_flags & RAY_COM_FWOK) {
613 RAY_DPRINTF(sc, RAY_DBG_STOP, "waking com %p", com);
614 wakeup(com->c_wakeup);
615 }
616 }
617
618 /*
619 * Release resources
620 */
621 ray_res_release(sc);
622 RAY_DPRINTF(sc, RAY_DBG_STOP, "unloading complete");
623
624 splx(s);
625
626 return (0);
627}
628
629/*
630 * Network ioctl request.
631 */
632static int
bd4539cc
JH
633ray_ioctl(register struct ifnet *ifp, u_long command, caddr_t data,
634 struct ucred *cr)
984263bc
MD
635{
636 struct ray_softc *sc = ifp->if_softc;
637 struct ray_param_req pr;
638 struct ray_stats_req sr;
639 struct ifreq *ifr = (struct ifreq *)data;
640 int s, error, error2;
641
642 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_IOCTL, "");
643
644 if ((sc == NULL) || (sc->sc_gone))
645 return (ENXIO);
646
647 error = error2 = 0;
648 s = splimp();
649
650 switch (command) {
651
652 case SIOCGIFADDR:
653 case SIOCSIFMTU:
654 case SIOCSIFADDR:
655 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFADDR/SIFMTU");
656 error = ether_ioctl(ifp, command, data);
657/* XXX SIFADDR used to fall through to SIOCSIFFLAGS */
658 break;
659
660 case SIOCSIFFLAGS:
661 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "SIFFLAGS 0x%0x", ifp->if_flags);
662 /*
663 * If the interface is marked up we call ray_init_user.
664 * This will deal with mcast and promisc flags as well as
665 * initialising the hardware if it needs it.
666 */
667 if (ifp->if_flags & IFF_UP)
668 error = ray_init_user(sc);
669 else
670 error = ray_stop_user(sc);
671 break;
672
673 case SIOCADDMULTI:
674 case SIOCDELMULTI:
675 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "ADDMULTI/DELMULTI");
676 error = ray_mcast_user(sc);
677 break;
678
679 case SIOCSRAYPARAM:
680 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "SRAYPARAM");
681 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
682 break;
683 error = ray_upparams_user(sc, &pr);
684 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
685 error = error2 ? error2 : error;
686 break;
687
688 case SIOCGRAYPARAM:
689 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GRAYPARAM");
690 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
691 break;
692 error = ray_repparams_user(sc, &pr);
693 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
694 error = error2 ? error2 : error;
695 break;
696
697 case SIOCGRAYSTATS:
698 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GRAYSTATS");
699 error = ray_repstats_user(sc, &sr);
700 error2 = copyout(&sr, ifr->ifr_data, sizeof(sr));
701 error = error2 ? error2 : error;
702 break;
703
704 case SIOCGRAYSIGLEV:
705 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GRAYSIGLEV");
706 error = copyout(sc->sc_siglevs, ifr->ifr_data,
707 sizeof(sc->sc_siglevs));
708 break;
709
710 case SIOCGIFFLAGS:
711 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFFLAGS");
712 error = EINVAL;
713 break;
714
715 case SIOCGIFMETRIC:
716 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFMETRIC");
717 error = EINVAL;
718 break;
719
720 case SIOCGIFMTU:
721 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFMTU");
722 error = EINVAL;
723 break;
724
725 case SIOCGIFPHYS:
726 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFPYHS");
727 error = EINVAL;
728 break;
729
730 case SIOCSIFMEDIA:
731 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "SIFMEDIA");
732 error = EINVAL;
733 break;
734
735 case SIOCGIFMEDIA:
736 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFMEDIA");
737 error = EINVAL;
738 break;
739
740 default:
741 error = EINVAL;
742
743 }
744
745 splx(s);
746
747 return (error);
748}
749
750/*
751 * Ethernet layer entry to ray_init - discard errors
752 */
753static void
754ray_init(void *xsc)
755{
756 struct ray_softc *sc = (struct ray_softc *)xsc;
757
758 ray_init_user(sc);
759}
760
761/*
762 * User land entry to network initialisation and changes in interface flags.
763 *
764 * We do a very little work here, just creating runq entries to
765 * processes the actions needed to cope with interface flags. We do it
766 * this way in case there are runq entries outstanding from earlier
767 * ioctls that modify the interface flags.
768 *
769 * Returns values are either 0 for success, a varity of resource allocation
770 * failures or errors in the command sent to the card.
771 *
772 * Note, IFF_RUNNING is eventually set by init_sj_done or init_assoc_done
773 */
774static int
775ray_init_user(struct ray_softc *sc)
776{
777 struct ray_comq_entry *com[6];
778 int error, ncom;
779
780 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
781
782 /*
783 * Create the following runq entries to bring the card up.
784 *
785 * init_download - download the network to the card
786 * init_mcast - reset multicast list
787 * init_sj - find or start a BSS
788 * init_auth - authenticate with a ESSID if needed
789 * init_assoc - associate with a ESSID if needed
790 *
791 * They are only actually executed if the card is not running.
792 * We may enter this routine from a simple change of IP
793 * address and do not need to get the card to do these things.
794 * However, we cannot perform the check here as there may be
795 * commands in the runq that change the IFF_RUNNING state of
796 * the interface.
797 */
798 ncom = 0;
799 com[ncom++] = RAY_COM_MALLOC(ray_init_download, RAY_COM_FCHKRUNNING);
800 com[ncom++] = RAY_COM_MALLOC(ray_init_mcast, RAY_COM_FCHKRUNNING);
801 com[ncom++] = RAY_COM_MALLOC(ray_init_sj, RAY_COM_FCHKRUNNING);
802 com[ncom++] = RAY_COM_MALLOC(ray_init_auth, RAY_COM_FCHKRUNNING);
803 com[ncom++] = RAY_COM_MALLOC(ray_init_assoc, RAY_COM_FCHKRUNNING);
804
805 /*
806 * Create runq entries to process flags
807 *
808 * promisc - set/reset PROMISC and ALLMULTI flags
809 *
810 * They are only actually executed if the card is running
811 */
812 com[ncom++] = RAY_COM_MALLOC(ray_promisc, 0);
813
814 RAY_COM_RUNQ(sc, com, ncom, "rayinit", error);
815
816 /* XXX no real error processing from anything yet! */
817
818 RAY_COM_FREE(com, ncom);
819
820 return (error);
821}
822
823/*
824 * Runq entry for resetting driver and downloading start up structures to card
825 */
826static void
827ray_init_download(struct ray_softc *sc, struct ray_comq_entry *com)
828{
829 struct ifnet *ifp = &sc->arpcom.ac_if;
830
831 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
832
833 /* If the card already running we might not need to download */
834 RAY_COM_CHKRUNNING(sc, com, ifp);
835
836 /*
837 * Reset instance variables
838 *
839 * The first set are network parameters that are read back when
840 * the card starts or joins the network.
841 *
842 * The second set are network parameters that are downloaded to
843 * the card.
844 *
845 * The third set are driver parameters.
846 *
847 * All of the variables in these sets can be updated by the
848 * card or ioctls.
849 *
850 * XXX see the ray_attach section for stuff to move
851 */
852 sc->sc_d.np_upd_param = 0;
853 bzero(sc->sc_d.np_bss_id, ETHER_ADDR_LEN);
854 sc->sc_d.np_inited = 0;
855 sc->sc_d.np_def_txrate = RAY_MIB_BASIC_RATE_SET_DEFAULT;
856 sc->sc_d.np_encrypt = 0;
857
858 bzero(sc->sc_d.np_ssid, IEEE80211_NWID_LEN);
859 if (sc->sc_version == RAY_ECFS_BUILD_4) {
860 sc->sc_d.np_net_type = RAY_MIB_NET_TYPE_V4;
861 strncpy(sc->sc_d.np_ssid, RAY_MIB_SSID_V4, IEEE80211_NWID_LEN);
862 sc->sc_d.np_ap_status = RAY_MIB_AP_STATUS_V4;
863 sc->sc_d.np_framing = RAY_FRAMING_ENCAPSULATION;
864 } else {
865 sc->sc_d.np_net_type = RAY_MIB_NET_TYPE_V5;
866 strncpy(sc->sc_d.np_ssid, RAY_MIB_SSID_V5, IEEE80211_NWID_LEN);
867 sc->sc_d.np_ap_status = RAY_MIB_AP_STATUS_V5;
868 sc->sc_d.np_framing = RAY_FRAMING_TRANSLATION;
869 }
870 sc->sc_d.np_priv_start = RAY_MIB_PRIVACY_MUST_START_DEFAULT;
871 sc->sc_d.np_priv_join = RAY_MIB_PRIVACY_CAN_JOIN_DEFAULT;
872 sc->sc_d.np_promisc = !!(ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI));
873
874/* XXX this is a hack whilst I transition the code. The instance
875 * XXX variables above should be set somewhere else. This is needed for
876 * XXX start_join */
877bcopy(&sc->sc_d, &com->c_desired, sizeof(struct ray_nw_param));
878
879 /*
880 * Download the right firmware defaults
881 */
882 if (sc->sc_version == RAY_ECFS_BUILD_4)
883 ray_init_download_v4(sc, com);
884 else
885 ray_init_download_v5(sc, com);
886
887 /*
888 * Kick the card
889 */
890 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_DOWNLOAD_PARAMS);
891 ray_com_ecf(sc, com);
892}
893
894#define PUT2(p, v) \
895 do { (p)[0] = ((v >> 8) & 0xff); (p)[1] = (v & 0xff); } while(0)
896/*
897 * Firmware version 4 defaults - see if_raymib.h for details
898 */
899static void
900ray_init_download_v4(struct ray_softc *sc, struct ray_comq_entry *com)
901{
902 struct ray_mib_4 ray_mib_4_default;
903
904 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
905 RAY_MAP_CM(sc);
906
dae8fa2c 907#define MIB4(m) ray_mib_4_default.m
984263bc
MD
908
909 MIB4(mib_net_type) = com->c_desired.np_net_type;
910 MIB4(mib_ap_status) = com->c_desired.np_ap_status;
911 bcopy(com->c_desired.np_ssid, MIB4(mib_ssid), IEEE80211_NWID_LEN);
912 MIB4(mib_scan_mode) = RAY_MIB_SCAN_MODE_V4;
913 MIB4(mib_apm_mode) = RAY_MIB_APM_MODE_V4;
914 bcopy(sc->sc_station_addr, MIB4(mib_mac_addr), ETHER_ADDR_LEN);
915 PUT2(MIB4(mib_frag_thresh), RAY_MIB_FRAG_THRESH_V4);
916 PUT2(MIB4(mib_dwell_time), RAY_MIB_DWELL_TIME_V4);
917 PUT2(MIB4(mib_beacon_period), RAY_MIB_BEACON_PERIOD_V4);
918 MIB4(mib_dtim_interval) = RAY_MIB_DTIM_INTERVAL_V4;
919 MIB4(mib_max_retry) = RAY_MIB_MAX_RETRY_V4;
920 MIB4(mib_ack_timo) = RAY_MIB_ACK_TIMO_V4;
921 MIB4(mib_sifs) = RAY_MIB_SIFS_V4;
922 MIB4(mib_difs) = RAY_MIB_DIFS_V4;
923 MIB4(mib_pifs) = RAY_MIB_PIFS_V4;
924 PUT2(MIB4(mib_rts_thresh), RAY_MIB_RTS_THRESH_V4);
925 PUT2(MIB4(mib_scan_dwell), RAY_MIB_SCAN_DWELL_V4);
926 PUT2(MIB4(mib_scan_max_dwell), RAY_MIB_SCAN_MAX_DWELL_V4);
927 MIB4(mib_assoc_timo) = RAY_MIB_ASSOC_TIMO_V4;
928 MIB4(mib_adhoc_scan_cycle) = RAY_MIB_ADHOC_SCAN_CYCLE_V4;
929 MIB4(mib_infra_scan_cycle) = RAY_MIB_INFRA_SCAN_CYCLE_V4;
930 MIB4(mib_infra_super_scan_cycle)
931 = RAY_MIB_INFRA_SUPER_SCAN_CYCLE_V4;
932 MIB4(mib_promisc) = com->c_desired.np_promisc;
933 PUT2(MIB4(mib_uniq_word), RAY_MIB_UNIQ_WORD_V4);
934 MIB4(mib_slot_time) = RAY_MIB_SLOT_TIME_V4;
935 MIB4(mib_roam_low_snr_thresh) = RAY_MIB_ROAM_LOW_SNR_THRESH_V4;
936 MIB4(mib_low_snr_count) = RAY_MIB_LOW_SNR_COUNT_V4;
937 MIB4(mib_infra_missed_beacon_count)
938 = RAY_MIB_INFRA_MISSED_BEACON_COUNT_V4;
939 MIB4(mib_adhoc_missed_beacon_count)
940 = RAY_MIB_ADHOC_MISSED_BEACON_COUNT_V4;
941 MIB4(mib_country_code) = RAY_MIB_COUNTRY_CODE_V4;
942 MIB4(mib_hop_seq) = RAY_MIB_HOP_SEQ_V4;
943 MIB4(mib_hop_seq_len) = RAY_MIB_HOP_SEQ_LEN_V4;
944 MIB4(mib_cw_max) = RAY_MIB_CW_MAX_V4;
945 MIB4(mib_cw_min) = RAY_MIB_CW_MIN_V4;
946 MIB4(mib_noise_filter_gain) = RAY_MIB_NOISE_FILTER_GAIN_DEFAULT;
947 MIB4(mib_noise_limit_offset) = RAY_MIB_NOISE_LIMIT_OFFSET_DEFAULT;
948 MIB4(mib_rssi_thresh_offset) = RAY_MIB_RSSI_THRESH_OFFSET_DEFAULT;
949 MIB4(mib_busy_thresh_offset) = RAY_MIB_BUSY_THRESH_OFFSET_DEFAULT;
950 MIB4(mib_sync_thresh) = RAY_MIB_SYNC_THRESH_DEFAULT;
951 MIB4(mib_test_mode) = RAY_MIB_TEST_MODE_DEFAULT;
952 MIB4(mib_test_min_chan) = RAY_MIB_TEST_MIN_CHAN_DEFAULT;
953 MIB4(mib_test_max_chan) = RAY_MIB_TEST_MAX_CHAN_DEFAULT;
954#undef MIB4
955
956 SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE,
957 &ray_mib_4_default, sizeof(ray_mib_4_default));
958}
959
960/*
961 * Firmware version 5 defaults - see if_raymib.h for details
962 */
963static void
964ray_init_download_v5(struct ray_softc *sc, struct ray_comq_entry *com)
965{
966 struct ray_mib_5 ray_mib_5_default;
967
968 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
969 RAY_MAP_CM(sc);
970
dae8fa2c 971#define MIB5(m) ray_mib_5_default.m
984263bc
MD
972 MIB5(mib_net_type) = com->c_desired.np_net_type;
973 MIB5(mib_ap_status) = com->c_desired.np_ap_status;
974 bcopy(com->c_desired.np_ssid, MIB5(mib_ssid), IEEE80211_NWID_LEN);
975 MIB5(mib_scan_mode) = RAY_MIB_SCAN_MODE_V5;
976 MIB5(mib_apm_mode) = RAY_MIB_APM_MODE_V5;
977 bcopy(sc->sc_station_addr, MIB5(mib_mac_addr), ETHER_ADDR_LEN);
978 PUT2(MIB5(mib_frag_thresh), RAY_MIB_FRAG_THRESH_V5);
979 PUT2(MIB5(mib_dwell_time), RAY_MIB_DWELL_TIME_V5);
980 PUT2(MIB5(mib_beacon_period), RAY_MIB_BEACON_PERIOD_V5);
981 MIB5(mib_dtim_interval) = RAY_MIB_DTIM_INTERVAL_V5;
982 MIB5(mib_max_retry) = RAY_MIB_MAX_RETRY_V5;
983 MIB5(mib_ack_timo) = RAY_MIB_ACK_TIMO_V5;
984 MIB5(mib_sifs) = RAY_MIB_SIFS_V5;
985 MIB5(mib_difs) = RAY_MIB_DIFS_V5;
986 MIB5(mib_pifs) = RAY_MIB_PIFS_V5;
987 PUT2(MIB5(mib_rts_thresh), RAY_MIB_RTS_THRESH_V5);
988 PUT2(MIB5(mib_scan_dwell), RAY_MIB_SCAN_DWELL_V5);
989 PUT2(MIB5(mib_scan_max_dwell), RAY_MIB_SCAN_MAX_DWELL_V5);
990 MIB5(mib_assoc_timo) = RAY_MIB_ASSOC_TIMO_V5;
991 MIB5(mib_adhoc_scan_cycle) = RAY_MIB_ADHOC_SCAN_CYCLE_V5;
992 MIB5(mib_infra_scan_cycle) = RAY_MIB_INFRA_SCAN_CYCLE_V5;
993 MIB5(mib_infra_super_scan_cycle)
994 = RAY_MIB_INFRA_SUPER_SCAN_CYCLE_V5;
995 MIB5(mib_promisc) = com->c_desired.np_promisc;
996 PUT2(MIB5(mib_uniq_word), RAY_MIB_UNIQ_WORD_V5);
997 MIB5(mib_slot_time) = RAY_MIB_SLOT_TIME_V5;
998 MIB5(mib_roam_low_snr_thresh) = RAY_MIB_ROAM_LOW_SNR_THRESH_V5;
999 MIB5(mib_low_snr_count) = RAY_MIB_LOW_SNR_COUNT_V5;
1000 MIB5(mib_infra_missed_beacon_count)
1001 = RAY_MIB_INFRA_MISSED_BEACON_COUNT_V5;
1002 MIB5(mib_adhoc_missed_beacon_count)
1003 = RAY_MIB_ADHOC_MISSED_BEACON_COUNT_V5;
1004 MIB5(mib_country_code) = RAY_MIB_COUNTRY_CODE_V5;
1005 MIB5(mib_hop_seq) = RAY_MIB_HOP_SEQ_V5;
1006 MIB5(mib_hop_seq_len) = RAY_MIB_HOP_SEQ_LEN_V5;
1007 PUT2(MIB5(mib_cw_max), RAY_MIB_CW_MAX_V5);
1008 PUT2(MIB5(mib_cw_min), RAY_MIB_CW_MIN_V5);
1009 MIB5(mib_noise_filter_gain) = RAY_MIB_NOISE_FILTER_GAIN_DEFAULT;
1010 MIB5(mib_noise_limit_offset) = RAY_MIB_NOISE_LIMIT_OFFSET_DEFAULT;
1011 MIB5(mib_rssi_thresh_offset) = RAY_MIB_RSSI_THRESH_OFFSET_DEFAULT;
1012 MIB5(mib_busy_thresh_offset) = RAY_MIB_BUSY_THRESH_OFFSET_DEFAULT;
1013 MIB5(mib_sync_thresh) = RAY_MIB_SYNC_THRESH_DEFAULT;
1014 MIB5(mib_test_mode) = RAY_MIB_TEST_MODE_DEFAULT;
1015 MIB5(mib_test_min_chan) = RAY_MIB_TEST_MIN_CHAN_DEFAULT;
1016 MIB5(mib_test_max_chan) = RAY_MIB_TEST_MAX_CHAN_DEFAULT;
1017 MIB5(mib_allow_probe_resp) = RAY_MIB_ALLOW_PROBE_RESP_DEFAULT;
1018 MIB5(mib_privacy_must_start) = com->c_desired.np_priv_start;
1019 MIB5(mib_privacy_can_join) = com->c_desired.np_priv_join;
1020 MIB5(mib_basic_rate_set[0]) = com->c_desired.np_def_txrate;
1021#undef MIB5
1022
1023 SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE,
1024 &ray_mib_5_default, sizeof(ray_mib_5_default));
1025}
1026#undef PUT2
1027
1028/*
1029 * Download completion routine
1030 */
1031static void
1032ray_init_download_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1033{
1034 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1035 RAY_COM_CHECK(sc, ccs);
1036
1037 RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
1038
1039 ray_com_ecf_done(sc);
1040}
1041
1042/*
1043 * Runq entry to empty the multicast filter list
1044 */
1045static void
1046ray_init_mcast(struct ray_softc *sc, struct ray_comq_entry *com)
1047{
1048 struct ifnet *ifp = &sc->arpcom.ac_if;
1049
1050 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1051 RAY_MAP_CM(sc);
1052
1053 /* If the card already running we might not need to reset the list */
1054 RAY_COM_CHKRUNNING(sc, com, ifp);
1055
1056 /*
1057 * Kick the card
1058 */
1059 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_MCAST);
1060 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_update_mcast, c_nmcast, 0);
1061
1062 ray_com_ecf(sc, com);
1063}
1064
1065/*
1066 * Runq entry to starting or joining a network
1067 */
1068static void
1069ray_init_sj(struct ray_softc *sc, struct ray_comq_entry *com)
1070{
1071 struct ifnet *ifp = &sc->arpcom.ac_if;
1072 struct ray_net_params np;
1073 int update;
1074
1075 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1076 RAY_MAP_CM(sc);
1077
1078 /* If the card already running we might not need to start the n/w */
1079 RAY_COM_CHKRUNNING(sc, com, ifp);
1080
1081 /*
1082 * Set up the right start or join command and determine
1083 * whether we should tell the card about a change in operating
1084 * parameters.
1085 */
1086 sc->sc_c.np_havenet = 0;
1087 if (sc->sc_d.np_net_type == RAY_MIB_NET_TYPE_ADHOC)
1088 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_START_NET);
1089 else
1090 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_JOIN_NET);
1091
1092 update = 0;
1093 if (sc->sc_c.np_net_type != sc->sc_d.np_net_type)
1094 update++;
1095 if (bcmp(sc->sc_c.np_ssid, sc->sc_d.np_ssid, IEEE80211_NWID_LEN))
1096 update++;
1097 if (sc->sc_c.np_priv_join != sc->sc_d.np_priv_join)
1098 update++;
1099 if (sc->sc_c.np_priv_start != sc->sc_d.np_priv_start)
1100 update++;
1101 RAY_DPRINTF(sc, RAY_DBG_STARTJOIN,
1102 "%s updating nw params", update?"is":"not");
1103 if (update) {
1104 bzero(&np, sizeof(np));
1105 np.p_net_type = sc->sc_d.np_net_type;
1106 bcopy(sc->sc_d.np_ssid, np.p_ssid, IEEE80211_NWID_LEN);
1107 np.p_privacy_must_start = sc->sc_d.np_priv_start;
1108 np.p_privacy_can_join = sc->sc_d.np_priv_join;
1109 SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np));
1110 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_net, c_upd_param, 1);
1111 } else
1112 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_net, c_upd_param, 0);
1113
1114 /*
1115 * Kick the card
1116 */
1117 ray_com_ecf(sc, com);
1118}
1119
1120/*
1121 * Complete start command or intermediate step in assoc command
1122 */
1123static void
1124ray_init_sj_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1125{
1126 struct ifnet *ifp = &sc->arpcom.ac_if;
1127
1128 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1129 RAY_MAP_CM(sc);
1130 RAY_COM_CHECK(sc, ccs);
1131
1132 RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
1133
1134 /*
1135 * Read back network parameters that the ECF sets
1136 */
1137 SRAM_READ_REGION(sc, ccs, &sc->sc_c.p_1, sizeof(struct ray_cmd_net));
1138
1139 /* Adjust values for buggy firmware */
1140 if (sc->sc_c.np_inited == 0x55)
1141 sc->sc_c.np_inited = 0;
1142 if (sc->sc_c.np_def_txrate == 0x55)
1143 sc->sc_c.np_def_txrate = sc->sc_d.np_def_txrate;
1144 if (sc->sc_c.np_encrypt == 0x55)
1145 sc->sc_c.np_encrypt = sc->sc_d.np_encrypt;
1146
1147 /*
1148 * Update our local state if we updated the network parameters
1149 * when the START_NET or JOIN_NET was issued.
1150 */
1151 if (sc->sc_c.np_upd_param) {
1152 RAY_DPRINTF(sc, RAY_DBG_STARTJOIN, "updated parameters");
1153 SRAM_READ_REGION(sc, RAY_HOST_TO_ECF_BASE,
1154 &sc->sc_c.p_2, sizeof(struct ray_net_params));
1155 }
1156
1157 /*
1158 * Hurrah! The network is now active.
1159 *
1160 * Clearing IFF_OACTIVE will ensure that the system will send us
1161 * packets. Just before we return from the interrupt context
1162 * we check to see if packets have been queued.
1163 */
1164 if (SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd) == RAY_CMD_START_NET) {
1165 sc->sc_c.np_havenet = 1;
1166 sc->sc_c.np_framing = sc->sc_d.np_framing;
1167 ifp->if_flags |= IFF_RUNNING;
1168 ifp->if_flags &= ~IFF_OACTIVE;
1169 }
1170
1171 ray_com_ecf_done(sc);
1172}
1173
1174/*
1175 * Runq entry to authenticate with an access point or another station
1176 */
1177static void
1178ray_init_auth(struct ray_softc *sc, struct ray_comq_entry *com)
1179{
1180 struct ifnet *ifp = &sc->arpcom.ac_if;
1181
1182 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN | RAY_DBG_AUTH, "");
1183
1184 /* If card already running we might not need to authenticate */
1185 RAY_COM_CHKRUNNING(sc, com, ifp);
1186
1187 /*
1188 * XXX Don't do anything if we are not in a managed network
1189 *
1190 * XXX V4 adhoc does not need this, V5 adhoc unknown
1191 */
1192 if (sc->sc_c.np_net_type != RAY_MIB_NET_TYPE_INFRA) {
1193 ray_com_runq_done(sc);
1194 return;
1195 }
1196
1197/*
1198 * XXX_AUTH need to think of run queue when doing auths from request i.e. would
1199 * XXX_AUTH need to have auth at top of runq?
1200 * XXX_AUTH ditto for sending any auth response packets...what about timeouts?
1201 */
1202
1203 /*
1204 * Kick the card
1205 */
1206/* XXX_AUTH check exit status and retry or fail as we can't associate without this */
1207 ray_init_auth_send(sc, sc->sc_c.np_bss_id, IEEE80211_AUTH_OPEN_REQUEST);
1208}
1209
1210/*
1211 * Build and send an authentication packet
1212 *
1213 * If an error occurs, returns 1 else returns 0.
1214 */
1215static int
1216ray_init_auth_send(struct ray_softc *sc, u_int8_t *dst, int sequence)
1217{
1218 size_t ccs, bufp;
1219 int pktlen = 0;
1220
1221 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN | RAY_DBG_AUTH, "");
1222
1223 /* Get a control block */
1224 if (ray_ccs_tx(sc, &ccs, &bufp)) {
1225 RAY_RECERR(sc, "could not obtain a ccs");
1226 return (1);
1227 }
1228
1229 /* Fill the header in */
1230 bufp = ray_tx_wrhdr(sc, bufp,
1231 IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_AUTH,
1232 IEEE80211_FC1_DIR_NODS,
1233 dst,
1234 sc->arpcom.ac_enaddr,
1235 sc->sc_c.np_bss_id);
1236
1237 /* Add algorithm number */
1238 SRAM_WRITE_1(sc, bufp + pktlen++, IEEE80211_AUTH_ALG_OPEN);
1239 SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1240
1241 /* Add sequence number */
1242 SRAM_WRITE_1(sc, bufp + pktlen++, sequence);
1243 SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1244
1245 /* Add status code */
1246 SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1247 SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1248 pktlen += sizeof(struct ieee80211_frame);
1249
1250 return (ray_tx_send(sc, ccs, pktlen, dst));
1251}
1252
1253/*
1254 * Complete authentication runq
1255 */
1256static void
1257ray_init_auth_done(struct ray_softc *sc, u_int8_t status)
1258{
1259 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN | RAY_DBG_AUTH, "");
1260
1261 if (status != IEEE80211_STATUS_SUCCESS)
1262 RAY_RECERR(sc, "authentication failed with status %d", status);
1263/*
1264 * XXX_AUTH retry? if not just recall ray_init_auth_send and dont clear runq?
1265 * XXX_AUTH association requires that authenitcation is successful
1266 * XXX_AUTH before we associate, and the runq is the only way to halt the
1267 * XXX_AUTH progress of associate.
1268 * XXX_AUTH In this case I might not need the RAY_AUTH_NEEDED state
1269 */
1270 ray_com_runq_done(sc);
1271}
1272
1273/*
1274 * Runq entry to starting an association with an access point
1275 */
1276static void
1277ray_init_assoc(struct ray_softc *sc, struct ray_comq_entry *com)
1278{
1279 struct ifnet *ifp = &sc->arpcom.ac_if;
1280
1281 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1282
1283 /* If the card already running we might not need to associate */
1284 RAY_COM_CHKRUNNING(sc, com, ifp);
1285
1286 /*
1287 * Don't do anything if we are not in a managed network
1288 */
1289 if (sc->sc_c.np_net_type != RAY_MIB_NET_TYPE_INFRA) {
1290 ray_com_runq_done(sc);
1291 return;
1292 }
1293
1294 /*
1295 * Kick the card
1296 */
1297 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_START_ASSOC);
1298 ray_com_ecf(sc, com);
1299}
1300
1301/*
1302 * Complete association
1303 */
1304static void
1305ray_init_assoc_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1306{
1307 struct ifnet *ifp = &sc->arpcom.ac_if;
1308
1309 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1310 RAY_COM_CHECK(sc, ccs);
1311
1312 RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
1313
1314 /*
1315 * Hurrah! The network is now active.
1316 *
1317 * Clearing IFF_OACTIVE will ensure that the system will send us
1318 * packets. Just before we return from the interrupt context
1319 * we check to see if packets have been queued.
1320 */
1321 sc->sc_c.np_havenet = 1;
1322 sc->sc_c.np_framing = sc->sc_d.np_framing;
1323 ifp->if_flags |= IFF_RUNNING;
1324 ifp->if_flags &= ~IFF_OACTIVE;
1325
1326 ray_com_ecf_done(sc);
1327}
1328
1329/*
1330 * Network stop.
1331 *
1332 * Inhibit card - if we can't prevent reception then do not worry;
1333 * stopping a NIC only guarantees no TX.
1334 *
1335 * The change to the interface flags is done via the runq so that any
1336 * existing commands can execute normally.
1337 */
1338static int
1339ray_stop_user(struct ray_softc *sc)
1340{
1341 struct ray_comq_entry *com[1];
1342 int error, ncom;
1343
1344 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STOP, "");
1345
1346 /*
1347 * Schedule the real stop routine
1348 */
1349 ncom = 0;
1350 com[ncom++] = RAY_COM_MALLOC(ray_stop, 0);
1351
1352 RAY_COM_RUNQ(sc, com, ncom, "raystop", error);
1353
1354 /* XXX no real error processing from anything yet! */
1355
1356 RAY_COM_FREE(com, ncom);
1357
1358 return (error);
1359}
1360
1361/*
1362 * Runq entry for stopping the interface activity
1363 */
1364static void
1365ray_stop(struct ray_softc *sc, struct ray_comq_entry *com)
1366{
1367 struct ifnet *ifp = &sc->arpcom.ac_if;
984263bc
MD
1368
1369 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STOP, "");
1370
1371 /*
1372 * Mark as not running and drain output queue
1373 */
1374 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1375 ifp->if_timer = 0;
751c3dcc 1376 ifq_purge(&ifp->if_snd);
984263bc
MD
1377 ray_com_runq_done(sc);
1378}
1379
1380static void
1381ray_watchdog(struct ifnet *ifp)
1382{
1383 struct ray_softc *sc = ifp->if_softc;
1384
1385 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
1386 RAY_MAP_CM(sc);
1387
1388 if ((sc == NULL) || (sc->sc_gone))
1389 return;
1390
1391 RAY_PRINTF(sc, "watchdog timeout");
1392}
1393
1394/*
1395 * Transmit packet handling
1396 */
1397
1398/*
1399 * Send a packet.
1400 *
1401 * We make two assumptions here:
1402 * 1) That the current priority is set to splimp _before_ this code
1403 * is called *and* is returned to the appropriate priority after
1404 * return
1405 * 2) That the IFF_OACTIVE flag is checked before this code is called
1406 * (i.e. that the output part of the interface is idle)
1407 *
1408 * A simple one packet at a time TX routine is used - we don't bother
1409 * chaining TX buffers. Performance is sufficient to max out the
1410 * wireless link on a P75.
1411 *
1412 * AST J30 Windows 95A (100MHz Pentium) to
1413 * Libretto 50CT FreeBSD-3.1 (75MHz Pentium) 167.37kB/s
1414 * Nonname box FreeBSD-3.4 (233MHz AMD K6) 161.82kB/s
1415 *
1416 * Libretto 50CT FreeBSD-3.1 (75MHz Pentium) to
1417 * AST J30 Windows 95A (100MHz Pentium) 167.37kB/s
1418 * Nonname box FreeBSD-3.4 (233MHz AMD K6) 161.38kB/s
1419 *
1420 * Given that 160kB/s is saturating the 2Mb/s wireless link we
1421 * are about there.
1422 *
1423 * In short I'm happy that the added complexity of chaining TX
1424 * packets together isn't worth it for my machines.
1425 */
1426static void
1427ray_tx(struct ifnet *ifp)
1428{
1429 struct ray_softc *sc = ifp->if_softc;
1430 struct mbuf *m0, *m;
1431 struct ether_header *eh;
1432 struct llc *llc;
1433 size_t ccs, bufp;
1434 int pktlen, len;
1435
1436 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1437 RAY_MAP_CM(sc);
1438
1439 /*
1440 * Some simple checks first - some are overkill
1441 */
1442 if ((sc == NULL) || (sc->sc_gone))
1443 return;
1444 if (!(ifp->if_flags & IFF_RUNNING)) {
1445 RAY_RECERR(sc, "cannot transmit - not running");
1446 return;
1447 }
1448 if (!sc->sc_c.np_havenet) {
1449 RAY_RECERR(sc, "cannot transmit - no network");
1450 return;
1451 }
1452 if (!RAY_ECF_READY(sc)) {
1453 /* Can't assume that the ECF is busy because of this driver */
b3a81bea
JS
1454 if (!callout_active(&sc->tx_timer)) {
1455 callout_reset(&sc->tx_timer, RAY_TX_TIMEOUT,
1456 ray_tx_timo, sc);
984263bc 1457 return;
b3a81bea 1458 }
984263bc 1459 } else
b3a81bea 1460 callout_stop(&sc->tx_timer);
984263bc
MD
1461
1462 /*
1463 * We find a ccs before we process the mbuf so that we are sure it
1464 * is worthwhile processing the packet. All errors in the mbuf
1465 * processing are either errors in the mbuf or gross configuration
1466 * errors and the packet wouldn't get through anyway.
1467 */
1468 if (ray_ccs_tx(sc, &ccs, &bufp)) {
1469 ifp->if_flags |= IFF_OACTIVE;
1470 return;
1471 }
1472
1473 /*
1474 * Get the mbuf and process it - we have to remember to free the
1475 * ccs if there are any errors.
1476 */
751c3dcc 1477 m0 = ifq_dequeue(&ifp->if_snd);
984263bc
MD
1478 if (m0 == NULL) {
1479 RAY_CCS_FREE(sc, ccs);
1480 return;
1481 }
1482
1483 pktlen = m0->m_pkthdr.len;
1484 if (pktlen > ETHER_MAX_LEN - ETHER_CRC_LEN) {
1485 RAY_RECERR(sc, "mbuf too long %d", pktlen);
1486 RAY_CCS_FREE(sc, ccs);
1487 ifp->if_oerrors++;
1488 m_freem(m0);
1489 return;
1490 }
1491
1492 m0 = m_pullup(m0, sizeof(struct ether_header));
1493 if (m0 == NULL) {
1494 RAY_RECERR(sc, "could not pullup ether");
1495 RAY_CCS_FREE(sc, ccs);
1496 ifp->if_oerrors++;
1497 return;
1498 }
1499 eh = mtod(m0, struct ether_header *);
1500
1501 /*
1502 * Write the 802.11 header according to network type etc.
1503 */
1504 if (sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_ADHOC)
1505 bufp = ray_tx_wrhdr(sc, bufp,
1506 IEEE80211_FC0_TYPE_DATA,
1507 IEEE80211_FC1_DIR_NODS,
1508 eh->ether_dhost,
1509 eh->ether_shost,
1510 sc->sc_c.np_bss_id);
1511 else
1512 if (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_TERMINAL)
1513 bufp = ray_tx_wrhdr(sc, bufp,
1514 IEEE80211_FC0_TYPE_DATA,
1515 IEEE80211_FC1_DIR_TODS,
1516 sc->sc_c.np_bss_id,
1517 eh->ether_shost,
1518 eh->ether_dhost);
1519 else
1520 bufp = ray_tx_wrhdr(sc, bufp,
1521 IEEE80211_FC0_TYPE_DATA,
1522 IEEE80211_FC1_DIR_FROMDS,
1523 eh->ether_dhost,
1524 sc->sc_c.np_bss_id,
1525 eh->ether_shost);
1526
1527 /*
1528 * Framing
1529 *
1530 * Add to the mbuf.
1531 */
1532 switch (sc->sc_c.np_framing) {
1533
1534 case RAY_FRAMING_ENCAPSULATION:
1535 /* Nice and easy - nothing! (just add an 802.11 header) */
1536 break;
1537
1538 case RAY_FRAMING_TRANSLATION:
1539 /*
1540 * Drop the first address in the ethernet header and
1541 * write an LLC and SNAP header over the second.
1542 */
1543 m_adj(m0, ETHER_ADDR_LEN);
1544 if (m0 == NULL) {
1545 RAY_RECERR(sc, "could not get space for 802.2 header");
1546 RAY_CCS_FREE(sc, ccs);
1547 ifp->if_oerrors++;
1548 return;
1549 }
1550 llc = mtod(m0, struct llc *);
1551 llc->llc_dsap = LLC_SNAP_LSAP;
1552 llc->llc_ssap = LLC_SNAP_LSAP;
1553 llc->llc_control = LLC_UI;
1554 llc->llc_un.type_snap.org_code[0] = 0;
1555 llc->llc_un.type_snap.org_code[1] = 0;
1556 llc->llc_un.type_snap.org_code[2] = 0;
1557 break;
1558
1559 default:
1560 RAY_RECERR(sc, "unknown framing type %d", sc->sc_c.np_framing);
1561 RAY_CCS_FREE(sc, ccs);
1562 ifp->if_oerrors++;
1563 m_freem(m0);
1564 return;
1565
1566 }
1567 if (m0 == NULL) {
1568 RAY_RECERR(sc, "could not frame packet");
1569 RAY_CCS_FREE(sc, ccs);
1570 ifp->if_oerrors++;
1571 return;
1572 }
1573 RAY_MBUF_DUMP(sc, RAY_DBG_TX, m0, "framed packet");
1574
1575 /*
1576 * Copy the mbuf to the buffer in common memory
1577 *
1578 * We drop and don't bother wrapping as Ethernet packets are 1518
1579 * bytes, we checked the mbuf earlier, and our TX buffers are 2048
1580 * bytes. We don't have 530 bytes of headers etc. so something
1581 * must be fubar.
1582 */
1583 pktlen = sizeof(struct ieee80211_frame);
1584 for (m = m0; m != NULL; m = m->m_next) {
1585 pktlen += m->m_len;
1586 if ((len = m->m_len) == 0)
1587 continue;
1588 if ((bufp + len) < RAY_TX_END)
1589 SRAM_WRITE_REGION(sc, bufp, mtod(m, u_int8_t *), len);
1590 else {
1591 RAY_RECERR(sc, "tx buffer overflow");
1592 RAY_CCS_FREE(sc, ccs);
1593 ifp->if_oerrors++;
1594 m_freem(m0);
1595 return;
1596 }
1597 bufp += len;
1598 }
1599
1600 /*
1601 * Send it off
1602 */
1603 if (ray_tx_send(sc, ccs, pktlen, eh->ether_dhost))
1604 ifp->if_oerrors++;
1605 else
1606 ifp->if_opackets++;
1607 m_freem(m0);
1608}
1609
1610/*
1611 * Start timeout routine.
1612 *
1613 * Used when card was busy but we needed to send a packet.
1614 */
1615static void
1616ray_tx_timo(void *xsc)
1617{
1618 struct ray_softc *sc = (struct ray_softc *)xsc;
1619 struct ifnet *ifp = &sc->arpcom.ac_if;
1620 int s;
1621
1622 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
1623
751c3dcc 1624 if ((ifp->if_flags & IFF_OACTIVE) == 0 && !ifq_is_empty(&ifp->if_snd)) {
984263bc
MD
1625 s = splimp();
1626 ray_tx(ifp);
1627 splx(s);
1628 }
1629}
1630
1631/*
1632 * Write an 802.11 header into the Tx buffer space and return the
1633 * adjusted buffer pointer.
1634 */
1635static size_t
1636ray_tx_wrhdr(struct ray_softc *sc, size_t bufp, u_int8_t type, u_int8_t fc1, u_int8_t *addr1, u_int8_t *addr2, u_int8_t *addr3)
1637{
1638 struct ieee80211_frame header;
1639
1640 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1641 RAY_MAP_CM(sc);
1642
1643 bzero(&header, sizeof(struct ieee80211_frame));
1644 header.i_fc[0] = (IEEE80211_FC0_VERSION_0 | type);
1645 header.i_fc[1] = fc1;
1646 bcopy(addr1, header.i_addr1, ETHER_ADDR_LEN);
1647 bcopy(addr2, header.i_addr2, ETHER_ADDR_LEN);
1648 bcopy(addr3, header.i_addr3, ETHER_ADDR_LEN);
1649
1650 SRAM_WRITE_REGION(sc, bufp, (u_int8_t *)&header,
1651 sizeof(struct ieee80211_frame));
1652
1653 return (bufp + sizeof(struct ieee80211_frame));
1654}
1655
1656/*
1657 * Fill in a few loose ends and kick the card to send the packet
1658 *
1659 * Returns 0 on success, 1 on failure
1660 */
1661static int
1662ray_tx_send(struct ray_softc *sc, size_t ccs, int pktlen, u_int8_t *dst)
1663{
1664 int i = 0;
1665
1666 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1667 RAY_MAP_CM(sc);
1668
1669 while (!RAY_ECF_READY(sc)) {
1670 DELAY(RAY_ECF_SPIN_DELAY);
1671 if (++i > RAY_ECF_SPIN_TRIES) {
1672 RAY_RECERR(sc, "ECF busy, dropping packet");
1673 RAY_CCS_FREE(sc, ccs);
1674 return (1);
1675 }
1676 }
1677 if (i != 0)
1678 RAY_RECERR(sc, "spun %d times", i);
1679
1680 SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_len, pktlen);
1681 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_antenna,
1682 ray_tx_best_antenna(sc, dst));
1683 SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_CCS_INDEX(ccs));
1684 RAY_ECF_START_CMD(sc);
1685
1686 return (0);
1687}
1688
1689/*
1690 * Determine best antenna to use from rx level and antenna cache
1691 */
1692static u_int8_t
1693ray_tx_best_antenna(struct ray_softc *sc, u_int8_t *dst)
1694{
1695 struct ray_siglev *sl;
1696 int i;
1697 u_int8_t antenna;
1698
1699 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1700
1701 if (sc->sc_version == RAY_ECFS_BUILD_4)
1702 return (0);
1703
1704 /* try to find host */
1705 for (i = 0; i < RAY_NSIGLEVRECS; i++) {
1706 sl = &sc->sc_siglevs[i];
1707 if (bcmp(sl->rsl_host, dst, ETHER_ADDR_LEN) == 0)
1708 goto found;
1709 }
1710 /* not found, return default setting */
1711 return (0);
1712
1713found:
1714 /* This is a simple thresholding scheme that takes the mean
1715 * of the best antenna history. This is okay but as it is a
1716 * filter, it adds a bit of lag in situations where the
1717 * best antenna swaps from one side to the other slowly. Don't know
1718 * how likely this is given the horrible fading though.
1719 */
1720 antenna = 0;
1721 for (i = 0; i < RAY_NANTENNA; i++) {
1722 antenna += sl->rsl_antennas[i];
1723 }
1724
1725 return (antenna > (RAY_NANTENNA >> 1));
1726}
1727
1728/*
1729 * Transmit now complete so clear ccs and network flags.
1730 */
1731static void
1732ray_tx_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1733{
1734 struct ifnet *ifp = &sc->arpcom.ac_if;
1735
1736 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1737
1738 RAY_CCSERR(sc, status, if_oerrors);
1739
1740 RAY_CCS_FREE(sc, ccs);
1741 ifp->if_timer = 0;
1742 if (ifp->if_flags & IFF_OACTIVE)
1743 ifp->if_flags &= ~IFF_OACTIVE;
1744}
1745
1746/*
1747 * Receiver packet handling
1748 */
1749
1750/*
1751 * Receive a packet from the card
1752 */
1753static void
1754ray_rx(struct ray_softc *sc, size_t rcs)
1755{
1756 struct ieee80211_frame *header;
1757 struct ifnet *ifp = &sc->arpcom.ac_if;
1758 struct mbuf *m0;
1759 size_t pktlen, fraglen, readlen, tmplen;
1760 size_t bufp, ebufp;
1761 u_int8_t siglev, antenna;
1762 u_int first, ni, i;
1763 u_int8_t *mp;
1764
1765 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
1766 RAY_MAP_CM(sc);
1767
1768 RAY_DPRINTF(sc, RAY_DBG_CCS, "using rcs 0x%x", rcs);
1769
1770 m0 = NULL;
1771 readlen = 0;
1772
1773 /*
1774 * Get first part of packet and the length. Do some sanity checks
1775 * and get a mbuf.
1776 */
1777 first = RAY_CCS_INDEX(rcs);
1778 pktlen = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_pktlen);
1779 siglev = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_siglev);
1780 antenna = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_antenna);
1781
1782 if ((pktlen > MCLBYTES) || (pktlen < sizeof(struct ieee80211_frame))) {
1783 RAY_RECERR(sc, "packet too big or too small");
1784 ifp->if_ierrors++;
1785 goto skip_read;
1786 }
1787
74f1caca 1788 MGETHDR(m0, MB_DONTWAIT, MT_DATA);
984263bc
MD
1789 if (m0 == NULL) {
1790 RAY_RECERR(sc, "MGETHDR failed");
1791 ifp->if_ierrors++;
1792 goto skip_read;
1793 }
1794 if (pktlen > MHLEN) {
74f1caca 1795 MCLGET(m0, MB_DONTWAIT);
984263bc
MD
1796 if (!(m0->m_flags & M_EXT)) {
1797 RAY_RECERR(sc, "MCLGET failed");
1798 ifp->if_ierrors++;
1799 m_freem(m0);
1800 m0 = NULL;
1801 goto skip_read;
1802 }
1803 }
1804 m0->m_pkthdr.rcvif = ifp;
1805 m0->m_pkthdr.len = pktlen;
1806 m0->m_len = pktlen;
1807 mp = mtod(m0, u_int8_t *);
1808
1809 /*
1810 * Walk the fragment chain to build the complete packet.
1811 *
1812 * The use of two index variables removes a race with the
1813 * hardware. If one index were used the clearing of the CCS would
1814 * happen before reading the next pointer and the hardware can get in.
1815 * Not my idea but verbatim from the NetBSD driver.
1816 */
1817 i = ni = first;
1818 while ((i = ni) && (i != RAY_CCS_LINK_NULL)) {
1819 rcs = RAY_CCS_ADDRESS(i);
1820 ni = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_nextfrag);
1821 bufp = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_bufp);
1822 fraglen = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_len);
1823 if (fraglen + readlen > pktlen) {
1824 RAY_RECERR(sc, "bad length current 0x%x pktlen 0x%x",
1825 fraglen + readlen, pktlen);
1826 ifp->if_ierrors++;
1827 m_freem(m0);
1828 m0 = NULL;
1829 goto skip_read;
1830 }
1831 if ((i < RAY_RCS_FIRST) || (i > RAY_RCS_LAST)) {
1832 RAY_RECERR(sc, "bad rcs index 0x%x", i);
1833 ifp->if_ierrors++;
1834 m_freem(m0);
1835 m0 = NULL;
1836 goto skip_read;
1837 }
1838
1839 ebufp = bufp + fraglen;
1840 if (ebufp <= RAY_RX_END)
1841 SRAM_READ_REGION(sc, bufp, mp, fraglen);
1842 else {
1843 SRAM_READ_REGION(sc, bufp, mp,
1844 (tmplen = RAY_RX_END - bufp));
1845 SRAM_READ_REGION(sc, RAY_RX_BASE, mp + tmplen,
1846 ebufp - RAY_RX_END);
1847 }
1848 mp += fraglen;
1849 readlen += fraglen;
1850 }
1851
1852skip_read:
1853
1854 /*
1855 * Walk the chain again to free the rcss.
1856 */
1857 i = ni = first;
1858 while ((i = ni) && (i != RAY_CCS_LINK_NULL)) {
1859 rcs = RAY_CCS_ADDRESS(i);
1860 ni = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_nextfrag);
1861 RAY_CCS_FREE(sc, rcs);
1862 }
1863
1864 if (m0 == NULL)
1865 return;
1866
1867 /*
1868 * Check the 802.11 packet type and hand off to
1869 * appropriate functions.
1870 */
1871 header = mtod(m0, struct ieee80211_frame *);
1872 if ((header->i_fc[0] & IEEE80211_FC0_VERSION_MASK)
1873 != IEEE80211_FC0_VERSION_0) {
1874 RAY_RECERR(sc, "header not version 0 fc0 0x%x",
1875 header->i_fc[0]);
1876 ifp->if_ierrors++;
1877 m_freem(m0);
1878 return;
1879 }
1880 switch (header->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
1881
1882 case IEEE80211_FC0_TYPE_DATA:
1883 ray_rx_data(sc, m0, siglev, antenna);
1884 break;
1885
1886 case IEEE80211_FC0_TYPE_MGT:
1887 ray_rx_mgt(sc, m0);
1888 break;
1889
1890 case IEEE80211_FC0_TYPE_CTL:
1891 ray_rx_ctl(sc, m0);
1892 break;
1893
1894 default:
1895 RAY_RECERR(sc, "unknown packet fc0 0x%x", header->i_fc[0]);
1896 ifp->if_ierrors++;
1897 m_freem(m0);
1898 }
1899}
1900
1901/*
1902 * Deal with DATA packet types
1903 */
1904static void
1905ray_rx_data(struct ray_softc *sc, struct mbuf *m0, u_int8_t siglev, u_int8_t antenna)
1906{
1907 struct ifnet *ifp = &sc->arpcom.ac_if;
1908 struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
1909 struct ether_header *eh;
1910 struct llc *llc;
1911 u_int8_t *sa = NULL, *da = NULL, *ra = NULL, *ta = NULL;
1912 int trim = 0;
1913
1914 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_RX, "");
1915
1916 /*
1917 * Check the the data packet subtype, some packets have
1918 * nothing in them so we will drop them here.
1919 */
1920 switch (header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
1921
1922 case IEEE80211_FC0_SUBTYPE_DATA:
1923 case IEEE80211_FC0_SUBTYPE_CF_ACK:
1924 case IEEE80211_FC0_SUBTYPE_CF_POLL:
1925 case IEEE80211_FC0_SUBTYPE_CF_ACPL:
1926 RAY_DPRINTF(sc, RAY_DBG_RX, "DATA packet");
1927 break;
1928
1929 case IEEE80211_FC0_SUBTYPE_NODATA:
1930 case IEEE80211_FC0_SUBTYPE_CFACK:
1931 case IEEE80211_FC0_SUBTYPE_CFPOLL:
1932 case IEEE80211_FC0_SUBTYPE_CF_ACK_CF_ACK:
1933 RAY_DPRINTF(sc, RAY_DBG_RX, "NULL packet");
1934 m_freem(m0);
1935 return;
1936 break;
1937
1938 default:
1939 RAY_RECERR(sc, "reserved DATA packet subtype 0x%x",
1940 header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
1941 ifp->if_ierrors++;
1942 m_freem(m0);
1943 return;
1944 }
1945
1946 /*
1947 * Parse the To DS and From DS fields to determine the length
1948 * of the 802.11 header for use later on.
1949 *
1950 * Additionally, furtle out the right destination and
1951 * source MAC addresses for the packet. Packets may come via
1952 * APs so the MAC addresses of the immediate node may be
1953 * different from the node that actually sent us the packet.
1954 *
1955 * da destination address of final recipient
1956 * sa source address of orginator
1957 * ra receiver address of immediate recipient
1958 * ta transmitter address of immediate orginator
1959 *
1960 * Address matching is performed on da or sa with the AP or
1961 * BSSID in ra and ta.
1962 */
1963 RAY_MBUF_DUMP(sc, RAY_DBG_RX, m0, "(1) packet before framing");
1964 switch (header->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
1965
1966 case IEEE80211_FC1_DIR_NODS:
1967 da = ra = header->i_addr1;
1968 sa = ta = header->i_addr2;
1969 trim = sizeof(struct ieee80211_frame);
1970 RAY_DPRINTF(sc, RAY_DBG_RX, "from %6D to %6D",
1971 sa, ":", da, ":");
1972 break;
1973
1974 case IEEE80211_FC1_DIR_FROMDS:
1975 da = ra = header->i_addr1;
1976 ta = header->i_addr2;
1977 sa = header->i_addr3;
1978 trim = sizeof(struct ieee80211_frame);
1979 RAY_DPRINTF(sc, RAY_DBG_RX, "ap %6D from %6D to %6D",
1980 ta, ":", sa, ":", da, ":");
1981 break;
1982
1983 case IEEE80211_FC1_DIR_TODS:
1984 ra = header->i_addr1;
1985 sa = ta = header->i_addr2;
1986 da = header->i_addr3;
1987 trim = sizeof(struct ieee80211_frame);
1988 RAY_DPRINTF(sc, RAY_DBG_RX, "from %6D to %6D ap %6D",
1989 sa, ":", da, ":", ra, ":");
1990 break;
1991
1992 case IEEE80211_FC1_DIR_DSTODS:
1993 ra = header->i_addr1;
1994 ta = header->i_addr2;
1995 da = header->i_addr3;
1996 sa = (u_int8_t *)header+1;
1997 trim = sizeof(struct ieee80211_frame) + ETHER_ADDR_LEN;
1998 RAY_DPRINTF(sc, RAY_DBG_RX, "from %6D to %6D ap %6D to %6D",
1999 sa, ":", da, ":", ta, ":", ra, ":");
2000 break;
2001 }
2002
2003 /*
2004 * Framing
2005 *
2006 * Each case must leave an Ethernet header and adjust trim.
2007 */
2008 switch (sc->sc_c.np_framing) {
2009
2010 case RAY_FRAMING_ENCAPSULATION:
2011 /* A NOP as the Ethernet header is in the packet */
2012 break;
2013
2014 case RAY_FRAMING_TRANSLATION:
2015 /* Check that we have an LLC and SNAP sequence */
2016 llc = (struct llc *)((u_int8_t *)header + trim);
2017 if (llc->llc_dsap == LLC_SNAP_LSAP &&
2018 llc->llc_ssap == LLC_SNAP_LSAP &&
2019 llc->llc_control == LLC_UI &&
2020 llc->llc_un.type_snap.org_code[0] == 0 &&
2021 llc->llc_un.type_snap.org_code[1] == 0 &&
2022 llc->llc_un.type_snap.org_code[2] == 0) {
2023 /*
2024 * This is not magic. RFC1042 header is 8
2025 * bytes, with the last two bytes being the
2026 * ether type. So all we need is another
2027 * ETHER_ADDR_LEN bytes to write the
2028 * destination into.
2029 */
2030 trim -= ETHER_ADDR_LEN;
2031 eh = (struct ether_header *)((u_int8_t *)header + trim);
2032
2033 /*
2034 * Copy carefully to avoid mashing the MAC
2035 * addresses. The address layout in the .11 header
2036 * does make sense, honest, but it is a pain.
2037 *
2038 * NODS da sa no risk
2039 * FROMDS da ta sa sa then da
2040 * DSTODS ra ta da sa sa then da
2041 * TODS ra sa da da then sa
2042 */
2043 if (sa > da) {
2044 /* Copy sa first */
2045 bcopy(sa, eh->ether_shost, ETHER_ADDR_LEN);
2046 bcopy(da, eh->ether_dhost, ETHER_ADDR_LEN);
2047 } else {
2048 /* Copy da first */
2049 bcopy(da, eh->ether_dhost, ETHER_ADDR_LEN);
2050 bcopy(sa, eh->ether_shost, ETHER_ADDR_LEN);
2051 }
2052
2053 } else {
2054
2055 /* Assume RAY_FRAMING_ENCAPSULATION */
2056 RAY_RECERR(sc,
2057 "got encapsulated packet but in translation mode");
2058
2059 }
2060 break;
2061
2062 default:
2063 RAY_RECERR(sc, "unknown framing type %d", sc->sc_c.np_framing);
2064 ifp->if_ierrors++;
2065 m_freem(m0);
2066 return;
2067 }
2068 RAY_MBUF_DUMP(sc, RAY_DBG_RX, m0, "(2) packet after framing");
2069
2070 /*
2071 * Finally, do a bit of house keeping before sending the packet
2072 * up the stack.
2073 */
2074 m_adj(m0, trim);
2075 RAY_MBUF_DUMP(sc, RAY_DBG_RX, m0, "(3) packet after trimming");
2076 ifp->if_ipackets++;
2077 ray_rx_update_cache(sc, header->i_addr2, siglev, antenna);
3013ac0e 2078 (*ifp->if_input)(ifp, m0);
984263bc
MD
2079}
2080
2081/*
2082 * Deal with MGT packet types
2083 */
2084static void
2085ray_rx_mgt(struct ray_softc *sc, struct mbuf *m0)
2086{
2087 struct ifnet *ifp = &sc->arpcom.ac_if;
2088 struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2089
2090 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_MGT, "");
2091
2092 if ((header->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
2093 IEEE80211_FC1_DIR_NODS) {
2094 RAY_RECERR(sc, "MGT TODS/FROMDS wrong fc1 0x%x",
2095 header->i_fc[1] & IEEE80211_FC1_DIR_MASK);
2096 ifp->if_ierrors++;
2097 m_freem(m0);
2098 return;
2099 }
2100
2101 /*
2102 * Check the the mgt packet subtype, some packets should be
2103 * dropped depending on the mode the station is in. See pg
2104 * 52(60) of docs
2105 *
2106 * P - proccess, J - Junk, E - ECF deals with, I - Illegal
2107 * ECF Proccesses
2108 * AHDOC procces or junk
2109 * INFRA STA process or junk
2110 * INFRA AP process or jumk
2111 *
2112 * +PPP IEEE80211_FC0_SUBTYPE_BEACON
2113 * +EEE IEEE80211_FC0_SUBTYPE_PROBE_REQ
2114 * +EEE IEEE80211_FC0_SUBTYPE_PROBE_RESP
2115 * PPP IEEE80211_FC0_SUBTYPE_AUTH
2116 * PPP IEEE80211_FC0_SUBTYPE_DEAUTH
2117 * JJP IEEE80211_FC0_SUBTYPE_ASSOC_REQ
2118 * JPJ IEEE80211_FC0_SUBTYPE_ASSOC_RESP
2119 * JPP IEEE80211_FC0_SUBTYPE_DISASSOC
2120 * JJP IEEE80211_FC0_SUBTYPE_REASSOC_REQ
2121 * JPJ IEEE80211_FC0_SUBTYPE_REASSOC_RESP
2122 * +EEE IEEE80211_FC0_SUBTYPE_ATIM
2123 */
2124 RAY_MBUF_DUMP(sc, RAY_DBG_MGT, m0, "MGT packet");
2125 switch (header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
2126
2127 case IEEE80211_FC0_SUBTYPE_BEACON:
2128 RAY_DPRINTF(sc, RAY_DBG_MGT, "BEACON MGT packet");
2129 ray_rx_mgt_beacon(sc, m0);
2130 break;
2131
2132 case IEEE80211_FC0_SUBTYPE_AUTH:
2133 RAY_DPRINTF(sc, RAY_DBG_MGT, "AUTH MGT packet");
2134 ray_rx_mgt_auth(sc, m0);
2135 break;
2136
2137 case IEEE80211_FC0_SUBTYPE_DEAUTH:
2138 RAY_DPRINTF(sc, RAY_DBG_MGT, "DEAUTH MGT packet");
2139 /* XXX ray_rx_mgt_deauth(sc, m0); */
2140 break;
2141
2142 case IEEE80211_FC0_SUBTYPE_ASSOC_REQ:
2143 case IEEE80211_FC0_SUBTYPE_REASSOC_REQ:
2144 RAY_DPRINTF(sc, RAY_DBG_MGT, "(RE)ASSOC_REQ MGT packet");
2145 if ((sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_INFRA) &&
2146 (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_AP))
2147 RAY_RECERR(sc, "can't be an AP yet"); /* XXX_ACTING_AP */
2148 break;
2149
2150 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP:
2151 case IEEE80211_FC0_SUBTYPE_REASSOC_RESP:
2152 RAY_DPRINTF(sc, RAY_DBG_MGT, "(RE)ASSOC_RESP MGT packet");
2153 if ((sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_INFRA) &&
2154 (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_TERMINAL))
2155 RAY_RECERR(sc, "can't be in INFRA yet"); /* XXX_INFRA */
2156 break;
2157
2158 case IEEE80211_FC0_SUBTYPE_DISASSOC:
2159 RAY_DPRINTF(sc, RAY_DBG_MGT, "DISASSOC MGT packet");
2160 if (sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_INFRA)
2161 RAY_RECERR(sc, "can't be in INFRA yet"); /* XXX_INFRA */
2162 break;
2163
2164 case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
2165 case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
2166 case IEEE80211_FC0_SUBTYPE_ATIM:
2167 RAY_RECERR(sc, "unexpected MGT packet subtype 0x%0x",
2168 header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2169 ifp->if_ierrors++;
2170 break;
2171
2172 default:
2173 RAY_RECERR(sc, "reserved MGT packet subtype 0x%x",
2174 header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2175 ifp->if_ierrors++;
2176 }
2177
2178 m_freem(m0);
2179}
2180
2181/*
2182 * Deal with BEACON management packet types
2183 * XXX furtle anything interesting out
2184 * XXX Note that there are rules governing what beacons to read
2185 * XXX see 8802 S7.2.3, S11.1.2.3
2186 * XXX is this actually useful?
2187 */
2188static void
2189ray_rx_mgt_beacon(struct ray_softc *sc, struct mbuf *m0)
2190{
2191 struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2192 ieee80211_mgt_beacon_t beacon = (u_int8_t *)(header+1);
2193 struct ieee80211_information elements;
2194
2195 u_int64_t *timestamp;
2196
2197 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_MGT, "");
2198
2199 timestamp = (u_int64_t *)beacon;
2200
2201RAY_DPRINTF(sc, RAY_DBG_MGT, "timestamp\t0x%x", *timestamp);
2202RAY_DPRINTF(sc, RAY_DBG_MGT, "interval\t\t0x%x", IEEE80211_BEACON_INTERVAL(beacon));
2203RAY_DPRINTF(sc, RAY_DBG_MGT, "capability\t0x%x", IEEE80211_BEACON_CAPABILITY(beacon));
2204
2205 ray_rx_mgt_info(sc, m0, &elements);
2206
2207}
2208
2209static void
2210ray_rx_mgt_info(struct ray_softc *sc, struct mbuf *m0, struct ieee80211_information *elements)
2211{
2212 struct ifnet *ifp = &sc->arpcom.ac_if;
2213 struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2214 ieee80211_mgt_beacon_t beacon = (u_int8_t *)(header+1);
2215 ieee80211_mgt_beacon_t bp, be;
2216 int len;
2217
2218 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_MGT, "");
2219
2220 bp = beacon + 12;
2221 be = mtod(m0, u_int8_t *) + m0->m_len;
2222
2223 while (bp < be) {
2224 len = *(bp + 1);
2225 RAY_DPRINTF(sc, RAY_DBG_MGT, "id 0x%02x length %d", *bp, len);
2226
2227 switch (*bp) {
2228
2229 case IEEE80211_ELEMID_SSID:
2230 if (len > IEEE80211_NWID_LEN) {
2231 RAY_RECERR(sc, "bad SSD length: %d from %6D",
2232 len, header->i_addr2, ":");
2233 }
2234 strncpy(elements->ssid, bp + 2, len);
2235 elements->ssid[len] = 0;
2236 RAY_DPRINTF(sc, RAY_DBG_MGT,
2237 "beacon ssid %s", elements->ssid);
2238 break;
2239
2240 case IEEE80211_ELEMID_RATES:
2241 RAY_DPRINTF(sc, RAY_DBG_MGT, "rates");
2242 break;
2243
2244 case IEEE80211_ELEMID_FHPARMS:
2245 elements->fh.dwell = bp[2] + (bp[3] << 8);
2246 elements->fh.set = bp[4];
2247 elements->fh.pattern = bp[5];
2248 elements->fh.index = bp[6];
2249 RAY_DPRINTF(sc, RAY_DBG_MGT,
2250 "fhparams dwell\t0x%04x", elements->fh.dwell);
2251 RAY_DPRINTF(sc, RAY_DBG_MGT,
2252 "fhparams set\t0x%02x", elements->fh.set);
2253 RAY_DPRINTF(sc, RAY_DBG_MGT,
2254 "fhparams pattern\t0x%02x", elements->fh.pattern);
2255 RAY_DPRINTF(sc, RAY_DBG_MGT,
2256 "fhparams index\t0x%02x", elements->fh.index);
2257 break;
2258
2259 case IEEE80211_ELEMID_DSPARMS:
2260 RAY_RECERR(sc, "got direct sequence params!");
2261 break;
2262
2263 case IEEE80211_ELEMID_CFPARMS:
2264 RAY_DPRINTF(sc, RAY_DBG_MGT, "cfparams");
2265 break;
2266
2267 case IEEE80211_ELEMID_TIM:
2268 elements->tim.count = bp[2];
2269 elements->tim.period = bp[3];
2270 elements->tim.bitctl = bp[4];
2271 RAY_DPRINTF(sc, RAY_DBG_MGT,
2272 "tim count\t0x%02x", elements->tim.count);
2273 RAY_DPRINTF(sc, RAY_DBG_MGT,
2274 "tim period\t0x%02x", elements->tim.period);
2275 RAY_DPRINTF(sc, RAY_DBG_MGT,
2276 "tim bitctl\t0x%02x", elements->tim.bitctl);
2277#if RAY_DEBUG & RAY_DBG_MGT
2278 {
2279 int i;
2280 for (i = 5; i < len + 1; i++)
2281 RAY_DPRINTF(sc, RAY_DBG_MGT,
2282 "tim pvt[%03d]\t0x%02x", i-5, bp[i]);
2283 }
6b08710e 2284#endif
984263bc
MD
2285 break;
2286
2287 case IEEE80211_ELEMID_IBSSPARMS:
2288 elements->ibss.atim = bp[2] + (bp[3] << 8);
2289 RAY_DPRINTF(sc, RAY_DBG_MGT,
2290 "ibssparams atim\t0x%02x", elements->ibss.atim);
2291 break;
2292
2293 case IEEE80211_ELEMID_CHALLENGE:
2294 RAY_DPRINTF(sc, RAY_DBG_MGT, "challenge");
2295 break;
2296
2297 default:
2298 RAY_RECERR(sc, "reserved MGT element id 0x%x", *bp);
2299 ifp->if_ierrors++;break;
2300 }
2301 bp += bp[1] + 2;
2302 }
2303}
2304
2305/*
2306 * Deal with AUTH management packet types
2307 */
2308static void
2309ray_rx_mgt_auth(struct ray_softc *sc, struct mbuf *m0)
2310{
2311 struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2312 ieee80211_mgt_auth_t auth = (u_int8_t *)(header+1);
2313
2314 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_AUTH, "");
2315
2316 switch (IEEE80211_AUTH_ALGORITHM(auth)) {
2317
2318 case IEEE80211_AUTH_ALG_OPEN:
2319 RAY_DPRINTF(sc, RAY_DBG_AUTH,
2320 "open system authentication sequence number %d",
2321 IEEE80211_AUTH_TRANSACTION(auth));
2322 if (IEEE80211_AUTH_TRANSACTION(auth) ==
2323 IEEE80211_AUTH_OPEN_REQUEST) {
2324
2325/* XXX_AUTH use ray_init_auth_send */
2326
2327 } else if (IEEE80211_AUTH_TRANSACTION(auth) ==
2328 IEEE80211_AUTH_OPEN_RESPONSE)
2329 ray_init_auth_done(sc, IEEE80211_AUTH_STATUS(auth));
2330 break;
2331
2332 case IEEE80211_AUTH_ALG_SHARED:
2333 RAY_RECERR(sc,
2334 "shared key authentication sequence number %d",
2335 IEEE80211_AUTH_TRANSACTION(auth));
2336 break;
2337
2338 default:
2339 RAY_RECERR(sc,
2340 "reserved authentication subtype 0x%04hx",
2341 IEEE80211_AUTH_ALGORITHM(auth));
2342 break;
2343 }
2344}
2345
2346/*
2347 * Deal with CTL packet types
2348 */
2349static void
2350ray_rx_ctl(struct ray_softc *sc, struct mbuf *m0)
2351{
2352 struct ifnet *ifp = &sc->arpcom.ac_if;
2353 struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2354
2355 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CTL, "");
2356
2357 if ((header->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
2358 IEEE80211_FC1_DIR_NODS) {
2359 RAY_RECERR(sc, "CTL TODS/FROMDS wrong fc1 0x%x",
2360 header->i_fc[1] & IEEE80211_FC1_DIR_MASK);
2361 ifp->if_ierrors++;
2362 m_freem(m0);
2363 return;
2364 }
2365
2366 /*
2367 * Check the the ctl packet subtype, some packets should be
2368 * dropped depending on the mode the station is in. The ECF
2369 * should deal with everything but the power save poll to an
2370 * AP. See pg 52(60) of docs.
2371 */
2372 RAY_MBUF_DUMP(sc, RAY_DBG_CTL, m0, "CTL packet");
2373 switch (header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
2374
2375 case IEEE80211_FC0_SUBTYPE_PS_POLL:
2376 RAY_DPRINTF(sc, RAY_DBG_CTL, "PS_POLL CTL packet");
2377 if ((sc->sc_d.np_net_type == RAY_MIB_NET_TYPE_INFRA) &&
2378 (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_AP))
2379 RAY_RECERR(sc, "can't be an AP yet"); /* XXX_ACTING_AP */
2380 break;
2381
2382 case IEEE80211_FC0_SUBTYPE_RTS:
2383 case IEEE80211_FC0_SUBTYPE_CTS:
2384 case IEEE80211_FC0_SUBTYPE_ACK:
2385 case IEEE80211_FC0_SUBTYPE_CF_END:
2386 case IEEE80211_FC0_SUBTYPE_CF_END_ACK:
2387 RAY_RECERR(sc, "unexpected CTL packet subtype 0x%0x",
2388 header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2389 ifp->if_ierrors++;
2390 break;
2391
2392 default:
2393 RAY_RECERR(sc, "reserved CTL packet subtype 0x%x",
2394 header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2395 ifp->if_ierrors++;
2396 }
2397
2398 m_freem(m0);
2399}
2400
2401/*
2402 * Update rx level and antenna cache
2403 */
2404static void
2405ray_rx_update_cache(struct ray_softc *sc, u_int8_t *src, u_int8_t siglev, u_int8_t antenna)
2406{
2407 struct timeval mint;
2408 struct ray_siglev *sl;
2409 int i, mini;
2410
2411 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2412
2413 /* Try to find host */
2414 for (i = 0; i < RAY_NSIGLEVRECS; i++) {
2415 sl = &sc->sc_siglevs[i];
2416 if (bcmp(sl->rsl_host, src, ETHER_ADDR_LEN) == 0)
2417 goto found;
2418 }
2419 /* Not found, find oldest slot */
2420 mini = 0;
2421 mint.tv_sec = LONG_MAX;
2422 mint.tv_usec = 0;
2423 for (i = 0; i < RAY_NSIGLEVRECS; i++) {
2424 sl = &sc->sc_siglevs[i];
2425 if (timevalcmp(&sl->rsl_time, &mint, <)) {
2426 mini = i;
2427 mint = sl->rsl_time;
2428 }
2429 }
2430 sl = &sc->sc_siglevs[mini];
2431 bzero(sl->rsl_siglevs, RAY_NSIGLEV);
2432 bzero(sl->rsl_antennas, RAY_NANTENNA);
2433 bcopy(src, sl->rsl_host, ETHER_ADDR_LEN);
2434
2435found:
2436 microtime(&sl->rsl_time);
2437 bcopy(sl->rsl_siglevs, &sl->rsl_siglevs[1], RAY_NSIGLEV-1);
2438 sl->rsl_siglevs[0] = siglev;
2439 if (sc->sc_version != RAY_ECFS_BUILD_4) {
2440 bcopy(sl->rsl_antennas, &sl->rsl_antennas[1], RAY_NANTENNA-1);
2441 sl->rsl_antennas[0] = antenna;
2442 }
2443}
2444
2445/*
2446 * Interrupt handling
2447 */
2448
2449/*
2450 * Process an interrupt
2451 */
2452static void
2453ray_intr(void *xsc)
2454{
2455 struct ray_softc *sc = (struct ray_softc *)xsc;
2456 struct ifnet *ifp = &sc->arpcom.ac_if;
2457 size_t ccs;
2458 u_int8_t cmd, status;
2459 int ccsi;
2460
2461 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2462 RAY_MAP_CM(sc);
2463
2464 if ((sc == NULL) || (sc->sc_gone))
2465 return;
2466
2467 /*
2468 * Check that the interrupt was for us, if so get the rcs/ccs
2469 * and vector on the command contained within it.
2470 */
2471 if (RAY_HCS_INTR(sc)) {
2472 ccsi = SRAM_READ_1(sc, RAY_SCB_RCSI);
2473 ccs = RAY_CCS_ADDRESS(ccsi);
2474 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
2475 status = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
2476 if (ccsi <= RAY_CCS_LAST)
2477 ray_intr_ccs(sc, cmd, status, ccs);
2478 else if (ccsi <= RAY_RCS_LAST)
2479 ray_intr_rcs(sc, cmd, ccs);
2480 else
2481 RAY_RECERR(sc, "bad ccs index 0x%x", ccsi);
2482 RAY_HCS_CLEAR_INTR(sc);
2483 }
2484
2485 /* Send any packets lying around and update error counters */
751c3dcc 2486 if ((ifp->if_flags & IFF_OACTIVE) == 0 && !ifq_is_empty(&ifp->if_snd))
984263bc
MD
2487 ray_tx(ifp);
2488 if ((++sc->sc_checkcounters % 32) == 0)
2489 ray_intr_updt_errcntrs(sc);
2490}
2491
2492/*
2493 * Read the error counters.
2494 */
2495static void
2496ray_intr_updt_errcntrs(struct ray_softc *sc)
2497{
2498 size_t csc;
2499
2500 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2501 RAY_MAP_CM(sc);
2502
2503 /*
2504 * The card implements the following protocol to keep the
2505 * values from being changed while read: It checks the `own'
2506 * bit and if zero writes the current internal counter value,
2507 * it then sets the `own' bit to 1. If the `own' bit was 1 it
2508 * incremenets its internal counter. The user thus reads the
2509 * counter if the `own' bit is one and then sets the own bit
2510 * to 0.
2511 */
2512 csc = RAY_STATUS_BASE;
2513 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxo_own)) {
2514 sc->sc_rxoverflow +=
2515 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
2516 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxo_own, 0);
2517 }
2518 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxc_own)) {
2519 sc->sc_rxcksum +=
2520 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
2521 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxc_own, 0);
2522 }
2523 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rxhc_own)) {
2524 sc->sc_rxhcksum +=
2525 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_rx_hcksum);
2526 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_rxhc_own, 0);
2527 }
2528 sc->sc_rxnoise = SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rx_noise);
2529}
2530
2531/*
2532 * Process CCS command completion
2533 */
2534static void
2535ray_intr_ccs(struct ray_softc *sc, u_int8_t cmd, u_int8_t status, size_t ccs)
2536{
2537 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2538
2539 switch (cmd) {
2540
2541 case RAY_CMD_DOWNLOAD_PARAMS:
2542 RAY_DPRINTF(sc, RAY_DBG_COM, "START_PARAMS");
2543 ray_init_download_done(sc, status, ccs);
2544 break;
2545
2546 case RAY_CMD_UPDATE_PARAMS:
2547 RAY_DPRINTF(sc, RAY_DBG_COM, "UPDATE_PARAMS");
2548 ray_upparams_done(sc, status, ccs);
2549 break;
2550
2551 case RAY_CMD_REPORT_PARAMS:
2552 RAY_DPRINTF(sc, RAY_DBG_COM, "REPORT_PARAMS");
2553 ray_repparams_done(sc, status, ccs);
2554 break;
2555
2556 case RAY_CMD_UPDATE_MCAST:
2557 RAY_DPRINTF(sc, RAY_DBG_COM, "UPDATE_MCAST");
2558 ray_mcast_done(sc, status, ccs);
2559 break;
2560
2561 case RAY_CMD_START_NET:
2562 case RAY_CMD_JOIN_NET:
2563 RAY_DPRINTF(sc, RAY_DBG_COM, "START|JOIN_NET");
2564 ray_init_sj_done(sc, status, ccs);
2565 break;
2566
2567 case RAY_CMD_TX_REQ:
2568 RAY_DPRINTF(sc, RAY_DBG_COM, "TX_REQ");
2569 ray_tx_done(sc, status, ccs);
2570 break;
2571
2572 case RAY_CMD_START_ASSOC:
2573 RAY_DPRINTF(sc, RAY_DBG_COM, "START_ASSOC");
2574 ray_init_assoc_done(sc, status, ccs);
2575 break;
2576
2577 case RAY_CMD_UPDATE_APM:
2578 RAY_RECERR(sc, "unexpected UPDATE_APM");
2579 break;
2580
2581 case RAY_CMD_TEST_MEM:
2582 RAY_RECERR(sc, "unexpected TEST_MEM");
2583 break;
2584
2585 case RAY_CMD_SHUTDOWN:
2586 RAY_RECERR(sc, "unexpected SHUTDOWN");
2587 break;
2588
2589 case RAY_CMD_DUMP_MEM:
2590 RAY_RECERR(sc, "unexpected DUMP_MEM");
2591 break;
2592
2593 case RAY_CMD_START_TIMER:
2594 RAY_RECERR(sc, "unexpected START_TIMER");
2595 break;
2596
2597 default:
2598 RAY_RECERR(sc, "unknown command 0x%x", cmd);
2599 break;
2600 }
2601}
2602
2603/*
2604 * Process ECF command request
2605 */
2606static void
2607ray_intr_rcs(struct ray_softc *sc, u_int8_t cmd, size_t rcs)
2608{
2609 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2610
2611 switch (cmd) {
2612
2613 case RAY_ECMD_RX_DONE:
2614 RAY_DPRINTF(sc, RAY_DBG_RX, "RX_DONE");
2615 ray_rx(sc, rcs);
2616 break;
2617
2618 case RAY_ECMD_REJOIN_DONE:
2619 RAY_DPRINTF(sc, RAY_DBG_RX, "REJOIN_DONE");
2620 sc->sc_c.np_havenet = 1; /* XXX Should not be here but in function */
2621 break;
2622
2623 case RAY_ECMD_ROAM_START:
2624 RAY_DPRINTF(sc, RAY_DBG_RX, "ROAM_START");
2625 sc->sc_c.np_havenet = 0; /* XXX Should not be here but in function */
2626 break;
2627
2628 case RAY_ECMD_JAPAN_CALL_SIGNAL:
2629 RAY_RECERR(sc, "unexpected JAPAN_CALL_SIGNAL");
2630 break;
2631
2632 default:
2633 RAY_RECERR(sc, "unknown command 0x%x", cmd);
2634 break;
2635 }
2636
2637 RAY_CCS_FREE(sc, rcs);
2638}
2639
2640/*
2641 * User land entry to multicast list changes
2642 */
2643static int
2644ray_mcast_user(struct ray_softc *sc)
2645{
2646 struct ray_comq_entry *com[2];
2647 int error, ncom;
2648
2649 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2650
2651 /*
2652 * Do all checking in the runq to preserve ordering.
2653 *
2654 * We run promisc to pick up changes to the ALL_MULTI
2655 * interface flag.
2656 */
2657 ncom = 0;
2658 com[ncom++] = RAY_COM_MALLOC(ray_mcast, 0);
2659 com[ncom++] = RAY_COM_MALLOC(ray_promisc, 0);
2660
2661 RAY_COM_RUNQ(sc, com, ncom, "raymcast", error);
2662
2663 /* XXX no real error processing from anything yet! */
2664
2665 RAY_COM_FREE(com, ncom);
2666
2667 return (error);
2668}
2669
2670/*
2671 * Runq entry to setting the multicast filter list
2672 *
2673 * MUST always be followed by a call to ray_promisc to pick up changes
2674 * to promisc flag
2675 */
2676static void
2677ray_mcast(struct ray_softc *sc, struct ray_comq_entry *com)
2678{
2679 struct ifnet *ifp = &sc->arpcom.ac_if;
2680 struct ifmultiaddr *ifma;
2681 size_t bufp;
2682 int count = 0;
2683
2684 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2685 RAY_MAP_CM(sc);
2686
2687 /*
2688 * If card is not running we don't need to update this.
2689 */
2690 if (!(ifp->if_flags & IFF_RUNNING)) {
2691 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "not running");
2692 ray_com_runq_done(sc);
2693 return;
2694 }
2695
2696 /*
2697 * The multicast list is only 16 items long so use promiscuous
2698 * mode and don't bother updating the multicast list.
2699 */
2700 for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
2701 ifma = ifma->ifma_link.le_next)
2702 count++;
2703 if (count == 0) {
2704 ray_com_runq_done(sc);
2705 return;
2706 } else if (count > 16) {
2707 ifp->if_flags |= IFF_ALLMULTI;
2708 ray_com_runq_done(sc);
2709 return;
2710 } else if (ifp->if_flags & IFF_ALLMULTI)
2711 ifp->if_flags &= ~IFF_ALLMULTI;
2712
2713 /*
2714 * Kick the card
2715 */
2716 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_MCAST);
2717 SRAM_WRITE_FIELD_1(sc, com->c_ccs,
2718 ray_cmd_update_mcast, c_nmcast, count);
2719 bufp = RAY_HOST_TO_ECF_BASE;
2720 for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
2721 ifma = ifma->ifma_link.le_next) {
2722 SRAM_WRITE_REGION(
2723 sc,
2724 bufp,
2725 LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
2726 ETHER_ADDR_LEN
2727 );
2728 bufp += ETHER_ADDR_LEN;
2729 }
2730
2731 ray_com_ecf(sc, com);
2732}
2733
2734/*
2735 * Complete the multicast filter list update
2736 */
2737static void
2738ray_mcast_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
2739{
2740 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
2741 RAY_COM_CHECK(sc, ccs);
2742
2743 RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
2744
2745 ray_com_ecf_done(sc);
2746}
2747
2748/*
2749 * Runq entry to set/reset promiscuous mode
2750 */
2751static void
2752ray_promisc(struct ray_softc *sc, struct ray_comq_entry *com)
2753{
2754 struct ifnet *ifp = &sc->arpcom.ac_if;
2755
2756 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2757 RAY_MAP_CM(sc);
2758
2759 /*
2760 * If card not running or we already have the right flags
2761 * we don't need to update this
2762 */
2763 sc->sc_d.np_promisc = !!(ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI));
2764 if (!(ifp->if_flags & IFF_RUNNING) ||
2765 (sc->sc_c.np_promisc == sc->sc_d.np_promisc)) {
2766 ray_com_runq_done(sc);
2767 return;
2768 }
2769
2770 /*
2771 * Kick the card
2772 */
2773 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_PARAMS);
2774 SRAM_WRITE_FIELD_1(sc, com->c_ccs,
2775 ray_cmd_update, c_paramid, RAY_MIB_PROMISC);
2776 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_update, c_nparam, 1);
2777 SRAM_WRITE_1(sc, RAY_HOST_TO_ECF_BASE, sc->sc_d.np_promisc);
2778
2779 ray_com_ecf(sc, com);
2780}
2781
2782/*
2783 * User land entry to parameter reporting
2784 *
2785 * As we by pass the runq to report current parameters this function
2786 * only provides a snap shot of the driver's state.
2787 */
2788static int
2789ray_repparams_user(struct ray_softc *sc, struct ray_param_req *pr)
2790{
2791 struct ray_comq_entry *com[1];
2792 int error, ncom;
2793
2794 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2795
2796 /*
2797 * Test for illegal values or immediate responses
2798 */
2799 if (pr->r_paramid > RAY_MIB_MAX)
2800 return (EINVAL);
2801 if ((sc->sc_version == RAY_ECFS_BUILD_4) &&
2802 !(mib_info[pr->r_paramid][0] & RAY_V4))
2803 return (EINVAL);
2804 if ((sc->sc_version == RAY_ECFS_BUILD_5) &&
2805 !(mib_info[pr->r_paramid][0] & RAY_V5))
2806 return (EINVAL);
2807 if (pr->r_paramid > RAY_MIB_LASTUSER) {
2808 switch (pr->r_paramid) {
2809
2810 case RAY_MIB_VERSION:
2811 if (sc->sc_version == RAY_ECFS_BUILD_4)
2812 *pr->r_data = RAY_V4;
2813 else
2814 *pr->r_data = RAY_V5;
2815 break;
2816 case RAY_MIB_CUR_BSSID:
2817 bcopy(sc->sc_c.np_bss_id, pr->r_data, ETHER_ADDR_LEN);
2818 break;
2819 case RAY_MIB_CUR_INITED:
2820 *pr->r_data = sc->sc_c.np_inited;
2821 break;
2822 case RAY_MIB_CUR_DEF_TXRATE:
2823 *pr->r_data = sc->sc_c.np_def_txrate;
2824 break;
2825 case RAY_MIB_CUR_ENCRYPT:
2826 *pr->r_data = sc->sc_c.np_encrypt;
2827 break;
2828 case RAY_MIB_CUR_NET_TYPE:
2829 *pr->r_data = sc->sc_c.np_net_type;
2830 break;
2831 case RAY_MIB_CUR_SSID:
2832 bcopy(sc->sc_c.np_ssid, pr->r_data, IEEE80211_NWID_LEN);
2833 break;
2834 case RAY_MIB_CUR_PRIV_START:
2835 *pr->r_data = sc->sc_c.np_priv_start;
2836 break;
2837 case RAY_MIB_CUR_PRIV_JOIN:
2838 *pr->r_data = sc->sc_c.np_priv_join;
2839 break;
2840 case RAY_MIB_DES_BSSID:
2841 bcopy(sc->sc_d.np_bss_id, pr->r_data, ETHER_ADDR_LEN);
2842 break;
2843 case RAY_MIB_DES_INITED:
2844 *pr->r_data = sc->sc_d.np_inited;
2845 break;
2846 case RAY_MIB_DES_DEF_TXRATE:
2847 *pr->r_data = sc->sc_d.np_def_txrate;
2848 break;
2849 case RAY_MIB_DES_ENCRYPT:
2850 *pr->r_data = sc->sc_d.np_encrypt;
2851 break;
2852 case RAY_MIB_DES_NET_TYPE:
2853 *pr->r_data = sc->sc_d.np_net_type;
2854 break;
2855 case RAY_MIB_DES_SSID:
2856 bcopy(sc->sc_d.np_ssid, pr->r_data, IEEE80211_NWID_LEN);
2857 break;
2858 case RAY_MIB_DES_PRIV_START:
2859 *pr->r_data = sc->sc_d.np_priv_start;
2860 break;
2861 case RAY_MIB_DES_PRIV_JOIN:
2862 *pr->r_data = sc->sc_d.np_priv_join;
2863 break;
2864 case RAY_MIB_CUR_AP_STATUS:
2865 *pr->r_data = sc->sc_c.np_ap_status;
2866 break;
2867 case RAY_MIB_CUR_PROMISC:
2868 *pr->r_data = sc->sc_c.np_promisc;
2869 break;
2870 case RAY_MIB_DES_AP_STATUS:
2871 *pr->r_data = sc->sc_d.np_ap_status;
2872 break;
2873 case RAY_MIB_DES_PROMISC:
2874 *pr->r_data = sc->sc_d.np_promisc;
2875 break;
2876 case RAY_MIB_CUR_FRAMING:
2877 *pr->r_data = sc->sc_c.np_framing;
2878 break;
2879 case RAY_MIB_DES_FRAMING:
2880 *pr->r_data = sc->sc_d.np_framing;
2881 break;
2882
2883 default:
2884 return (EINVAL);
2885 break;
2886 }
2887 pr->r_failcause = 0;
2888 if (sc->sc_version == RAY_ECFS_BUILD_4)
2889 pr->r_len = mib_info[pr->r_paramid][RAY_MIB_INFO_SIZ4];
2890 else if (sc->sc_version == RAY_ECFS_BUILD_5)
2891 pr->r_len = mib_info[pr->r_paramid][RAY_MIB_INFO_SIZ5];
2892 return (0);
2893 }
2894
2895 pr->r_failcause = 0;
2896 ncom = 0;
2897 com[ncom++] = RAY_COM_MALLOC(ray_repparams, RAY_COM_FWOK);
2898 com[ncom-1]->c_pr = pr;
2899
2900 RAY_COM_RUNQ(sc, com, ncom, "rayrparm", error);
2901
2902 /* XXX no real error processing from anything yet! */
2903 if (!com[0]->c_retval && pr->r_failcause)
2904 error = EINVAL;
2905
2906 RAY_COM_FREE(com, ncom);
2907
2908 return (error);
2909}
2910
2911/*
2912 * Runq entry to read the required parameter
2913 *
2914 * The card and driver are happy for parameters to be read
2915 * whenever the card is plugged in
2916 */
2917static void
2918ray_repparams(struct ray_softc *sc, struct ray_comq_entry *com)
2919{
2920 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2921 RAY_MAP_CM(sc);
2922
2923 /*
2924 * Kick the card
2925 */
2926 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_REPORT_PARAMS);
2927 SRAM_WRITE_FIELD_1(sc, com->c_ccs,
2928 ray_cmd_report, c_paramid, com->c_pr->r_paramid);
2929 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_report, c_nparam, 1);
2930
2931 ray_com_ecf(sc, com);
2932}
2933
2934/*
2935 * Complete the parameter reporting
2936 */
2937static void
2938ray_repparams_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
2939{
2940 struct ray_comq_entry *com;
2941
2942 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2943 RAY_MAP_CM(sc);
2944 RAY_COM_CHECK(sc, ccs);
2945
2946 RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
2947
2948 com = TAILQ_FIRST(&sc->sc_comq);
2949 com->c_pr->r_failcause =
2950 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_failcause);
2951 com->c_pr->r_len =
2952 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_len);
2953 SRAM_READ_REGION(sc, RAY_ECF_TO_HOST_BASE,
2954 com->c_pr->r_data, com->c_pr->r_len);
2955
2956 ray_com_ecf_done(sc);
2957}
2958
2959/*
2960 * User land entry (and exit) to the error counters
2961 */
2962static int
2963ray_repstats_user(struct ray_softc *sc, struct ray_stats_req *sr)
2964{
2965 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2966
2967 sr->rxoverflow = sc->sc_rxoverflow;
2968 sr->rxcksum = sc->sc_rxcksum;
2969 sr->rxhcksum = sc->sc_rxhcksum;
2970 sr->rxnoise = sc->sc_rxnoise;
2971
2972 return (0);
2973}
2974
2975/*
2976 * User land entry to parameter update changes
2977 *
2978 * As a parameter change can cause the network parameters to be
2979 * invalid we have to re-start/join.
2980 */
2981static int
2982ray_upparams_user(struct ray_softc *sc, struct ray_param_req *pr)
2983{
2984 struct ray_comq_entry *com[4];
2985 int error, ncom, todo;
2986#define RAY_UPP_SJ 0x1
2987#define RAY_UPP_PARAMS 0x2
2988
2989 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2990
2991 /*
2992 * Check that the parameter is available based on firmware version
2993 */
2994 pr->r_failcause = 0;
2995 if (pr->r_paramid > RAY_MIB_LASTUSER)
2996 return (EINVAL);
2997 if ((sc->sc_version == RAY_ECFS_BUILD_4) &&
2998 !(mib_info[pr->r_paramid][0] & RAY_V4))
2999 return (EINVAL);
3000 if ((sc->sc_version == RAY_ECFS_BUILD_5) &&
3001 !(mib_info[pr->r_paramid][0] & RAY_V5))
3002 return (EINVAL);
3003
3004 /*
3005 * Handle certain parameters specially
3006 */
3007 todo = 0;
3008 switch (pr->r_paramid) {
3009 case RAY_MIB_NET_TYPE: /* Updated via START_NET JOIN_NET */
3010 sc->sc_d.np_net_type = *pr->r_data;
3011 todo |= RAY_UPP_SJ;
3012 break;
3013
3014 case RAY_MIB_SSID: /* Updated via START_NET JOIN_NET */
3015 bcopy(pr->r_data, sc->sc_d.np_ssid, IEEE80211_NWID_LEN);
3016 todo |= RAY_UPP_SJ;
3017 break;
3018
3019 case RAY_MIB_PRIVACY_MUST_START:/* Updated via START_NET */
3020 if (sc->sc_c.np_net_type != RAY_MIB_NET_TYPE_ADHOC)
3021 return (EINVAL);
3022 sc->sc_d.np_priv_start = *pr->r_data;
3023 todo |= RAY_UPP_SJ;
3024 break;
3025
3026 case RAY_MIB_PRIVACY_CAN_JOIN: /* Updated via START_NET JOIN_NET */
3027 sc->sc_d.np_priv_join = *pr->r_data;
3028 todo |= RAY_UPP_SJ;
3029 break;
3030
3031 case RAY_MIB_BASIC_RATE_SET:
3032 sc->sc_d.np_def_txrate = *pr->r_data;
3033 todo |= RAY_UPP_PARAMS;
3034 break;
3035
3036 case RAY_MIB_AP_STATUS: /* Unsupported */
3037 case RAY_MIB_MAC_ADDR: /* XXX Need interface up but could be done */
3038 case RAY_MIB_PROMISC: /* BPF */
3039 return (EINVAL);
3040 break;
3041
3042 default:
3043 todo |= RAY_UPP_PARAMS;
3044 todo |= RAY_UPP_SJ;
3045 break;
3046 }
3047
3048 /*
3049 * Generate the runq entries as needed
3050 */
3051 ncom = 0;
3052 if (todo & RAY_UPP_PARAMS) {
3053 com[ncom++] = RAY_COM_MALLOC(ray_upparams, 0);
3054 com[ncom-1]->c_pr = pr;
3055 }
3056 if (todo & RAY_UPP_SJ) {
3057 com[ncom++] = RAY_COM_MALLOC(ray_init_sj, 0);
3058 com[ncom++] = RAY_COM_MALLOC(ray_init_auth, 0);
3059 com[ncom++] = RAY_COM_MALLOC(ray_init_assoc, 0);
3060 }
3061
3062 RAY_COM_RUNQ(sc, com, ncom, "rayuparam", error);
3063
3064 /* XXX no real error processing from anything yet! */
3065 if (!com[0]->c_retval && pr->r_failcause)
3066 error = EINVAL;
3067
3068 RAY_COM_FREE(com, ncom);
3069
3070 return (error);
3071}
3072
3073/*
3074 * Runq entry to update a parameter
3075 *
3076 * The card and driver are happy for parameters to be updated
3077 * whenever the card is plugged in
3078 *
3079 * XXX the above is a little bit of a lie until _download is sorted out and we
3080 * XXX keep local copies of things
3081 */
3082static void
3083ray_upparams(struct ray_softc *sc, struct ray_comq_entry *com)
3084{
3085 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
3086 RAY_MAP_CM(sc);
3087
3088 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_PARAMS);
3089
3090 SRAM_WRITE_FIELD_1(sc, com->c_ccs,
3091 ray_cmd_update, c_paramid, com->c_pr->r_paramid);
3092 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_update, c_nparam, 1);
3093 SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE,
3094 com->c_pr->r_data, com->c_pr->r_len);
3095
3096 ray_com_ecf(sc, com);
3097}
3098
3099/*
3100 * Complete the parameter update, note that promisc finishes up here too
3101 */
3102static void
3103ray_upparams_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
3104{
3105 struct ray_comq_entry *com;
3106
3107 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
3108 RAY_MAP_CM(sc);
3109 RAY_COM_CHECK(sc, ccs);
3110
3111 RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
3112
3113 com = TAILQ_FIRST(&sc->sc_comq);
3114
3115 switch (SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_paramid)) {
3116
3117 case RAY_MIB_PROMISC:
3118 sc->sc_c.np_promisc = SRAM_READ_1(sc, RAY_HOST_TO_ECF_BASE);
3119 RAY_DPRINTF(sc, RAY_DBG_IOCTL,
3120 "promisc value %d", sc->sc_c.np_promisc);
3121 break;
3122
3123 default:
3124 com->c_pr->r_failcause =
3125 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_failcause);
3126 break;
3127
3128 }
3129
3130 ray_com_ecf_done(sc);
3131}
3132
3133/*
3134 * Command queuing and execution
3135 */
3136
3137/*
3138 * Set up a comq entry struct
3139 */
3140static struct ray_comq_entry *
3141ray_com_init(struct ray_comq_entry *com, ray_comqfn_t function, int flags, char *mesg)
3142{
3143 com->c_function = function;
3144 com->c_flags = flags;
3145 com->c_retval = 0;
3146 com->c_ccs = NULL;
3147 com->c_wakeup = NULL;
3148 com->c_pr = NULL;
3149 com->c_mesg = mesg;
3150
3151 return (com);
3152}
3153
3154/*
3155 * Malloc and set up a comq entry struct
3156 */
3157static struct ray_comq_entry *
3158ray_com_malloc(ray_comqfn_t function, int flags, char *mesg)
3159{
3160 struct ray_comq_entry *com;
3161
3162 MALLOC(com, struct ray_comq_entry *,
3163 sizeof(struct ray_comq_entry), M_RAYCOM, M_WAITOK);
3164
3165 return (ray_com_init(com, function, flags, mesg));
3166}
3167
3168/*
3169 * Add an array of commands to the runq, get some ccs's for them and
3170 * then run, waiting on the last command.
3171 *
3172 * We add the commands to the queue first to preserve ioctl ordering.
3173 *
3174 * On recoverable errors, this routine removes the entries from the
3175 * runq. A caller can requeue the commands (and still preserve its own
3176 * processes ioctl ordering) but doesn't have to. When the card is
3177 * detached we get out quickly to prevent panics and don't bother
3178 * about the runq.
3179 */
3180static int
3181ray_com_runq_add(struct ray_softc *sc, struct ray_comq_entry *com[], int ncom, char *wmesg)
3182{
3183 int i, error;
3184
3185 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3186
3187 error = 0;
3188 /*
3189 * Add the commands to the runq but don't let it run until
3190 * the ccs's are allocated successfully
3191 */
3192 com[0]->c_flags |= RAY_COM_FWAIT;
3193 for (i = 0; i < ncom; i++) {
3194 com[i]->c_wakeup = com[ncom-1];
3195 RAY_DPRINTF(sc, RAY_DBG_COM, "adding %p", com[i]);
3196 RAY_DCOM(sc, RAY_DBG_DCOM, com[i], "adding");
3197 TAILQ_INSERT_TAIL(&sc->sc_comq, com[i], c_chain);
3198 }
3199 com[ncom-1]->c_flags |= RAY_COM_FWOK;
3200
3201 /*
3202 * Allocate ccs's for each command.
3203 */
3204 for (i = 0; i < ncom; i++) {
3205 error = ray_ccs_alloc(sc, &com[i]->c_ccs, wmesg);
3206 if (error == ENXIO)
3207 return (ENXIO);
3208 else if (error)
3209 goto cleanup;
3210 }
3211
3212 /*
3213 * Allow the queue to run and sleep if needed.
3214 *
3215 * Iff the FDETACHED flag is set in the com entry we waited on
3216 * the driver is in a zombie state! The softc structure has been
3217 * freed by the generic bus detach methods - eek. We tread very
3218 * carefully!
3219 */
3220 com[0]->c_flags &= ~RAY_COM_FWAIT;
3221 ray_com_runq(sc);
3222 if (TAILQ_FIRST(&sc->sc_comq) != NULL) {
3223 RAY_DPRINTF(sc, RAY_DBG_COM, "sleeping");
377d4740 3224 error = tsleep(com[ncom-1], PCATCH, wmesg, 0);
984263bc
MD
3225 if (com[ncom-1]->c_flags & RAY_COM_FDETACHED)
3226 return (ENXIO);
3227 RAY_DPRINTF(sc, RAY_DBG_COM,
3228 "awakened, tsleep returned 0x%x", error);
3229 } else
3230 error = 0;
3231
3232cleanup:
3233 /*
3234 * Only clean the queue on real errors - we don't care about it
3235 * when we detach as the queue entries are freed by the callers.
3236 */
3237 if (error && (error != ENXIO))
3238 for (i = 0; i < ncom; i++)
3239 if (!(com[i]->c_flags & RAY_COM_FCOMPLETED)) {
3240 RAY_DPRINTF(sc, RAY_DBG_COM, "removing %p",
3241 com[i]);
3242 RAY_DCOM(sc, RAY_DBG_DCOM, com[i], "removing");
3243 TAILQ_REMOVE(&sc->sc_comq, com[i], c_chain);
3244 ray_ccs_free(sc, com[i]->c_ccs);
3245 com[i]->c_ccs = NULL;
3246 }
3247
3248 return (error);
3249}
3250
3251/*
3252 * Run the command at the head of the queue (if not already running)
3253 */
3254static void
3255ray_com_runq(struct ray_softc *sc)
3256{
3257 struct ray_comq_entry *com;
3258
3259 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3260
3261 com = TAILQ_FIRST(&sc->sc_comq);
3262 if ((com == NULL) ||
3263 (com->c_flags & RAY_COM_FRUNNING) ||
3264 (com->c_flags & RAY_COM_FWAIT) ||
3265 (com->c_flags & RAY_COM_FDETACHED))
3266 return;
3267
3268 com->c_flags |= RAY_COM_FRUNNING;
3269 RAY_DPRINTF(sc, RAY_DBG_COM, "running %p", com);
3270 RAY_DCOM(sc, RAY_DBG_DCOM, com, "running");
3271 com->c_function(sc, com);
3272}
3273
3274/*
3275 * Remove run command, free ccs and wakeup caller.
3276 *
3277 * Minimal checks are done here as we ensure that the com and command
3278 * handler were matched up earlier. Must be called at splnet or higher
3279 * so that entries on the command queue are correctly removed.
3280 *
3281 * Remove the com from the comq, and wakeup the caller if it requested
3282 * to be woken. This is used for ensuring a sequence of commands
3283 * completes. Finally, re-run the queue.
3284 */
3285static void
3286ray_com_runq_done(struct ray_softc *sc)
3287{
3288 struct ray_comq_entry *com;
3289
3290 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3291
3292 com = TAILQ_FIRST(&sc->sc_comq); /* XXX shall we check this as below */
3293 RAY_DPRINTF(sc, RAY_DBG_COM, "removing %p", com);
3294 RAY_DCOM(sc, RAY_DBG_DCOM, com, "removing");
3295 TAILQ_REMOVE(&sc->sc_comq, com, c_chain);
3296
3297 com->c_flags &= ~RAY_COM_FRUNNING;
3298 com->c_flags |= RAY_COM_FCOMPLETED;
3299 com->c_retval = 0;
3300 ray_ccs_free(sc, com->c_ccs);
3301 com->c_ccs = NULL;
3302
3303 if (com->c_flags & RAY_COM_FWOK)
3304 wakeup(com->c_wakeup);
3305
3306 ray_com_runq(sc);
3307
3308 /* XXX what about error on completion then? deal with when i fix
3309 * XXX the status checking
3310 *
3311 * XXX all the runq_done calls from IFF_RUNNING checks in runq
3312 * XXX routines should return EIO but shouldn't abort the runq
3313 */
3314}
3315
3316/*
3317 * Send a command to the ECF.
3318 */
3319static void
3320ray_com_ecf(struct ray_softc *sc, struct ray_comq_entry *com)
3321{
3322 int i = 0;
3323
3324 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3325 RAY_MAP_CM(sc);
3326
3327 while (!RAY_ECF_READY(sc)) {
3328 DELAY(RAY_ECF_SPIN_DELAY);
3329 if (++i > RAY_ECF_SPIN_TRIES)
3330 RAY_PANIC(sc, "spun too long");
3331 }
3332 if (i != 0)
3333 RAY_RECERR(sc, "spun %d times", i);
3334
3335 RAY_DPRINTF(sc, RAY_DBG_COM, "sending %p", com);
3336 RAY_DCOM(sc, RAY_DBG_DCOM, com, "sending");
3337 SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_CCS_INDEX(com->c_ccs));
3338 RAY_ECF_START_CMD(sc);
3339
3340 if (RAY_COM_NEEDS_TIMO(
3341 SRAM_READ_FIELD_1(sc, com->c_ccs, ray_cmd, c_cmd))) {
3342 RAY_DPRINTF(sc, RAY_DBG_COM, "adding timeout");
b3a81bea
JS
3343 callout_reset(&sc->com_timer, RAY_COM_TIMEOUT,
3344 ray_com_ecf_timo, sc);
984263bc
MD
3345 }
3346}
3347
3348/*
3349 * Deal with commands that require a timeout to test completion.
3350 *
3351 * This routine is coded to only expect one outstanding request for the
3352 * timed out requests at a time, but thats all that can be outstanding
3353 * per hardware limitations and all that we issue anyway.
3354 *
3355 * We don't do any fancy testing of the command currently issued as we
3356 * know it must be a timeout based one...unless I've got this wrong!
3357 */
3358static void
3359ray_com_ecf_timo(void *xsc)
3360{
3361 struct ray_softc *sc = (struct ray_softc *)xsc;
3362 struct ray_comq_entry *com;
3363 u_int8_t cmd, status;
3364 int s;
3365
3366 s = splnet();
3367
3368 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3369 RAY_MAP_CM(sc);
3370
3371 com = TAILQ_FIRST(&sc->sc_comq);
3372
3373 cmd = SRAM_READ_FIELD_1(sc, com->c_ccs, ray_cmd, c_cmd);
3374 status = SRAM_READ_FIELD_1(sc, com->c_ccs, ray_cmd, c_status);
3375 switch (status) {
3376
3377 case RAY_CCS_STATUS_COMPLETE:
3378 case RAY_CCS_STATUS_FREE: /* Buggy firmware */
3379 ray_intr_ccs(sc, cmd, status, com->c_ccs);
3380 break;
3381
3382 case RAY_CCS_STATUS_BUSY:
b3a81bea
JS
3383 callout_reset(&sc->com_timer, RAY_COM_TIMEOUT,
3384 ray_com_ecf_timo, sc);
984263bc
MD
3385 break;
3386
3387 default: /* Replicates NetBSD */
3388 if (sc->sc_ccsinuse[RAY_CCS_INDEX(com->c_ccs)] == 1) {
3389 /* give a chance for the interrupt to occur */
3390 sc->sc_ccsinuse[RAY_CCS_INDEX(com->c_ccs)] = 2;
b3a81bea
JS
3391 callout_reset(&sc->com_timer, RAY_COM_TIMEOUT,
3392 ray_com_ecf_timo, sc);
984263bc
MD
3393 } else
3394 ray_intr_ccs(sc, cmd, status, com->c_ccs);
3395 break;
3396
3397 }
3398
3399 splx(s);
3400}
3401
3402/*
3403 * Called when interrupt handler for the command has done all it
3404 * needs to. Will be called at splnet.
3405 */
3406static void
3407ray_com_ecf_done(struct ray_softc *sc)
3408{
3409 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3410
b3a81bea 3411 callout_stop(&sc->com_timer);
984263bc
MD
3412
3413 ray_com_runq_done(sc);
3414}
3415
3416#if RAY_DEBUG & RAY_DBG_COM
3417/*
3418 * Process completed ECF commands that probably came from the command queue
3419 *
3420 * This routine is called after vectoring the completed ECF command
3421 * to the appropriate _done routine. It helps check everything is okay.
3422 */
3423static void
3424ray_com_ecf_check(struct ray_softc *sc, size_t ccs, char *mesg)
3425{
3426 struct ray_comq_entry *com;
3427
3428 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "%s", mesg);
3429
3430 com = TAILQ_FIRST(&sc->sc_comq);
3431
3432 if (com == NULL)
3433 RAY_PANIC(sc, "no command queue");
3434 if (com->c_ccs != ccs)
3435 RAY_PANIC(sc, "ccs's don't match");
3436}
3437#endif /* RAY_DEBUG & RAY_DBG_COM */
3438
3439/*
3440 * CCS allocators
3441 */
3442
3443/*
3444 * Obtain a ccs for a commmand
3445 *
3446 * Returns 0 and in `ccsp' the bus offset of the free ccs. Will block
3447 * awaiting free ccs if needed - if the sleep is interrupted
3448 * EINTR/ERESTART is returned, if the card is ejected we return ENXIO.
3449 */
3450static int
3451ray_ccs_alloc(struct ray_softc *sc, size_t *ccsp, char *wmesg)
3452{
3453 size_t ccs;
3454 u_int i;
3455 int error;
3456
3457 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3458 RAY_MAP_CM(sc);
3459
3460 for (;;) {
3461 for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) {
3462 /* we probe here to make the card go */
3463 (void)SRAM_READ_FIELD_1(sc, RAY_CCS_ADDRESS(i), ray_cmd,
3464 c_status);
3465 if (!sc->sc_ccsinuse[i])
3466 break;
3467 }
3468 if (i > RAY_CCS_CMD_LAST) {
3469 RAY_DPRINTF(sc, RAY_DBG_CCS, "sleeping");
377d4740 3470 error = tsleep(ray_ccs_alloc, PCATCH, wmesg, 0);
984263bc
MD
3471 if ((sc == NULL) || (sc->sc_gone))
3472 return (ENXIO);
3473 RAY_DPRINTF(sc, RAY_DBG_CCS,
3474 "awakened, tsleep returned 0x%x", error);
3475 if (error)
3476 return (error);
3477 } else
3478 break;
3479 }
3480 RAY_DPRINTF(sc, RAY_DBG_CCS, "allocated 0x%02x", i);
3481 sc->sc_ccsinuse[i] = 1;
3482 ccs = RAY_CCS_ADDRESS(i);
3483 *ccsp = ccs;
3484
3485 return (0);
3486}
3487
3488/*
3489 * Fill the easy bits in of a pre-allocated CCS
3490 */
3491static void
3492ray_ccs_fill(struct ray_softc *sc, size_t ccs, u_int cmd)
3493{
3494 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3495 RAY_MAP_CM(sc);
3496
3497 if (ccs == NULL)
3498 RAY_PANIC(sc, "ccs not allocated");
3499
3500 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_BUSY);
3501 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_cmd, cmd);
3502 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_link, RAY_CCS_LINK_NULL);
3503}
3504
3505/*
3506 * Free up a ccs allocated via ray_ccs_alloc
3507 *
3508 * Return the old status. This routine is only used for ccs allocated via
3509 * ray_ccs_alloc (not tx, rx or ECF command requests).
3510 */
3511static void
3512ray_ccs_free(struct ray_softc *sc, size_t ccs)
3513{
3514 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3515 RAY_MAP_CM(sc);
3516
3517#if 1 | (RAY_DEBUG & RAY_DBG_CCS)
3518 if (!sc->sc_ccsinuse[RAY_CCS_INDEX(ccs)])
3519 RAY_RECERR(sc, "freeing free ccs 0x%02x", RAY_CCS_INDEX(ccs));
3520#endif /* RAY_DEBUG & RAY_DBG_CCS */
3521 if (!sc->sc_gone)
3522 RAY_CCS_FREE(sc, ccs);
3523 sc->sc_ccsinuse[RAY_CCS_INDEX(ccs)] = 0;
3524 RAY_DPRINTF(sc, RAY_DBG_CCS, "freed 0x%02x", RAY_CCS_INDEX(ccs));
3525 wakeup(ray_ccs_alloc);
3526}
3527
3528/*
3529 * Obtain a ccs and tx buffer to transmit with and fill them in.
3530 *
3531 * Returns 0 and in `ccsp' the bus offset of the free ccs. Will not block
3532 * and if none available and will returns EAGAIN.
3533 *
3534 * The caller must fill in the length later.
3535 * The caller must clear the ccs on errors.
3536 */
3537static int
3538ray_ccs_tx(struct ray_softc *sc, size_t *ccsp, size_t *bufpp)
3539{
3540 size_t ccs, bufp;
3541 int i;
3542 u_int8_t status;
3543
3544 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3545 RAY_MAP_CM(sc);
3546
3547 i = RAY_CCS_TX_FIRST;
3548 do {
3549 status = SRAM_READ_FIELD_1(sc, RAY_CCS_ADDRESS(i),
3550 ray_cmd, c_status);
3551 if (status == RAY_CCS_STATUS_FREE)
3552 break;
3553 i++;
3554 } while (i <= RAY_CCS_TX_LAST);
3555 if (i > RAY_CCS_TX_LAST) {
3556 return (EAGAIN);
3557 }
3558 RAY_DPRINTF(sc, RAY_DBG_CCS, "allocated 0x%02x", i);
3559
3560 /*
3561 * Reserve and fill the ccs - must do the length later.
3562 *
3563 * Even though build 4 and build 5 have different fields all these
3564 * are common apart from tx_rate. Neither the NetBSD driver or Linux
3565 * driver bother to overwrite this for build 4 cards.
3566 *
3567 * The start of the buffer must be aligned to a 256 byte boundary
3568 * (least significant byte of address = 0x00).
3569 */
3570 ccs = RAY_CCS_ADDRESS(i);
3571 bufp = RAY_TX_BASE + i * RAY_TX_BUF_SIZE;
3572 bufp += sc->sc_tibsize;
3573 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_status, RAY_CCS_STATUS_BUSY);
3574 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_cmd, RAY_CMD_TX_REQ);
3575 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_link, RAY_CCS_LINK_NULL);
3576 SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_bufp, bufp);
3577 SRAM_WRITE_FIELD_1(sc,
3578 ccs, ray_cmd_tx, c_tx_rate, sc->sc_c.np_def_txrate);
3579 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_apm_mode, 0);
3580 bufp += sizeof(struct ray_tx_phy_header);
3581
3582 *ccsp = ccs;
3583 *bufpp = bufp;
3584 return (0);
3585}
3586
3587/*
3588 * Routines to obtain resources for the card
3589 */
3590
3591/*
3592 * Allocate the attribute memory on the card
3593 *
3594 * The attribute memory space is abused by these devices as IO space. As such
3595 * the OS card services don't have a chance of knowing that they need to keep
3596 * the attribute space mapped. We have to do it manually.
3597 */
3598static int
3599ray_res_alloc_am(struct ray_softc *sc)
3600{
3601 int error;
3602
3603 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CM, "");
3604
3605 sc->am_rid = RAY_AM_RID;
3606 sc->am_res = bus_alloc_resource(sc->dev, SYS_RES_MEMORY,
3607 &sc->am_rid, 0UL, ~0UL, 0x1000, RF_ACTIVE);
3608 if (!sc->am_res) {
3609 RAY_PRINTF(sc, "Cannot allocate attribute memory");
3610 return (ENOMEM);
3611 }
3612 error = CARD_SET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
76ded439 3613 sc->am_rid, 0, NULL);
984263bc
MD
3614 if (error) {
3615 RAY_PRINTF(sc, "CARD_SET_MEMORY_OFFSET returned 0x%0x", error);
3616 return (error);
3617 }
3618 error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3619 SYS_RES_MEMORY, sc->am_rid, PCCARD_A_MEM_ATTR);
3620 if (error) {
3621 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3622 return (error);
3623 }
3624 error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3625 SYS_RES_MEMORY, sc->am_rid, PCCARD_A_MEM_8BIT);
3626 if (error) {
3627 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3628 return (error);
3629 }
3630 sc->am_bsh = rman_get_bushandle(sc->am_res);
3631 sc->am_bst = rman_get_bustag(sc->am_res);
3632
3633#if RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM)
3634{
3635 u_long flags;
3636 u_int32_t offset;
3637 CARD_GET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3638 SYS_RES_MEMORY, sc->am_rid, &flags);
3639 CARD_GET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
3640 sc->am_rid, &offset);
3641 RAY_PRINTF(sc, "allocated attribute memory:\n"
3642 ". start 0x%0lx count 0x%0lx flags 0x%0lx offset 0x%0x",
3643 bus_get_resource_start(sc->dev, SYS_RES_MEMORY, sc->am_rid),
3644 bus_get_resource_count(sc->dev, SYS_RES_MEMORY, sc->am_rid),
3645 flags, offset);
3646}
3647#endif /* RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM) */
3648
3649 return (0);
3650}
3651
3652/*
3653 * Allocate the common memory on the card
3654 *
3655 * As this memory is described in the CIS, the OS card services should
3656 * have set the map up okay, but the card uses 8 bit RAM. This is not
3657 * described in the CIS.
3658 */
3659static int
3660ray_res_alloc_cm(struct ray_softc *sc)
3661{
3662 u_long start, count, end;
3663 int error;
3664
3665 RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CM, "");
3666
3667 RAY_DPRINTF(sc,RAY_DBG_CM | RAY_DBG_BOOTPARAM,
3668 "cm start 0x%0lx count 0x%0lx",
3669 bus_get_resource_start(sc->dev, SYS_RES_MEMORY, RAY_CM_RID),
3670 bus_get_resource_count(sc->dev, SYS_RES_MEMORY, RAY_CM_RID));
3671
3672 sc->cm_rid = RAY_CM_RID;
3673 start = bus_get_resource_start(sc->dev, SYS_RES_MEMORY, sc->cm_rid);
3674 count = bus_get_resource_count(sc->dev, SYS_RES_MEMORY, sc->cm_rid);
3675 end = start + count - 1;
3676 sc->cm_res = bus_alloc_resource(sc->dev, SYS_RES_MEMORY,
3677 &sc->cm_rid, start, end, count, RF_ACTIVE);
3678 if (!sc->cm_res) {
3679 RAY_PRINTF(sc, "Cannot allocate common memory");
3680 return (ENOMEM);
3681 }
3682 error = CARD_SET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
76ded439 3683 sc->cm_rid, 0, NULL);
984263bc
MD
3684 if (error) {
3685 RAY_PRINTF(sc, "CARD_SET_MEMORY_OFFSET returned 0x%0x", error);
3686 return (error);
3687 }
3688 error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3689 SYS_RES_MEMORY, sc->cm_rid, PCCARD_A_MEM_COM);
3690 if (error) {
3691 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3692 return (error);
3693 }
3694 error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3695 SYS_RES_MEMORY, sc->cm_rid, PCCARD_A_MEM_8BIT);
3696 if (error) {
3697 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3698 return (error);
3699 }
3700 sc->cm_bsh = rman_get_bushandle(sc->cm_res);
3701 sc->cm_bst = rman_get_bustag(sc->cm_res);
3702
3703#if RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM)
3704{
3705 u_long flags;
3706 u_int32_t offset;
3707 CARD_GET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3708 SYS_RES_MEMORY, sc->cm_rid, &flags);
3709 CARD_GET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
3710 sc->cm_rid, &offset);
3711 RAY_PRINTF(sc, "allocated common memory:\n"
3712 ". start 0x%0lx count 0x%0lx flags 0x%0lx offset 0x%0x",
3713 bus_get_resource_start(sc->dev, SYS_RES_MEMORY, sc->cm_rid),
3714 bus_get_resource_count(sc->dev, SYS_RES_MEMORY, sc->cm_rid),
3715 flags, offset);
3716}
3717#endif /* RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM) */
3718
3719 return (0);
3720}
3721
3722/*
3723 * Get an irq and attach it to the bus
3724 */
3725static int
3726ray_res_alloc_irq(struct ray_softc *sc)
3727{
3728 int error;
3729
3730 RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
3731
3732 RAY_DPRINTF(sc,RAY_DBG_CM | RAY_DBG_BOOTPARAM,
3733 "irq start 0x%0lx count 0x%0lx",
3734 bus_get_resource_start(sc->dev, SYS_RES_IRQ, 0),
3735 bus_get_resource_count(sc->dev, SYS_RES_IRQ, 0));
3736
3737 sc->irq_rid = 0;
3738 sc->irq_res = bus_alloc_resource(sc->dev, SYS_RES_IRQ, &sc->irq_rid,
3739 0, ~0, 1, RF_ACTIVE);
3740 if (!sc->irq_res) {
3741 RAY_PRINTF(sc, "Cannot allocate irq");
3742 return (ENOMEM);
3743 }
3744 if ((error = bus_setup_intr(sc->dev, sc->irq_res, INTR_TYPE_NET,
3745 ray_intr, sc, &sc->irq_handle)) != 0) {
3746 RAY_PRINTF(sc, "Failed to setup irq");
3747 return (error);
3748 }
3749 RAY_DPRINTF(sc, RAY_DBG_CM | RAY_DBG_BOOTPARAM, "allocated irq:\n"
3750 ". start 0x%0lx count 0x%0lx",
3751 bus_get_resource_start(sc->dev, SYS_RES_IRQ, sc->irq_rid),
3752 bus_get_resource_count(sc->dev, SYS_RES_IRQ, sc->irq_rid));
3753
3754 return (0);
3755}
3756
3757/*
3758 * Release all of the card's resources
3759 */
3760static void
3761ray_res_release(struct ray_softc *sc)
3762{
3763 if (sc->irq_res != 0) {
3764 bus_teardown_intr(sc->dev, sc->irq_res, sc->irq_handle);
3765 bus_release_resource(sc->dev, SYS_RES_IRQ,
3766 sc->irq_rid, sc->irq_res);
3767 sc->irq_res = 0;
3768 }
3769 if (sc->am_res != 0) {
3770 bus_release_resource(sc->dev, SYS_RES_MEMORY,
3771 sc->am_rid, sc->am_res);
3772 sc->am_res = 0;
3773 }
3774 if (sc->cm_res != 0) {
3775 bus_release_resource(sc->dev, SYS_RES_MEMORY,
3776 sc->cm_rid, sc->cm_res);
3777 sc->cm_res = 0;
3778 }
3779}
3780
3781/*
3782 * mbuf dump
3783 */
3784#if RAY_DEBUG & RAY_DBG_MBUF
3785static void
3786ray_dump_mbuf(struct ray_softc *sc, struct mbuf *m, char *s)
3787{
3788 u_int8_t *d, *ed;
3789 u_int i;
3790 char p[17];
3791
3792 RAY_PRINTF(sc, "%s", s);
3793 RAY_PRINTF(sc, "\nm0->data\t0x%p\nm_pkthdr.len\t%d\nm_len\t%d",
3794 mtod(m, u_int8_t *), m->m_pkthdr.len, m->m_len);
3795 i = 0;
3796 bzero(p, 17);
3797 for (; m; m = m->m_next) {
3798 d = mtod(m, u_int8_t *);
3799 ed = d + m->m_len;
3800
3801 for (; d < ed; i++, d++) {
3802 if ((i % 16) == 0) {
3803 printf(" %s\n\t", p);
3804 } else if ((i % 8) == 0)
3805 printf(" ");
3806 printf(" %02x", *d);
3807 p[i % 16] = ((*d >= 0x20) && (*d < 0x80)) ? *d : '.';
3808 }
3809 }
3810 if ((i - 1) % 16)
3811 printf(" %s\n", p);
3812}
3813#endif /* RAY_DEBUG & RAY_DBG_MBUF */