?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Oops, I accidentally MFC'd too much.
[dragonfly.git] / sys / dev / netif / iwl / iwl2100.c
blobc1af330b4b0899b8bc2b1f07b9dda8d83d728ba9
1 /*
2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Sepherosa Ziehau <sepherosa@gmail.com>
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 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * $DragonFly: src/sys/dev/netif/iwl/iwl2100.c,v 1.4 2008/05/14 11:59:20 sephe Exp $
35 */
36
37 #include <sys/param.h>
38 #include <sys/bus.h>
39 #include <sys/endian.h>
40 #include <sys/firmware.h>
41 #include <sys/kernel.h>
42 #include <sys/interrupt.h>
43 #include <sys/mbuf.h>
44 #include <sys/module.h>
45 #include <sys/sysctl.h>
46 #include <sys/socket.h>
47 #include <sys/sockio.h>
48 #include <sys/rman.h>
49
50 #include <net/bpf.h>
51 #include <net/if.h>
52 #include <net/if_arp.h>
53 #include <net/ethernet.h>
54 #include <net/if_dl.h>
55 #include <net/if_media.h>
56 #include <net/ifq_var.h>
57 #include <net/netmsg2.h>
58
59 #include <netproto/802_11/ieee80211_var.h>
60 #include <netproto/802_11/ieee80211_radiotap.h>
61
62 #include <bus/pci/pcireg.h>
63 #include <bus/pci/pcivar.h>
64
65 #include "if_iwlvar.h"
66 #include "iwl2100reg.h"
67 #include "iwl2100var.h"
68
69 #define IWL2100_INIT_F_ENABLE 0x1
70 #define IWL2100_INIT_F_IBSSCHAN 0x2
71
72 #define sc_tx_th sc_u_tx_th.u_tx_th
73 #define sc_rx_th sc_u_rx_th.u_rx_th
74
75 static void iwl2100_init(void *);
76 static int iwl2100_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
77 static void iwl2100_start(struct ifnet *);
78 static void iwl2100_watchdog(struct ifnet *);
79 static int iwl2100_newstate(struct ieee80211com *, enum ieee80211_state, int);
80 static int iwl2100_media_change(struct ifnet *);
81 static void iwl2100_media_status(struct ifnet *, struct ifmediareq *);
82 static void iwl2100_stop(struct iwl2100_softc *);
83 static void iwl2100_restart(struct iwl2100_softc *);
84 static void iwl2100_reinit(struct iwl2100_softc *);
85
86 static void iwl2100_intr(void *);
87 static void iwl2100_txeof(struct iwl2100_softc *);
88 static void iwl2100_rxeof(struct iwl2100_softc *);
89 static void iwl2100_rxeof_status(struct iwl2100_softc *, int);
90 static void iwl2100_rxeof_note(struct iwl2100_softc *, int);
91 static void iwl2100_rxeof_cmd(struct iwl2100_softc *, int);
92 static void iwl2100_rxeof_data(struct iwl2100_softc *, int);
93
94 static void iwl2100_init_dispatch(struct netmsg *);
95 static void iwl2100_reinit_dispatch(struct netmsg *);
96 static void iwl2100_stop_dispatch(struct netmsg *);
97 static void iwl2100_newstate_dispatch(struct netmsg *);
98 static void iwl2100_scanend_dispatch(struct netmsg *);
99 static void iwl2100_restart_dispatch(struct netmsg *);
100 static void iwl2100_bmiss_dispatch(struct netmsg *);
101
102 static void iwl2100_stop_callouts(struct iwl2100_softc *);
103 static void iwl2100_restart_bmiss(void *);
104 static void iwl2100_ibss_bssid(void *);
105 static void iwl2100_reinit_callout(void *);
106
107 static int iwl2100_dma_alloc(device_t);
108 static void iwl2100_dma_free(device_t);
109 static int iwl2100_dma_mbuf_create(device_t);
110 static void iwl2100_dma_mbuf_destroy(device_t, int, int);
111 static int iwl2100_init_tx_ring(struct iwl2100_softc *);
112 static int iwl2100_init_rx_ring(struct iwl2100_softc *);
113 static void iwl2100_free_tx_ring(struct iwl2100_softc *);
114 static void iwl2100_free_rx_ring(struct iwl2100_softc *);
115
116 static int iwl2100_alloc_cmd(struct iwl2100_softc *);
117 static void iwl2100_free_cmd(struct iwl2100_softc *);
118 static int iwl2100_wait_cmd(struct iwl2100_softc *);
119
120 static void iwl2100_rxdesc_setup(struct iwl2100_softc *, int);
121 static int iwl2100_newbuf(struct iwl2100_softc *, int, int);
122 static int iwl2100_encap(struct iwl2100_softc *, struct mbuf *);
123
124 static void iwl2100_chan_change(struct iwl2100_softc *,
125 const struct ieee80211_channel *);
126
127 static int iwl2100_alloc_firmware(struct iwl2100_softc *,
128 enum ieee80211_opmode);
129 static void iwl2100_free_firmware(struct iwl2100_softc *);
130 static int iwl2100_load_firmware(struct iwl2100_softc *,
131 enum ieee80211_opmode);
132 static int iwl2100_load_fw_ucode(struct iwl2100_softc *,
133 const struct iwl2100_firmware *);
134 static int iwl2100_load_fw_data(struct iwl2100_softc *,
135 const struct iwl2100_firmware *);
136 static int iwl2100_init_firmware(struct iwl2100_softc *);
137
138 static int iwl2100_read_ord2(struct iwl2100_softc *, uint32_t,
139 void *, int);
140 static uint32_t iwl2100_read_ord1(struct iwl2100_softc *, uint32_t);
141 static void iwl2100_write_ord1(struct iwl2100_softc *, uint32_t, uint32_t);
142
143 static int iwl2100_reset(struct iwl2100_softc *);
144 static int iwl2100_hw_reset(struct iwl2100_softc *);
145 static int iwl2100_rfkilled(struct iwl2100_softc *);
146
147 static int iwl2100_scan(struct iwl2100_softc *);
148 static int iwl2100_auth(struct iwl2100_softc *);
149 static int iwl2100_ibss(struct iwl2100_softc *);
150
151 static int iwl2100_hw_init(struct iwl2100_softc *, const uint8_t *,
152 const uint8_t *, uint8_t, uint32_t);
153 static void iwl2100_hw_stop(struct iwl2100_softc *);
154 static int iwl2100_config(struct iwl2100_softc *, const uint8_t *,
155 const uint8_t *, uint8_t, int);
156 static int iwl2100_start_scan(struct iwl2100_softc *, uint32_t, uint32_t);
157
158 static int iwl2100_config_op(struct iwl2100_softc *, uint32_t);
159 static int iwl2100_set_addr(struct iwl2100_softc *, const uint8_t *);
160 static int iwl2100_set_opmode(struct iwl2100_softc *,
161 enum ieee80211_opmode);
162 static int iwl2100_set_80211(struct iwl2100_softc *);
163 static int iwl2100_set_basicrates(struct iwl2100_softc *);
164 static int iwl2100_set_txrates(struct iwl2100_softc *);
165 static int iwl2100_set_powersave(struct iwl2100_softc *, int);
166 static int iwl2100_set_rtsthreshold(struct iwl2100_softc *, uint16_t);
167 static int iwl2100_set_bssid(struct iwl2100_softc *, const uint8_t *);
168 static int iwl2100_set_essid(struct iwl2100_softc *, const uint8_t *, int);
169 static int iwl2100_set_auth_ciphers(struct iwl2100_softc *,
170 enum ieee80211_authmode);
171 static int iwl2100_set_wepkey(struct iwl2100_softc *,
172 const struct ieee80211_key *);
173 static int iwl2100_set_weptxkey(struct iwl2100_softc *, ieee80211_keyix);
174 static int iwl2100_set_privacy(struct iwl2100_softc *, int);
175 static int iwl2100_set_chan(struct iwl2100_softc *,
176 const struct ieee80211_channel *);
177 static int iwl2100_set_scanopt(struct iwl2100_softc *, uint32_t, uint32_t);
178 static int iwl2100_set_scan(struct iwl2100_softc *);
179 static int iwl2100_set_optie(struct iwl2100_softc *, void *, uint16_t);
180 static int iwl2100_set_bintval(struct iwl2100_softc *, uint16_t);
181 static int iwl2100_set_txpower(struct iwl2100_softc *, uint16_t);
182
183 static __inline int
184 iwl2100_config_done(struct iwl2100_softc *sc)
185 {
186 return iwl2100_config_op(sc, IWL2100_CMD_CONF_DONE);
187 }
188
189 static __inline int
190 iwl2100_config_start(struct iwl2100_softc *sc)
191 {
192 return iwl2100_config_op(sc, IWL2100_CMD_CONF_START);
193 }
194
195 static __inline void
196 iwl2100_restart_done(struct iwl2100_softc *sc)
197 {
198 callout_stop(&sc->sc_restart_bmiss);
199 sc->sc_flags &= ~IWL2100_F_RESTARTING;
200 }
201
202 int
203 iwl2100_attach(device_t dev)
204 {
205 struct iwl2100_softc *sc = device_get_softc(dev);
206 struct ieee80211com *ic = &sc->sc_ic;
207 struct ifnet *ifp = &ic->ic_if;
208 uint16_t val;
209 int error, i;
210
211 /*
212 * Linux voodoo:
213 * Clear the retry timeout PCI configuration register to keep
214 * PCI TX retries from interfering with C3 CPU state.
215 */
216 pci_write_config(dev, IWL2100_PCIR_RETRY_TIMEOUT, 0, 1);
217
218 /*
219 * Allocate DMA stuffs
220 */
221 error = iwl2100_dma_alloc(dev);
222 if (error)
223 return error;
224
225 /* Disable interrupts */
226 CSR_WRITE_4(sc, IWL2100_INTR_MASK, 0);
227
228 /*
229 * SW reset before reading EEPROM
230 */
231 error = iwl2100_reset(sc);
232 if (error)
233 return error;
234
235 ifp->if_softc = sc;
236 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
237 ifp->if_init = iwl2100_init;
238 ifp->if_ioctl = iwl2100_ioctl;
239 ifp->if_start = iwl2100_start;
240 ifp->if_watchdog = iwl2100_watchdog;
241 ifq_set_maxlen(&ifp->if_snd, IWL2100_TX_USED_MAX);
242 ifq_set_ready(&ifp->if_snd);
243
244 #ifdef DUMP_EEPROM
245 device_printf(dev, "eeprom\n");
246 for (i = 0; i < 128; ++i) {
247 if (i != 0 && i % 8 == 0)
248 kprintf("\n");
249 val = iwl_read_eeprom(&sc->iwlcom, i);
250 kprintf("%04x ", val);
251 }
252 kprintf("\n");
253 #endif
254
255 /* IBSS channel mask */
256 sc->sc_ibss_chans = iwl_read_eeprom(&sc->iwlcom,
257 IWL2100_EEPROM_IBSS_CHANS) & IWL2100_CFG_CHANMASK;
258
259 /* BSS channel mask */
260 sc->sc_bss_chans = iwl_read_eeprom(&sc->iwlcom, IWL2100_EEPROM_CHANS);
261
262 /*
263 * Set MAC address
264 */
265 for (i = 0; i < ETHER_ADDR_LEN / 2; ++i) {
266 val = iwl_read_eeprom(&sc->iwlcom, IWL2100_EEPROM_MAC + i);
267 ic->ic_myaddr[i * 2] = val >> 8;
268 ic->ic_myaddr[(i * 2) + 1] = val & 0xff;
269 }
270
271 /*
272 * Set supported channels
273 */
274 for (i = 0; i < 14; ++i) {
275 if (sc->sc_bss_chans & (1 << i)) {
276 int chan = i + 1;
277
278 ic->ic_channels[chan].ic_freq =
279 ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ);
280 ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_B;
281 }
282 }
283
284 ic->ic_sup_rates[IEEE80211_MODE_11B] = iwl_rateset_11b;
285 ic->ic_phytype = IEEE80211_T_DS;
286 ic->ic_caps = IEEE80211_C_MONITOR |
287 IEEE80211_C_IBSS |
288 IEEE80211_C_SHPREAMBLE |
289 IEEE80211_C_WPA;
290 ic->ic_caps_ext = IEEE80211_CEXT_AUTOSCAN;
291 ic->ic_state = IEEE80211_S_INIT;
292 ic->ic_opmode = IEEE80211_M_STA;
293
294 ieee80211_ifattach(ic);
295
296 /*
297 * ieee80211_frame will be stripped on TX path, so only
298 * extra space needs to be reserved.
299 */
300 ic->ic_headroom = sizeof(struct iwl2100_tx_hdr) -
301 sizeof(struct ieee80211_frame);
302
303 sc->sc_newstate = ic->ic_newstate;
304 ic->ic_newstate = iwl2100_newstate;
305
306 ieee80211_media_init(ic, iwl2100_media_change, iwl2100_media_status);
307
308 error = bus_setup_intr(dev, sc->sc_irq_res, INTR_MPSAFE,
309 iwl2100_intr, sc, &sc->sc_irq_handle,
310 ifp->if_serializer);
311 if (error) {
312 device_printf(dev, "can't setup intr\n");
313 ieee80211_ifdetach(ic);
314 return ENXIO;
315 }
316
317 ifp->if_cpuid = ithread_cpuid(rman_get_start(sc->sc_irq_res));
318 KKASSERT(ifp->if_cpuid >= 0 && ifp->if_cpuid < ncpus);
319
320 /*
321 * Attach radio tap
322 */
323 bpfattach_dlt(ifp, DLT_IEEE802_11_RADIO,
324 sizeof(struct ieee80211_frame) + sizeof(sc->sc_tx_th),
325 &sc->sc_drvbpf);
326
327 sc->sc_tx_th_len = roundup(sizeof(sc->sc_tx_th), sizeof(uint32_t));
328 sc->sc_tx_th.wt_ihdr.it_len = htole16(sc->sc_tx_th_len);
329 sc->sc_tx_th.wt_ihdr.it_present = htole32(IWL2100_TX_RADIOTAP_PRESENT);
330
331 sc->sc_rx_th_len = roundup(sizeof(sc->sc_rx_th), sizeof(uint32_t));
332 sc->sc_rx_th.wr_ihdr.it_len = htole16(sc->sc_rx_th_len);
333 sc->sc_rx_th.wr_ihdr.it_present = htole32(IWL2100_RX_RADIOTAP_PRESENT);
334
335 sc->sc_tx_th.wt_chan_flags = sc->sc_rx_th.wr_chan_flags =
336 htole16(IEEE80211_CHAN_B);
337
338 /*
339 * Create worker thread and initialize all necessary messages
340 */
341 iwl_create_thread(&sc->iwlcom, device_get_unit(dev));
342
343 iwlmsg_init(&sc->sc_scanend_msg, &netisr_adone_rport,
344 iwl2100_scanend_dispatch, sc);
345 iwlmsg_init(&sc->sc_restart_msg, &netisr_adone_rport,
346 iwl2100_restart_dispatch, sc);
347 iwlmsg_init(&sc->sc_bmiss_msg, &netisr_adone_rport,
348 iwl2100_bmiss_dispatch, sc);
349 iwlmsg_init(&sc->sc_reinit_msg, &netisr_adone_rport,
350 iwl2100_reinit_dispatch, sc);
351
352 iwlmsg_init(&sc->sc_assoc_msg, &netisr_adone_rport,
353 iwl2100_newstate_dispatch, sc);
354 sc->sc_assoc_msg.iwlm_nstate = IEEE80211_S_ASSOC;
355 sc->sc_assoc_msg.iwlm_arg = -1;
356
357 iwlmsg_init(&sc->sc_run_msg, &netisr_adone_rport,
358 iwl2100_newstate_dispatch, sc);
359 sc->sc_run_msg.iwlm_nstate = IEEE80211_S_RUN;
360 sc->sc_run_msg.iwlm_arg = -1;
361
362 /*
363 * Initialize callouts
364 */
365 callout_init(&sc->sc_restart_bmiss);
366 callout_init(&sc->sc_ibss);
367 callout_init(&sc->sc_reinit);
368
369 /* Add sysctl node */
370 SYSCTL_ADD_UINT(&sc->sc_sysctl_ctx,
371 SYSCTL_CHILDREN(sc->sc_sysctl_tree), OID_AUTO,
372 "debug", CTLFLAG_RW, &sc->sc_debug, 0, "debug flags");
373
374 if (bootverbose)
375 ieee80211_announce(ic);
376 return 0;
377 }
378
379 void
380 iwl2100_detach(device_t dev)
381 {
382 struct iwl2100_softc *sc = device_get_softc(dev);
383
384 if (device_is_attached(dev)) {
385 struct ifnet *ifp = &sc->sc_ic.ic_if;
386
387 lwkt_serialize_enter(ifp->if_serializer);
388
389 sc->sc_flags |= IWL2100_F_DETACH;
390 iwl2100_stop(sc);
391 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_handle);
392 iwl_destroy_thread(&sc->iwlcom);
393
394 lwkt_serialize_exit(ifp->if_serializer);
395
396 iwl2100_free_firmware(sc);
397
398 bpfdetach(ifp);
399 ieee80211_ifdetach(&sc->sc_ic);
400 }
401 iwl2100_dma_free(dev);
402 }
403
404 int
405 iwl2100_shutdown(device_t dev)
406 {
407 struct iwl2100_softc *sc = device_get_softc(dev);
408 struct ifnet *ifp = &sc->sc_ic.ic_if;
409
410 lwkt_serialize_enter(ifp->if_serializer);
411 iwl2100_stop(sc);
412 lwkt_serialize_exit(ifp->if_serializer);
413
414 return 0;
415 }
416
417 static void
418 iwl2100_stop(struct iwl2100_softc *sc)
419 {
420 struct iwlmsg msg;
421
422 ASSERT_SERIALIZED(sc->sc_ic.ic_if.if_serializer);
423
424 iwl2100_stop_callouts(sc);
425
426 iwlmsg_init(&msg, &sc->sc_reply_port, iwl2100_stop_dispatch, sc);
427 lwkt_domsg(&sc->sc_thread_port, &msg.iwlm_nmsg.nm_lmsg, 0);
428 }
429
430 static void
431 iwl2100_stop_dispatch(struct netmsg *nmsg)
432 {
433 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
434 struct iwl2100_softc *sc = msg->iwlm_softc;
435
436 ASSERT_SERIALIZED(sc->sc_ic.ic_if.if_serializer);
437
438 ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
439 iwl2100_hw_stop(sc);
440 lwkt_replymsg(&nmsg->nm_lmsg, 0);
441 }
442
443 static void
444 iwl2100_hw_stop(struct iwl2100_softc *sc)
445 {
446 struct ifnet *ifp = &sc->sc_ic.ic_if;
447
448 ASSERT_SERIALIZED(ifp->if_serializer);
449 KKASSERT(curthread == &sc->sc_thread);
450
451 callout_stop(&sc->sc_reinit);
452
453 /* Disable interrupts */
454 CSR_WRITE_4(sc, IWL2100_INTR_MASK, 0);
455
456 /*
457 * HW and SW reset
458 */
459 iwl2100_hw_reset(sc);
460 iwl2100_reset(sc);
461
462 /*
463 * Free TX/RX rings
464 */
465 iwl2100_free_tx_ring(sc);
466 iwl2100_free_rx_ring(sc);
467
468 /* NOTE: MUST after iwl2100_free_tx_ring() */
469 iwl2100_free_cmd(sc);
470
471 ifp->if_timer = 0;
472 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
473
474 sc->sc_tx_timer = 0;
475 sc->sc_flags &= ~(IWL2100_F_WAITCMD |
476 IWL2100_F_INITED |
477 IWL2100_F_SCANNING |
478 IWL2100_F_RESTARTING |
479 IWL2100_F_IFSTART |
480 IWL2100_F_ERROR |
481 IWL2100_F_ZERO_CMD);
482 }
483
484 static int
485 iwl2100_reset(struct iwl2100_softc *sc)
486 {
487 int i;
488
489 /*
490 * Software reset
491 */
492 #define WAIT_MAX 1000
493
494 CSR_WRITE_4(sc, IWL2100_RESET, IWL2100_RESET_SW);
495 for (i = 0; i < WAIT_MAX; ++i) {
496 DELAY(10);
497 if (CSR_READ_4(sc, IWL2100_RESET) & IWL2100_RESET_DONE)
498 break;
499 }
500 if (i == WAIT_MAX) {
501 if_printf(&sc->sc_ic.ic_if, "sw reset timed out\n");
502 return ETIMEDOUT;
503 }
504
505 #undef WAIT_MAX
506
507 /*
508 * Move to D0 state, wait clock to become stable
509 */
510 #define WAIT_MAX 10000
511
512 CSR_WRITE_4(sc, IWL2100_CTRL, IWL2100_CTRL_INITDONE);
513 for (i = 0; i < WAIT_MAX; ++i) {
514 DELAY(200);
515 if (CSR_READ_4(sc, IWL2100_CTRL) & IWL2100_CTRL_CLKREADY)
516 break;
517 }
518 if (i == WAIT_MAX) {
519 if_printf(&sc->sc_ic.ic_if, "can't stablize clock\n");
520 return ETIMEDOUT;
521 }
522
523 #undef WAIT_MAX
524
525 /*
526 * Move to D0 standby
527 */
528 CSR_SETBITS_4(sc, IWL2100_CTRL, IWL2100_CTRL_STANDBY);
529 return 0;
530 }
531
532 static int
533 iwl2100_dma_alloc(device_t dev)
534 {
535 struct iwl2100_softc *sc = device_get_softc(dev);
536 struct iwl2100_tx_ring *tr = &sc->sc_txring;
537 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
538 int error;
539
540 /*
541 * Create top level DMA tag
542 */
543 error = bus_dma_tag_create(NULL, 1, 0,
544 BUS_SPACE_MAXADDR_32BIT,
545 BUS_SPACE_MAXADDR,
546 NULL, NULL,
547 MAXBSIZE,
548 BUS_SPACE_UNRESTRICTED,
549 BUS_SPACE_MAXSIZE_32BIT,
550 0, &sc->sc_dtag);
551 if (error) {
552 device_printf(dev, "can't create DMA tag\n");
553 return error;
554 }
555
556 /*
557 * Create DMA stuffs for TX desc ring
558 */
559 error = iwl_dma_mem_create(dev, sc->sc_dtag, IWL2100_TXRING_SIZE,
560 &tr->tr_dtag, (void **)&tr->tr_desc,
561 &tr->tr_paddr, &tr->tr_dmap);
562 if (error) {
563 device_printf(dev, "can't create DMA memory for "
564 "TX desc ring\n");
565 return error;
566 }
567
568 /*
569 * Create DMA stuffs for RX desc ring
570 */
571 error = iwl_dma_mem_create(dev, sc->sc_dtag, IWL2100_RXRING_SIZE,
572 &rr->rr_dtag, (void **)&rr->rr_desc,
573 &rr->rr_paddr, &rr->rr_dmap);
574 if (error) {
575 device_printf(dev, "can't create DMA memory for "
576 "RX desc ring\n");
577 return error;
578 }
579
580 /*
581 * Create DMA stuffs for RX status ring
582 */
583 error = iwl_dma_mem_create(dev, sc->sc_dtag, IWL2100_RXSTATUS_SIZE,
584 &rr->rr_st_dtag, (void **)&rr->rr_status,
585 &rr->rr_st_paddr, &rr->rr_st_dmap);
586 if (error) {
587 device_printf(dev, "can't create DMA memory for "
588 "RX status ring\n");
589 return error;
590 }
591
592 /*
593 * Create mbuf DMA stuffs
594 */
595 error = iwl2100_dma_mbuf_create(dev);
596 if (error)
597 return error;
598
599 return 0;
600 }
601
602 static void
603 iwl2100_dma_free(device_t dev)
604 {
605 struct iwl2100_softc *sc = device_get_softc(dev);
606 struct iwl2100_tx_ring *tr = &sc->sc_txring;
607 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
608
609 /* Free DMA stuffs for TX desc ring */
610 iwl_dma_mem_destroy(tr->tr_dtag, tr->tr_desc, tr->tr_dmap);
611
612 /* Free DMA stuffs for RX desc ring */
613 iwl_dma_mem_destroy(rr->rr_dtag, rr->rr_desc, rr->rr_dmap);
614
615 /* Free DMA stuffs for RX status ring */
616 iwl_dma_mem_destroy(rr->rr_st_dtag, rr->rr_status, rr->rr_st_dmap);
617
618 /* Free DMA stuffs for mbufs */
619 iwl2100_dma_mbuf_destroy(dev, IWL2100_TX_NDESC, IWL2100_RX_NDESC);
620
621 /* Free top level DMA tag */
622 if (sc->sc_dtag != NULL)
623 bus_dma_tag_destroy(sc->sc_dtag);
624 }
625
626 static int
627 iwl2100_dma_mbuf_create(device_t dev)
628 {
629 struct iwl2100_softc *sc = device_get_softc(dev);
630 struct iwl2100_tx_ring *tr = &sc->sc_txring;
631 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
632 int i, error;
633
634 /*
635 * Create mbuf DMA tag
636 */
637 error = bus_dma_tag_create(sc->sc_dtag, 1, 0,
638 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
639 NULL, NULL,
640 MCLBYTES, IWL2100_NSEG_MAX,
641 BUS_SPACE_MAXSIZE_32BIT,
642 BUS_DMA_ALLOCNOW, &sc->sc_mbuf_dtag);
643 if (error) {
644 device_printf(dev, "can't create mbuf DMA tag\n");
645 return error;
646 }
647
648 /*
649 * Create spare DMA map for RX mbufs
650 */
651 error = bus_dmamap_create(sc->sc_mbuf_dtag, 0, &rr->rr_tmp_dmap);
652 if (error) {
653 device_printf(dev, "can't create spare mbuf DMA map\n");
654 bus_dma_tag_destroy(sc->sc_mbuf_dtag);
655 sc->sc_mbuf_dtag = NULL;
656 return error;
657 }
658
659 /*
660 * Create DMA maps for RX mbufs
661 */
662 for (i = 0; i < IWL2100_RX_NDESC; ++i) {
663 error = bus_dmamap_create(sc->sc_mbuf_dtag, 0,
664 &rr->rr_buf[i].rb_dmap);
665 if (error) {
666 device_printf(dev, "can't create %d RX mbuf "
667 "for RX ring\n", i);
668 iwl2100_dma_mbuf_destroy(dev, 0, i);
669 return error;
670 }
671 }
672
673 /*
674 * Create DMA maps for TX mbufs
675 */
676 for (i = 0; i < IWL2100_TX_NDESC; ++i) {
677 error = bus_dmamap_create(sc->sc_mbuf_dtag, 0,
678 &tr->tr_buf[i].tb_dmap);
679 if (error) {
680 device_printf(dev, "can't create %d TX mbuf "
681 "DMA map\n", i);
682 iwl2100_dma_mbuf_destroy(dev, i, IWL2100_RX_NDESC);
683 return error;
684 }
685 }
686 return 0;
687 }
688
689 static void
690 iwl2100_dma_mbuf_destroy(device_t dev, int tx_done, int rx_done)
691 {
692 struct iwl2100_softc *sc = device_get_softc(dev);
693 struct iwl2100_tx_ring *tr = &sc->sc_txring;
694 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
695 int i;
696
697 if (sc->sc_mbuf_dtag == NULL)
698 return;
699
700 /*
701 * Destroy DMA maps for RX mbufs
702 */
703 for (i = 0; i < rx_done; ++i) {
704 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
705
706 KASSERT(rb->rb_mbuf == NULL, ("RX mbuf is not freed yet\n"));
707 bus_dmamap_destroy(sc->sc_mbuf_dtag, rb->rb_dmap);
708 }
709
710 /*
711 * Destroy DMA maps for TX mbufs
712 */
713 for (i = 0; i < tx_done; ++i) {
714 struct iwl2100_txbuf *tb = &tr->tr_buf[i];
715
716 KASSERT(tb->tb_mbuf == NULL, ("TX mbuf is not freed yet\n"));
717 bus_dmamap_destroy(sc->sc_mbuf_dtag, tb->tb_dmap);
718 }
719
720 /*
721 * Destroy spare mbuf DMA map
722 */
723 bus_dmamap_destroy(sc->sc_mbuf_dtag, rr->rr_tmp_dmap);
724
725 /*
726 * Destroy mbuf DMA tag
727 */
728 bus_dma_tag_destroy(sc->sc_mbuf_dtag);
729 sc->sc_mbuf_dtag = NULL;
730 }
731
732 static void
733 iwl2100_init(void *xsc)
734 {
735 struct iwl2100_softc *sc = xsc;
736 struct iwlmsg msg;
737
738 ASSERT_SERIALIZED(sc->sc_ic.ic_if.if_serializer);
739
740 iwl2100_stop_callouts(sc);
741
742 iwlmsg_init(&msg, &sc->sc_reply_port, iwl2100_init_dispatch, sc);
743 lwkt_domsg(&sc->sc_thread_port, &msg.iwlm_nmsg.nm_lmsg, 0);
744 }
745
746 static void
747 iwl2100_init_dispatch(struct netmsg *nmsg)
748 {
749 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
750 struct iwl2100_softc *sc = msg->iwlm_softc;
751 struct ieee80211com *ic = &sc->sc_ic;
752 struct ifnet *ifp = &ic->ic_if;
753 int error = 0, flags;
754
755 ASSERT_SERIALIZED(ifp->if_serializer);
756
757 if (sc->sc_flags & IWL2100_F_DETACH)
758 goto back;
759
760 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
761
762 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
763 /*
764 * XXX
765 * Workaround for dummy firmware:
766 * Don't enable hardware too early, since
767 * once it is enabled, it will start scanning.
768 */
769 flags = 0;
770 } else {
771 flags = IWL2100_INIT_F_ENABLE;
772 }
773
774 /* Always put the device into a known state */
775 error = iwl2100_hw_init(sc, NULL,
776 ic->ic_des_essid, ic->ic_des_esslen, flags);
777 if (error)
778 goto back;
779
780 if (sc->sc_flags & IWL2100_F_ZERO_CMD) {
781 if_printf(ifp, "zero cmd, reinit 1s later\n");
782 iwl2100_hw_stop(sc);
783
784 callout_reset(&sc->sc_reinit, hz, iwl2100_reinit_callout, sc);
785 goto back;
786 }
787
788 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
789 if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
790 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
791 } else {
792 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
793 }
794 back:
795 if (error)
796 iwl2100_stop(sc);
797 lwkt_replymsg(&nmsg->nm_lmsg, error);
798 }
799
800 static int
801 iwl2100_ioctl(struct ifnet *ifp, u_long cmd, caddr_t req, struct ucred *cr)
802 {
803 struct iwl2100_softc *sc = ifp->if_softc;
804 int error = 0;
805
806 ASSERT_SERIALIZED(ifp->if_serializer);
807
808 if (sc->sc_flags & IWL2100_F_DETACH)
809 return 0;
810
811 switch (cmd) {
812 case SIOCSIFFLAGS:
813 if (ifp->if_flags & IFF_UP) {
814 if ((ifp->if_flags & IFF_RUNNING) == 0)
815 iwl2100_init(sc);
816 } else {
817 if (ifp->if_flags & IFF_RUNNING) {
818 iwl2100_stop(sc);
819 } else {
820 /*
821 * Stop callouts explicitly, since
822 * if reinitialization is happening,
823 * IFF_RUNNING will not be turned on.
824 */
825 iwl2100_stop_callouts(sc);
826 }
827 }
828 break;
829 default:
830 error = ieee80211_ioctl(&sc->sc_ic, cmd, req, cr);
831 break;
832 }
833
834 if (error == ENETRESET) {
835 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
836 (IFF_UP | IFF_RUNNING))
837 iwl2100_init(sc);
838 error = 0;
839 }
840 return error;
841 }
842
843 static void
844 iwl2100_start(struct ifnet *ifp)
845 {
846 struct iwl2100_softc *sc = ifp->if_softc;
847 struct ieee80211com *ic = &sc->sc_ic;
848 struct iwl2100_tx_ring *tr = &sc->sc_txring;
849 int trans = 0;
850
851 ASSERT_SERIALIZED(ifp->if_serializer);
852
853 if (sc->sc_flags & IWL2100_F_DETACH) {
854 ieee80211_drain_mgtq(&ic->ic_mgtq);
855 ifq_purge(&ifp->if_snd);
856 return;
857 }
858
859 if ((ifp->if_flags & (IFF_OACTIVE | IFF_RUNNING)) != IFF_RUNNING)
860 return;
861
862 if ((sc->sc_flags & IWL2100_F_IFSTART) == 0) {
863 ifq_purge(&ifp->if_snd);
864 goto back;
865 }
866
867 while (tr->tr_used < IWL2100_TX_USED_MAX) {
868 struct ieee80211_frame *wh;
869 struct ieee80211_node *ni;
870 struct ether_header *eh;
871 struct mbuf *m;
872
873 m = ifq_dequeue(&ifp->if_snd, NULL);
874 if (m == NULL)
875 break;
876
877 if (m->m_len < sizeof(*eh)) {
878 m = m_pullup(m, sizeof(*eh));
879 if (m == NULL) {
880 ifp->if_oerrors++;
881 continue;
882 }
883 }
884 eh = mtod(m, struct ether_header *);
885
886 ni = ieee80211_find_txnode(ic, eh->ether_dhost);
887 if (ni == NULL) {
888 m_freem(m);
889 ifp->if_oerrors++;
890 continue;
891 }
892
893 /* TODO: PS */
894
895 BPF_MTAP(ifp, m);
896
897 m = ieee80211_encap(ic, m, ni);
898 if (m == NULL) {
899 ieee80211_free_node(ni);
900 ifp->if_oerrors++;
901 continue;
902 }
903
904 if (ic->ic_rawbpf != NULL)
905 bpf_mtap(ic->ic_rawbpf, m);
906
907 wh = mtod(m, struct ieee80211_frame *);
908 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
909 if (ieee80211_crypto_encap(ic, ni, m) == NULL) {
910 ieee80211_free_node(ni);
911 m_freem(m);
912 ifp->if_oerrors++;
913 continue;
914 }
915 }
916
917 /*
918 * TX radio tap
919 */
920 if (sc->sc_drvbpf != NULL) {
921 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
922 sc->sc_tx_th.wt_flags = IEEE80211_RADIOTAP_F_WEP;
923 else
924 sc->sc_tx_th.wt_flags = 0;
925 bpf_ptap(sc->sc_drvbpf, m, &sc->sc_tx_th,
926 sc->sc_tx_th_len);
927 }
928 wh = NULL; /* Catch any invalid use */
929
930 ieee80211_free_node(ni);
931
932 if (iwl2100_encap(sc, m)) {
933 ifp->if_oerrors++;
934 continue;
935 }
936
937 ifp->if_opackets++;
938 trans = 1;
939 }
940
941 if (tr->tr_used >= IWL2100_TX_USED_MAX)
942 ifp->if_flags |= IFF_OACTIVE;
943
944 if (trans) {
945 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
946 CSR_WRITE_4(sc, IWL2100_TXQ_WRITE_IDX, tr->tr_index);
947 sc->sc_tx_timer = 5;
948 }
949 back:
950 ieee80211_drain_mgtq(&ic->ic_mgtq);
951 ifp->if_timer = 1;
952 }
953
954 static void
955 iwl2100_watchdog(struct ifnet *ifp)
956 {
957 struct iwl2100_softc *sc = ifp->if_softc;
958
959 ASSERT_SERIALIZED(ifp->if_serializer);
960
961 if (sc->sc_flags & IWL2100_F_DETACH)
962 return;
963
964 if (sc->sc_tx_timer) {
965 if (--sc->sc_tx_timer == 0) {
966 if_printf(ifp, "watchdog timeout!\n");
967 ifp->if_oerrors++;
968 iwl2100_restart(sc);
969 return;
970 } else {
971 ifp->if_timer = 1;
972 }
973 }
974 ieee80211_watchdog(&sc->sc_ic);
975 }
976
977 static int
978 iwl2100_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
979 {
980 struct ifnet *ifp = &ic->ic_if;
981 struct iwl2100_softc *sc = ifp->if_softc;
982 struct iwlmsg msg;
983
984 ASSERT_SERIALIZED(ifp->if_serializer);
985
986 iwlmsg_init(&msg, &sc->sc_reply_port, iwl2100_newstate_dispatch, sc);
987 msg.iwlm_nstate = nstate;
988 msg.iwlm_arg = arg;
989
990 return lwkt_domsg(&sc->sc_thread_port, &msg.iwlm_nmsg.nm_lmsg, 0);
991 }
992
993 static void
994 iwl2100_newstate_dispatch(struct netmsg *nmsg)
995 {
996 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
997 struct iwl2100_softc *sc = msg->iwlm_softc;
998 struct ieee80211com *ic = &sc->sc_ic;
999 #ifdef INVARIANTS
1000 struct ifnet *ifp = &ic->ic_if;
1001 #endif
1002 enum ieee80211_state nstate, ostate;
1003 int arg = msg->iwlm_arg, error = 0;
1004
1005 ASSERT_SERIALIZED(ifp->if_serializer);
1006
1007 nstate = msg->iwlm_nstate;
1008 ostate = ic->ic_state;
1009
1010 sc->sc_flags &= ~IWL2100_F_IFSTART;
1011 sc->sc_state_age++;
1012
1013 iwl2100_chan_change(sc, ic->ic_curchan);
1014
1015 callout_stop(&sc->sc_ibss);
1016 iwl2100_restart_done(sc);
1017
1018 if (nstate == IEEE80211_S_INIT)
1019 goto back;
1020
1021 if (sc->sc_flags & IWL2100_F_DETACH) {
1022 /*
1023 * Except for INIT, we skip rest of the
1024 * state changes during detaching
1025 */
1026 goto reply;
1027 }
1028
1029 if (ic->ic_opmode == IEEE80211_M_STA) {
1030 if (nstate == IEEE80211_S_AUTH)
1031 error = iwl2100_auth(sc);
1032 else if (nstate == IEEE80211_S_RUN)
1033 sc->sc_flags |= IWL2100_F_IFSTART;
1034 } else if (ic->ic_opmode == IEEE80211_M_IBSS) {
1035 if (nstate == IEEE80211_S_RUN) {
1036 DPRINTF(sc, IWL2100_DBG_IBSS, "%s",
1037 "start/join ibss\n");
1038
1039 /*
1040 * IWL2100_F_IFSTART can't be turned on
1041 * until BSSID generated by the firmware
1042 * is extracted.
1043 *
1044 * XXX only if we started the IBSS
1045 */
1046 error = iwl2100_ibss(sc);
1047 }
1048 }
1049 back:
1050 if (!error)
1051 error = sc->sc_newstate(ic, nstate, arg);
1052
1053 if (!error) {
1054 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
1055 /*
1056 * Don't use 'nstate' here, since for IBSS
1057 * mode 802.11 layer may enter RUN state in
1058 * a recursive manner, i.e. when we reach
1059 * here, nstate != ic->ic_state
1060 */
1061 if (ic->ic_state == IEEE80211_S_SCAN &&
1062 ic->ic_state != ostate) {
1063 DPRINTF(sc, IWL2100_DBG_SCAN, "%s",
1064 "start scan\n");
1065 error = iwl2100_scan(sc);
1066 }
1067 }
1068 }
1069 reply:
1070 lwkt_replymsg(&nmsg->nm_lmsg, error);
1071 }
1072
1073 static int
1074 iwl2100_media_change(struct ifnet *ifp)
1075 {
1076 int error;
1077
1078 ASSERT_SERIALIZED(ifp->if_serializer);
1079
1080 error = ieee80211_media_change(ifp);
1081 if (error != ENETRESET)
1082 return error;
1083
1084 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
1085 iwl2100_init(ifp->if_softc);
1086 return 0;
1087 }
1088
1089 static void
1090 iwl2100_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1091 {
1092 struct iwl2100_softc *sc = ifp->if_softc;
1093
1094 if (sc->sc_flags & IWL2100_F_IFSTART) {
1095 struct ieee80211_node *ni = sc->sc_ic.ic_bss;
1096 uint32_t txrate;
1097 int i, nrates = 4;
1098
1099 txrate = iwl2100_read_ord1(sc, IWL2100_ORD1_TXRATE) & 0xf;
1100 if (ni->ni_rates.rs_nrates < 4)
1101 nrates = ni->ni_rates.rs_nrates;
1102
1103 for (i = 0; i < nrates; ++i) {
1104 if ((1 << i) & txrate)
1105 ni->ni_txrate = i;
1106 }
1107 }
1108 ieee80211_media_status(ifp, imr);
1109 }
1110
1111 static void
1112 iwl2100_intr(void *xsc)
1113 {
1114 struct iwl2100_softc *sc = xsc;
1115 struct ifnet *ifp = &sc->sc_ic.ic_if;
1116 uint32_t intr_status;
1117
1118 ASSERT_SERIALIZED(ifp->if_serializer);
1119
1120 if ((sc->sc_flags & IWL2100_F_INITED) == 0)
1121 return;
1122
1123 intr_status = CSR_READ_4(sc, IWL2100_INTR_STATUS);
1124 if (intr_status == 0xffffffff) /* not for us */
1125 return;
1126
1127 if ((intr_status & IWL2100_INTRS) == 0) /* not interested */
1128 return;
1129
1130 sc->sc_flags |= IWL2100_F_IN_INTR;
1131
1132 /* Disable interrupts */
1133 CSR_WRITE_4(sc, IWL2100_INTR_MASK, 0);
1134
1135 if (intr_status & IWL2100_INTR_EFATAL) {
1136 uint32_t error_info;
1137
1138 if_printf(ifp, "intr fatal error\n");
1139 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_EFATAL);
1140
1141 error_info = IND_READ_4(sc, IWL2100_IND_ERROR_INFO);
1142 IND_READ_4(sc, error_info & IWL2100_IND_ERRORADDR_MASK);
1143
1144 callout_stop(&sc->sc_reinit);
1145 iwl2100_reinit(sc);
1146
1147 /* Leave interrupts disabled */
1148 goto back;
1149 }
1150
1151 if (intr_status & IWL2100_INTR_EPARITY) {
1152 if_printf(ifp, "intr parity error\n");
1153 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_EPARITY);
1154 }
1155
1156 if (intr_status & IWL2100_INTR_RX) {
1157 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_RX);
1158 iwl2100_rxeof(sc);
1159 iwl2100_txeof(sc);
1160 }
1161
1162 if (intr_status & IWL2100_INTR_TX) {
1163 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_TX);
1164 iwl2100_txeof(sc);
1165 }
1166
1167 if (intr_status & IWL2100_INTR_FW_INITED)
1168 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_FW_INITED);
1169 if (intr_status & IWL2100_INTR_CMD_DONE)
1170 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_CMD_DONE);
1171
1172 /* Enable interrupts */
1173 CSR_WRITE_4(sc, IWL2100_INTR_MASK, IWL2100_INTRS);
1174 back:
1175 sc->sc_flags &= ~IWL2100_F_IN_INTR;
1176 }
1177
1178 static int
1179 iwl2100_hw_reset(struct iwl2100_softc *sc)
1180 {
1181 int i;
1182
1183 /*
1184 * Initialize GPIO:
1185 * - Enable GPIO3
1186 * - Make GPIO3 firmware writable
1187 * - Enable GPIO1
1188 * - Turn off LED
1189 */
1190 CSR_WRITE_4(sc, IWL2100_GPIO,
1191 IWL2100_GPIO_3_EN | IWL2100_GPIO_3_FWWR |
1192 IWL2100_GPIO_1_EN | IWL2100_GPIO_LEDOFF);
1193
1194 /*
1195 * Stop master
1196 */
1197 #define WAIT_MAX 5
1198
1199 CSR_WRITE_4(sc, IWL2100_RESET, IWL2100_RESET_STOP_MASTER);
1200 for (i = 0; i < WAIT_MAX; ++i) {
1201 DELAY(10);
1202
1203 if (CSR_READ_4(sc, IWL2100_RESET) &
1204 IWL2100_RESET_MASTER_STOPPED)
1205 break;
1206 }
1207 if (i == WAIT_MAX) {
1208 if_printf(&sc->sc_ic.ic_if, "can't stop master\n");
1209 return ETIMEDOUT;
1210 }
1211
1212 #undef WAIT_MAX
1213
1214 CSR_WRITE_4(sc, IWL2100_RESET, IWL2100_RESET_SW);
1215 return 0;
1216 }
1217
1218 static int
1219 iwl2100_alloc_firmware(struct iwl2100_softc *sc, enum ieee80211_opmode opmode)
1220 {
1221 struct {
1222 const char *suffix;
1223 uint16_t mode;
1224 enum ieee80211_opmode opmode;
1225 struct iwl2100_firmware *fw;
1226 } fw_arr[] = {
1227 { "", IWL2100_FW_M_STA, IEEE80211_M_STA,
1228 &sc->sc_fw_sta },
1229 { "-i", IWL2100_FW_M_IBSS, IEEE80211_M_IBSS,
1230 &sc->sc_fw_ibss },
1231 { "-p", IWL2100_FW_M_MONITOR, IEEE80211_M_MONITOR,
1232 &sc->sc_fw_monitor },
1233 { NULL, 0, 0, NULL }
1234 };
1235 struct ifnet *ifp = &sc->sc_ic.ic_if;
1236 const struct iwl2100_fwimg_hdr *hdr;
1237 struct iwl2100_firmware *fw = NULL;
1238 struct fw_image *image;
1239 char filename[128];
1240 int i, error;
1241
1242 for (i = 0; fw_arr[i].fw != NULL; ++i) {
1243 fw = fw_arr[i].fw;
1244
1245 if (fw_arr[i].opmode == opmode) {
1246 if (fw->fw_image != NULL)
1247 return 0;
1248 else
1249 break;
1250 }
1251 }
1252 KASSERT(fw_arr[i].fw != NULL, ("unsupported opmode %u\n", opmode));
1253
1254 ksnprintf(filename, sizeof(filename), IWL2100_FW_PATH,
1255 fw_arr[i].suffix);
1256
1257 /*
1258 * Release the serializer to avoid possible dead lock
1259 */
1260 lwkt_serialize_exit(ifp->if_serializer);
1261 image = firmware_image_load(filename, NULL);
1262 lwkt_serialize_enter(ifp->if_serializer);
1263
1264 if (image == NULL)
1265 return ENOENT;
1266 fw->fw_image = image;
1267
1268 /*
1269 * Verify the image
1270 */
1271 error = EINVAL;
1272
1273 hdr = (const struct iwl2100_fwimg_hdr *)image->fw_image;
1274 if ((hdr->version & 0xff) != 1) {
1275 if_printf(ifp, "%s unsupported firmware version %d",
1276 image->fw_name, hdr->version & 0xff);
1277 goto back;
1278 }
1279
1280 if (hdr->mode != fw_arr[i].mode) {
1281 if_printf(ifp, "%s contains %d mode firmware, should be %d\n",
1282 image->fw_name, hdr->mode, fw_arr[i].mode);
1283 goto back;
1284 }
1285
1286 if (hdr->data_size + hdr->ucode_size + sizeof(*hdr) !=
1287 image->fw_imglen) {
1288 if_printf(ifp, "%s size mismatch, %u/hdr %u\n", image->fw_name,
1289 fw->fw_image->fw_imglen,
1290 hdr->data_size + hdr->ucode_size + sizeof(*hdr));
1291 goto back;
1292 }
1293
1294 fw->fw_data = (const uint8_t *)(hdr + 1);
1295 fw->fw_data_size = hdr->data_size;
1296 fw->fw_ucode = fw->fw_data + fw->fw_data_size;
1297 fw->fw_ucode_size = hdr->ucode_size;
1298 error = 0;
1299 back:
1300 if (error) {
1301 firmware_image_unload(fw->fw_image);
1302 bzero(fw, sizeof(*fw));
1303 }
1304 return error;
1305 }
1306
1307 static void
1308 iwl2100_free_firmware(struct iwl2100_softc *sc)
1309 {
1310 struct iwl2100_firmware *fw_arr[] =
1311 { &sc->sc_fw_sta, &sc->sc_fw_ibss, &sc->sc_fw_monitor, NULL };
1312 int i;
1313
1314 for (i = 0; fw_arr[i] != NULL; ++i) {
1315 struct iwl2100_firmware *fw = fw_arr[i];
1316
1317 if (fw->fw_image != NULL) {
1318 firmware_image_unload(fw->fw_image);
1319 bzero(fw, sizeof(*fw));
1320 }
1321 }
1322 }
1323
1324 static int
1325 iwl2100_load_firmware(struct iwl2100_softc *sc, enum ieee80211_opmode opmode)
1326 {
1327 static const struct {
1328 uint32_t addr;
1329 int size;
1330 } share_mem[] = {
1331 { IWL2100_SHMEM0, IWL2100_SHMEM0_SIZE },
1332 { IWL2100_SHMEM1, IWL2100_SHMEM1_SIZE },
1333 { IWL2100_SHMEM2, IWL2100_SHMEM2_SIZE },
1334 { IWL2100_SHMEM3, IWL2100_SHMEM3_SIZE },
1335 { IWL2100_SHMEM_INTR, IWL2100_SHMEM_INTR_SIZE },
1336 { 0, 0 }
1337 };
1338 const struct iwl2100_firmware *fw = NULL;
1339 int i, error;
1340
1341 /*
1342 * Pick up the firmware image corresponding to
1343 * the current operation mode
1344 */
1345 switch (opmode) {
1346 case IEEE80211_M_STA:
1347 fw = &sc->sc_fw_sta;
1348 break;
1349 case IEEE80211_M_IBSS:
1350 fw = &sc->sc_fw_ibss;
1351 break;
1352 case IEEE80211_M_MONITOR:
1353 fw = &sc->sc_fw_monitor;
1354 break;
1355 default:
1356 panic("unsupported opmode %d\n", opmode);
1357 break;
1358 }
1359 KASSERT(fw->fw_image != NULL,
1360 ("opmode %d firmware image is not allocated yet\n", opmode));
1361
1362 /* Load ucode */
1363 error = iwl2100_load_fw_ucode(sc, fw);
1364 if (error)
1365 return error;
1366
1367 /* SW reset */
1368 error = iwl2100_reset(sc);
1369 if (error)
1370 return error;
1371
1372 /* Load data */
1373 error = iwl2100_load_fw_data(sc, fw);
1374 if (error)
1375 return error;
1376
1377 /* Clear shared memory */
1378 for (i = 0; share_mem[i].size != 0; ++i) {
1379 uint32_t addr = share_mem[i].addr;
1380 int j;
1381
1382 for (j = 0; j < share_mem[i].size; j += 4)
1383 IND_WRITE_4(sc, addr + j, 0);
1384 }
1385
1386 return 0;
1387 }
1388
1389 #define IND_WRITE_FLUSH_2(sc, reg, val) \
1390 do { \
1391 IND_WRITE_2((sc), (reg), (val)); \
1392 CSR_READ_4((sc), 0); \
1393 } while (0)
1394
1395 #define IND_WRITE_FLUSH_1(sc, reg, val) \
1396 do { \
1397 IND_WRITE_1((sc), (reg), (val)); \
1398 CSR_READ_4((sc), 0); \
1399 } while (0)
1400
1401 /* XXX need more comment */
1402 static int
1403 iwl2100_load_fw_ucode(struct iwl2100_softc *sc,
1404 const struct iwl2100_firmware *fw)
1405 {
1406 struct iwl2100_ucode_resp resp;
1407 const uint8_t *p;
1408 int i;
1409
1410 /* Hold ARC */
1411 IND_WRITE_4(sc, IWL2100_IND_HALT, IWL2100_IND_HALT_HOLD);
1412
1413 /* Allow ARC to run */
1414 CSR_WRITE_4(sc, IWL2100_RESET, 0);
1415
1416 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x703);
1417 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x707);
1418
1419 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1420 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1421
1422 IND_WRITE_FLUSH_1(sc, 0x210000, 0x40);
1423 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1424 IND_WRITE_FLUSH_1(sc, 0x210000, 0x40);
1425
1426 p = fw->fw_ucode;
1427 for (i = 0; i < fw->fw_ucode_size; ++i, ++p)
1428 IND_WRITE_1(sc, 0x210010, *p);
1429
1430 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1431 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1432 IND_WRITE_FLUSH_1(sc, 0x210000, 0x80);
1433
1434
1435 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x703);
1436 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x707);
1437
1438 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1439 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1440
1441 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1442 IND_WRITE_1(sc, 0x210000, 0x80);
1443
1444 #define WAIT_MAX 10
1445 for (i = 0; i < WAIT_MAX; ++i) {
1446 DELAY(10);
1447
1448 if (IND_READ_1(sc, 0x210000) & 0x1)
1449 break;
1450 }
1451 if (i == WAIT_MAX) {
1452 if_printf(&sc->sc_ic.ic_if,
1453 "wait ucode symbol init timed out\n");
1454 return ETIMEDOUT;
1455 }
1456 #undef WAIT_MAX
1457
1458 #define WAIT_MAX 30
1459 for (i = 0; i < WAIT_MAX; ++i) {
1460 uint16_t *r = (uint16_t *)&resp;
1461 int j;
1462
1463 for (j = 0; j < sizeof(resp) / 2; ++j, ++r)
1464 *r = IND_READ_2(sc, 0x210004);
1465
1466 if (resp.cmd_id == 1 && resp.ucode_valid == 1)
1467 break;
1468 DELAY(10);
1469 }
1470 if (i == WAIT_MAX) {
1471 if_printf(&sc->sc_ic.ic_if,
1472 "wait ucode response timed out\n");
1473 return ETIMEDOUT;
1474 }
1475 #undef WAIT_MAX
1476
1477 /* Release ARC */
1478 IND_WRITE_4(sc, IWL2100_IND_HALT, 0);
1479
1480 if (bootverbose) {
1481 if_printf(&sc->sc_ic.ic_if, "ucode rev.%d date %d.%d.20%02d "
1482 "time %02d:%02d\n", resp.ucode_rev,
1483 resp.date_time[0], resp.date_time[1],
1484 resp.date_time[2], resp.date_time[3],
1485 resp.date_time[4]);
1486 }
1487
1488 return 0;
1489 }
1490
1491 #undef IND_WRITE_FLUSH_1
1492 #undef IND_WRITE_FLUSH_2
1493
1494 static int
1495 iwl2100_load_fw_data(struct iwl2100_softc *sc,
1496 const struct iwl2100_firmware *fw)
1497 {
1498 const uint8_t *p = fw->fw_data;
1499 int w = 0;
1500
1501 while (w < fw->fw_data_size) {
1502 const struct iwl2100_fwdata_hdr *h;
1503 int hlen, i;
1504
1505 h = (const struct iwl2100_fwdata_hdr *)p;
1506 if (h->len > 32 || h->len == 0) {
1507 if_printf(&sc->sc_ic.ic_if,
1508 "firmware image data corrupted\n");
1509 return EINVAL;
1510 }
1511 if ((h->addr & 0x3) || (h->len & 0x3)) {
1512 if_printf(&sc->sc_ic.ic_if,
1513 "firmware image data with unaligned "
1514 "address %#x or length %#x\n",
1515 h->addr, h->len);
1516 return EOPNOTSUPP;
1517 }
1518
1519 hlen = sizeof(*h) + h->len - 1;
1520 if (w + hlen > fw->fw_data_size) {
1521 if_printf(&sc->sc_ic.ic_if,
1522 "firmware image data size mismatch\n");
1523 return EINVAL;
1524 }
1525
1526 CSR_WRITE_4(sc, IWL2100_AUTOINC_ADDR, h->addr);
1527 for (i = 0; i < h->len; i += 4) {
1528 CSR_WRITE_4(sc, IWL2100_AUTOINC_DATA,
1529 *(const uint32_t *)&h->data[i]);
1530 }
1531
1532 p += hlen;
1533 w += hlen;
1534 }
1535 KKASSERT(w == fw->fw_data_size);
1536
1537 return 0;
1538 }
1539
1540 static void
1541 iwl2100_free_tx_ring(struct iwl2100_softc *sc)
1542 {
1543 struct iwl2100_tx_ring *tr = &sc->sc_txring;
1544 int i;
1545
1546 for (i = 0; i < IWL2100_TX_NDESC; ++i) {
1547 struct iwl2100_txbuf *tb = &tr->tr_buf[i];
1548
1549 if (tb->tb_mbuf != NULL) {
1550 bus_dmamap_unload(sc->sc_mbuf_dtag, tb->tb_dmap);
1551 if (tb->tb_flags & IWL2100_TBF_CMDBUF) {
1552 KKASSERT(tb->tb_mbuf == sc->sc_cmd);
1553 tb->tb_flags &= ~IWL2100_TBF_CMDBUF;
1554 } else {
1555 m_freem(tb->tb_mbuf);
1556 }
1557 tb->tb_mbuf = NULL;
1558 }
1559 }
1560
1561 bzero(tr->tr_desc, IWL2100_TXRING_SIZE);
1562 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
1563
1564 tr->tr_used = 0;
1565 tr->tr_index = 0;
1566 tr->tr_coll = 0;
1567 }
1568
1569 static void
1570 iwl2100_free_rx_ring(struct iwl2100_softc *sc)
1571 {
1572 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1573 int i;
1574
1575 for (i = 0; i < IWL2100_RX_NDESC; ++i) {
1576 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
1577
1578 if (rb->rb_mbuf != NULL) {
1579 bus_dmamap_unload(sc->sc_mbuf_dtag, rb->rb_dmap);
1580 m_freem(rb->rb_mbuf);
1581 rb->rb_mbuf = NULL;
1582 }
1583 }
1584
1585 bzero(rr->rr_desc, IWL2100_RXRING_SIZE);
1586 bus_dmamap_sync(rr->rr_dtag, rr->rr_dmap, BUS_DMASYNC_PREWRITE);
1587
1588 bzero(rr->rr_status, IWL2100_RXSTATUS_SIZE);
1589 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap, BUS_DMASYNC_PREWRITE);
1590
1591 rr->rr_index = 0;
1592 }
1593
1594 static void
1595 iwl2100_free_cmd(struct iwl2100_softc *sc)
1596 {
1597 if (sc->sc_cmd != NULL) {
1598 m_freem(sc->sc_cmd);
1599 sc->sc_cmd = NULL;
1600 }
1601 }
1602
1603 static int
1604 iwl2100_init_tx_ring(struct iwl2100_softc *sc)
1605 {
1606 struct iwl2100_tx_ring *tr = &sc->sc_txring;
1607
1608 tr->tr_used = 0;
1609 tr->tr_index = 0;
1610 tr->tr_coll = 0;
1611
1612 bzero(tr->tr_desc, IWL2100_TXRING_SIZE);
1613 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
1614
1615 CSR_WRITE_4(sc, IWL2100_TXQ_ADDR, tr->tr_paddr);
1616 CSR_WRITE_4(sc, IWL2100_TXQ_SIZE, IWL2100_TX_NDESC);
1617 CSR_WRITE_4(sc, IWL2100_TXQ_READ_IDX, 0);
1618 CSR_WRITE_4(sc, IWL2100_TXQ_WRITE_IDX, tr->tr_index);
1619
1620 return 0;
1621 }
1622
1623 static int
1624 iwl2100_init_rx_ring(struct iwl2100_softc *sc)
1625 {
1626 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1627 int i, error;
1628
1629 for (i = 0; i < IWL2100_RX_NDESC; ++i) {
1630 error = iwl2100_newbuf(sc, i, 1);
1631 if (error)
1632 return error;
1633 }
1634 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap, BUS_DMASYNC_PREWRITE);
1635 bus_dmamap_sync(rr->rr_dtag, rr->rr_dmap, BUS_DMASYNC_PREWRITE);
1636
1637 rr->rr_index = IWL2100_RX_NDESC - 1;
1638
1639 CSR_WRITE_4(sc, IWL2100_RXQ_ADDR, rr->rr_paddr);
1640 CSR_WRITE_4(sc, IWL2100_RXQ_SIZE, IWL2100_RX_NDESC);
1641 CSR_WRITE_4(sc, IWL2100_RXQ_READ_IDX, 0);
1642 CSR_WRITE_4(sc, IWL2100_RXQ_WRITE_IDX, rr->rr_index);
1643
1644 CSR_WRITE_4(sc, IWL2100_RX_STATUS_ADDR, rr->rr_st_paddr);
1645
1646 return 0;
1647 }
1648
1649 static int
1650 iwl2100_alloc_cmd(struct iwl2100_softc *sc)
1651 {
1652 KKASSERT(sc->sc_cmd == NULL);
1653
1654 sc->sc_cmd = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
1655 if (sc->sc_cmd == NULL)
1656 return ENOBUFS;
1657 return 0;
1658 }
1659
1660 static int
1661 iwl2100_newbuf(struct iwl2100_softc *sc, int buf_idx, int init)
1662 {
1663 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1664 struct iwl2100_rxbuf *rb;
1665 struct iwl_dmamap_ctx ctx;
1666 bus_dma_segment_t seg;
1667 bus_dmamap_t dmap;
1668 struct mbuf *m;
1669 int error;
1670
1671 KKASSERT(buf_idx < IWL2100_RX_NDESC);
1672 rb = &rr->rr_buf[buf_idx];
1673
1674 m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
1675 if (m == NULL) {
1676 error = ENOBUFS;
1677
1678 if (init) {
1679 if_printf(&sc->sc_ic.ic_if, "m_getcl failed\n");
1680 return error;
1681 } else {
1682 goto back;
1683 }
1684 }
1685 m->m_len = m->m_pkthdr.len = MCLBYTES;
1686
1687 /*
1688 * Try load RX mbuf into temporary DMA map
1689 */
1690 ctx.nsegs = 1;
1691 ctx.segs = &seg;
1692 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, rr->rr_tmp_dmap, m,
1693 iwl_dma_buf_addr, &ctx,
1694 init ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT);
1695 if (error || ctx.nsegs == 0) {
1696 if (!error) {
1697 bus_dmamap_unload(sc->sc_mbuf_dtag, rr->rr_tmp_dmap);
1698 error = EFBIG;
1699 if_printf(&sc->sc_ic.ic_if, "too many segments?!\n");
1700 }
1701 m_freem(m);
1702
1703 if (init) {
1704 if_printf(&sc->sc_ic.ic_if, "can't load RX mbuf\n");
1705 return error;
1706 } else {
1707 goto back;
1708 }
1709 }
1710
1711 if (!init)
1712 bus_dmamap_unload(sc->sc_mbuf_dtag, rb->rb_dmap);
1713 rb->rb_mbuf = m;
1714 rb->rb_paddr = seg.ds_addr;
1715
1716 /*
1717 * Swap RX buf's DMA map with the loaded temporary one
1718 */
1719 dmap = rb->rb_dmap;
1720 rb->rb_dmap = rr->rr_tmp_dmap;
1721 rr->rr_tmp_dmap = dmap;
1722
1723 error = 0;
1724 back:
1725 iwl2100_rxdesc_setup(sc, buf_idx);
1726 return error;
1727 }
1728
1729 static void
1730 iwl2100_rxdesc_setup(struct iwl2100_softc *sc, int buf_idx)
1731 {
1732 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1733 struct iwl2100_rxbuf *rb;
1734 struct iwl2100_desc *d;
1735 struct iwl2100_rx_status *st;
1736
1737 KKASSERT(buf_idx < IWL2100_RX_NDESC);
1738 rb = &rr->rr_buf[buf_idx];
1739
1740 st = &rr->rr_status[buf_idx];
1741 bzero(st, sizeof(*st));
1742
1743 d = &rr->rr_desc[buf_idx];
1744 bzero(d, sizeof(*d));
1745 d->d_paddr = rb->rb_paddr;
1746 d->d_len = MCLBYTES;
1747 }
1748
1749 static int
1750 iwl2100_init_firmware(struct iwl2100_softc *sc)
1751 {
1752 #ifdef INVARIANTS
1753 struct ifnet *ifp = &sc->sc_ic.ic_if;
1754 #endif
1755 uint32_t intr;
1756 int i;
1757
1758 ASSERT_SERIALIZED(ifp->if_serializer);
1759
1760 CSR_WRITE_4(sc, IWL2100_GPIO,
1761 IWL2100_GPIO_3_EN | IWL2100_GPIO_3_FWWR |
1762 IWL2100_GPIO_1_EN | IWL2100_GPIO_LEDOFF);
1763 CSR_WRITE_4(sc, IWL2100_RESET, 0);
1764
1765 /*
1766 * Wait for firmware to be initialized
1767 */
1768 #define WAIT_MAX 5000
1769
1770 for (i = 0; i < WAIT_MAX; ++i) {
1771 DELAY(8000);
1772
1773 intr = CSR_READ_4(sc, IWL2100_INTR_STATUS);
1774 if (intr & IWL2100_INTR_FW_INITED) {
1775 CSR_WRITE_4(sc, IWL2100_INTR_STATUS,
1776 IWL2100_INTR_FW_INITED);
1777 break;
1778 }
1779 if (intr & (IWL2100_INTR_EFATAL | IWL2100_INTR_EPARITY)) {
1780 CSR_WRITE_4(sc, IWL2100_INTR_STATUS,
1781 IWL2100_INTR_EFATAL | IWL2100_INTR_EPARITY);
1782 }
1783 }
1784
1785 intr = CSR_READ_4(sc, IWL2100_INTR_STATUS) & IWL2100_INTRS;
1786 if (intr & CSR_READ_4(sc, IWL2100_INTR_MASK))
1787 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, intr);
1788
1789 if (i == WAIT_MAX) {
1790 if_printf(&sc->sc_ic.ic_if,
1791 "firmware initialization timed out\n");
1792 return ETIMEDOUT;
1793 }
1794
1795 #undef WAIT_MAX
1796
1797 /* Enable GPIO1/3 and allow firmware to write to them */
1798 CSR_SETBITS_4(sc, IWL2100_GPIO,
1799 IWL2100_GPIO_1_EN | IWL2100_GPIO_1_FWWR |
1800 IWL2100_GPIO_3_EN | IWL2100_GPIO_3_FWWR);
1801 return 0;
1802 }
1803
1804 static int
1805 iwl2100_read_ord2(struct iwl2100_softc *sc, uint32_t ofs, void *buf0, int buflen)
1806 {
1807 uint8_t *buf = buf0;
1808 uint32_t addr, info;
1809 int i, len, ret;
1810
1811 #define IND_ALIGN 4
1812 #define IND_ALIGN_MASK 0x3
1813
1814 addr = IND_READ_4(sc, sc->sc_ord2 + (ofs << 3));
1815 info = IND_READ_4(sc, sc->sc_ord2 + (ofs << 3) + sizeof(addr));
1816
1817 len = info & 0xffff;
1818 i = info >> 16;
1819
1820 if ((len * i) < buflen)
1821 buflen = len * i;
1822 ret = buflen;
1823
1824 i = addr & IND_ALIGN_MASK;
1825 addr &= ~IND_ALIGN_MASK;
1826 if (i) {
1827 int lim, r;
1828
1829 KKASSERT(i < IND_ALIGN);
1830 if (buflen + i < IND_ALIGN)
1831 lim = buflen + i;
1832 else
1833 lim = IND_ALIGN;
1834 r = lim - i;
1835
1836 CSR_WRITE_4(sc, IWL2100_IND_ADDR, addr);
1837 for (; i < lim; ++i, ++buf)
1838 *buf = CSR_READ_1(sc, IWL2100_IND_DATA + i);
1839
1840 KKASSERT(buflen >= r);
1841 buflen -= r;
1842 if (buflen == 0)
1843 goto back;
1844
1845 addr += IND_ALIGN;
1846 }
1847
1848 len = buflen & ~IND_ALIGN_MASK;
1849 buflen &= IND_ALIGN_MASK;
1850
1851 if (len) {
1852 CSR_WRITE_4(sc, IWL2100_AUTOINC_ADDR, addr);
1853 for (i = 0; i < len; i += 4, addr += 4, buf += 4) {
1854 *((uint32_t *)buf) =
1855 CSR_READ_4(sc, IWL2100_AUTOINC_DATA);
1856 }
1857 }
1858 if (buflen) {
1859 CSR_WRITE_4(sc, IWL2100_IND_ADDR, addr);
1860 for (i = 0; i < buflen; ++i, ++buf)
1861 *buf = CSR_READ_1(sc, IWL2100_IND_DATA + i);
1862 }
1863 back:
1864 return ret;
1865
1866 #undef IND_ALIGN
1867 #undef IND_ALIGN_MASK
1868 }
1869
1870 static uint32_t
1871 iwl2100_read_ord1(struct iwl2100_softc *sc, uint32_t ofs)
1872 {
1873 uint32_t addr;
1874
1875 addr = IND_READ_4(sc, sc->sc_ord1 + (ofs << 2));
1876 return IND_READ_4(sc, addr);
1877 }
1878
1879 static void
1880 iwl2100_write_ord1(struct iwl2100_softc *sc, uint32_t ofs, uint32_t val)
1881 {
1882 uint32_t addr;
1883
1884 addr = IND_READ_4(sc, sc->sc_ord1 + (ofs << 2));
1885 IND_WRITE_4(sc, addr, val);
1886 }
1887
1888 static int
1889 iwl2100_rfkilled(struct iwl2100_softc *sc)
1890 {
1891 int i;
1892
1893 if ((sc->sc_caps & IWL2100_C_RFKILL) == 0)
1894 return 0;
1895
1896 #define TEST_MAX 5
1897
1898 for (i = 0; i < TEST_MAX; ++i) {
1899 DELAY(40);
1900
1901 if (CSR_READ_4(sc, IWL2100_GPIO) & IWL2100_GPIO_RFKILLED)
1902 break;
1903 }
1904 if (i != TEST_MAX) {
1905 if_printf(&sc->sc_ic.ic_if, "RF killed\n");
1906 return 1;
1907 }
1908
1909 #undef TEST_MAX
1910
1911 return 0;
1912 }
1913
1914 static int
1915 iwl2100_set_addr(struct iwl2100_softc *sc, const uint8_t *eaddr)
1916 {
1917 struct iwl2100_cmd *cmd;
1918 int error;
1919
1920 if (sc->sc_flags & IWL2100_F_WAITCMD) {
1921 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
1922 return EEXIST;
1923 }
1924
1925 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
1926 bzero(cmd, sizeof(*cmd));
1927
1928 cmd->c_cmd = IWL2100_CMD_SET_ADDR;
1929 cmd->c_param_len = IEEE80211_ADDR_LEN;
1930 IEEE80211_ADDR_COPY(cmd->c_param, eaddr);
1931
1932 error = iwl2100_wait_cmd(sc);
1933 if (error) {
1934 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
1935 return error;
1936 }
1937 return 0;
1938 }
1939
1940 static int
1941 iwl2100_set_opmode(struct iwl2100_softc *sc, enum ieee80211_opmode opmode)
1942 {
1943 struct iwl2100_cmd *cmd;
1944 int error;
1945
1946 if (sc->sc_flags & IWL2100_F_WAITCMD) {
1947 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
1948 return EEXIST;
1949 }
1950
1951 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
1952 bzero(cmd, sizeof(cmd));
1953
1954 cmd->c_cmd = IWL2100_CMD_SET_OPMODE;
1955 cmd->c_param_len = sizeof(cmd->c_param[0]);
1956 switch (opmode) {
1957 case IEEE80211_M_STA:
1958 cmd->c_param[0] = IWL2100_OPMODE_STA;
1959 break;
1960 case IEEE80211_M_IBSS:
1961 cmd->c_param[0] = IWL2100_OPMODE_IBSS;
1962 break;
1963 case IEEE80211_M_MONITOR:
1964 /* YYY ipw2100 leave this unset */
1965 cmd->c_param[0] = IWL2100_OPMODE_MONITOR;
1966 break;
1967 default:
1968 panic("unsupported opmode %d\n", opmode);
1969 break;
1970 }
1971
1972 error = iwl2100_wait_cmd(sc);
1973 if (error) {
1974 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
1975 return error;
1976 }
1977 return 0;
1978 }
1979
1980 static int
1981 iwl2100_set_80211(struct iwl2100_softc *sc)
1982 {
1983 struct ieee80211com *ic = &sc->sc_ic;
1984 struct iwl2100_cmd *cmd;
1985 int error;
1986
1987 if (sc->sc_flags & IWL2100_F_WAITCMD) {
1988 if_printf(&ic->ic_if, "there is command pending\n");
1989 return EEXIST;
1990 }
1991
1992 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
1993 bzero(cmd, sizeof(cmd));
1994
1995 cmd->c_cmd = IWL2100_CMD_SET_80211;
1996 cmd->c_param_len = sizeof(cmd->c_param[0]) * 3;
1997 cmd->c_param[0] = IWL2100_CFG_IBSS | IWL2100_CFG_STA |
1998 IWL2100_CFG_8021X | IWL2100_CFG_AUTO_PREAMBLE;
1999 if (ic->ic_opmode == IEEE80211_M_IBSS)
2000 cmd->c_param[0] |= IWL2100_CFG_IBSS_AUTO_START;
2001 else if (ic->ic_opmode == IEEE80211_M_MONITOR) /* YYY not ipw2100 */
2002 cmd->c_param[0] |= IWL2100_CFG_MONITOR;
2003 cmd->c_param[1] = IWL2100_CFG_CHANMASK; /* XXX sc->sc_bss_chans */
2004 cmd->c_param[2] = IWL2100_CFG_CHANMASK; /* YYY sc->sc_ibss_chans */
2005
2006 error = iwl2100_wait_cmd(sc);
2007 if (error) {
2008 if_printf(&ic->ic_if, "%s failed\n", __func__);
2009 return error;
2010 }
2011 return 0;
2012 }
2013
2014 static int
2015 iwl2100_set_basicrates(struct iwl2100_softc *sc)
2016 {
2017 struct iwl2100_cmd *cmd;
2018 int error;
2019
2020 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2021 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2022 return EEXIST;
2023 }
2024
2025 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2026 bzero(cmd, sizeof(cmd));
2027
2028 /*
2029 * This configuration does not seem to have any effects
2030 * on probe-req and assoc-req frames.
2031 */
2032 cmd->c_cmd = IWL2100_CMD_SET_BASICRATES;
2033 cmd->c_param_len = sizeof(cmd->c_param[0]);
2034 cmd->c_param[0] = 0x3; /* 1Mbps and 2Mbps. XXX from caller */
2035
2036 error = iwl2100_wait_cmd(sc);
2037 if (error) {
2038 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2039 return error;
2040 }
2041 return 0;
2042 }
2043
2044 static int
2045 iwl2100_set_txrates(struct iwl2100_softc *sc)
2046 {
2047 struct ieee80211com *ic = &sc->sc_ic;
2048 struct iwl2100_cmd *cmd;
2049 uint32_t rate_mask;
2050 int error;
2051
2052 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2053 if_printf(&ic->ic_if, "there is command pending\n");
2054 return EEXIST;
2055 }
2056
2057 /* Calculate TX rate mask. XXX let caller do this */
2058 if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE)
2059 rate_mask = 1 << ic->ic_fixed_rate;
2060 else
2061 rate_mask = 0xf; /* all 11b rates */
2062 KKASSERT((rate_mask & ~0xf) == 0);
2063
2064 /*
2065 * Set TX rates
2066 */
2067 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2068 bzero(cmd, sizeof(cmd));
2069
2070 cmd->c_cmd = IWL2100_CMD_SET_TXRATES;
2071 cmd->c_param_len = sizeof(cmd->c_param[0]);
2072 cmd->c_param[0] = rate_mask;
2073
2074 error = iwl2100_wait_cmd(sc);
2075 if (error) {
2076 if_printf(&ic->ic_if, "%s failed\n", __func__);
2077 return error;
2078 }
2079
2080 /*
2081 * Set MSDU TX rates
2082 */
2083 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2084 bzero(cmd, sizeof(cmd));
2085
2086 cmd->c_cmd = IWL2100_CMD_SET_MSDU_TXRATES;
2087 cmd->c_param_len = sizeof(cmd->c_param[0]);
2088 cmd->c_param[0] = rate_mask;
2089
2090 error = iwl2100_wait_cmd(sc);
2091 if (error) {
2092 if_printf(&ic->ic_if, "%s failed\n", __func__);
2093 return error;
2094 }
2095 return 0;
2096 }
2097
2098 static int
2099 iwl2100_set_powersave(struct iwl2100_softc *sc, int on)
2100 {
2101 struct iwl2100_cmd *cmd;
2102 int error;
2103
2104 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2105 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2106 return EEXIST;
2107 }
2108
2109 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2110 bzero(cmd, sizeof(cmd));
2111
2112 cmd->c_cmd = IWL2100_CMD_SET_POWERSAVE;
2113 cmd->c_param_len = sizeof(cmd->c_param[0]);
2114 cmd->c_param[0] = on; /* XXX power level? */
2115
2116 error = iwl2100_wait_cmd(sc);
2117 if (error) {
2118 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2119 return error;
2120 }
2121 return 0;
2122 }
2123
2124 static int
2125 iwl2100_set_rtsthreshold(struct iwl2100_softc *sc, uint16_t rtsthreshold)
2126 {
2127 struct iwl2100_cmd *cmd;
2128 int error;
2129
2130 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2131 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2132 return EEXIST;
2133 }
2134
2135 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2136 bzero(cmd, sizeof(cmd));
2137
2138 cmd->c_cmd = IWL2100_CMD_SET_RTSTHRESHOLD;
2139 cmd->c_param_len = sizeof(cmd->c_param[0]);
2140 if (rtsthreshold == IEEE80211_RTS_MAX) {
2141 /* Disable RTS threshold */
2142 cmd->c_param[0] = IWL2100_RTS_MAX;
2143 } else {
2144 if (rtsthreshold >= IWL2100_RTS_MAX)
2145 rtsthreshold = IWL2100_RTS_MAX - 1;
2146 cmd->c_param[0] = rtsthreshold;
2147 }
2148
2149 error = iwl2100_wait_cmd(sc);
2150 if (error) {
2151 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2152 return error;
2153 }
2154 return 0;
2155 }
2156
2157 static int
2158 iwl2100_set_bssid(struct iwl2100_softc *sc, const uint8_t *bssid)
2159 {
2160 struct iwl2100_cmd *cmd;
2161 int error;
2162
2163 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2164 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2165 return EEXIST;
2166 }
2167
2168 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2169 bzero(cmd, sizeof(cmd));
2170
2171 cmd->c_cmd = IWL2100_CMD_SET_BSSID;
2172 if (bssid != NULL) {
2173 cmd->c_param_len = IEEE80211_ADDR_LEN;
2174 IEEE80211_ADDR_COPY(cmd->c_param, bssid);
2175 }
2176
2177 error = iwl2100_wait_cmd(sc);
2178 if (error) {
2179 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2180 return error;
2181 }
2182 return 0;
2183 }
2184
2185 static int
2186 iwl2100_set_essid(struct iwl2100_softc *sc, const uint8_t *essid, int essid_len)
2187 {
2188 struct iwl2100_cmd *cmd;
2189 int error;
2190
2191 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2192 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2193 return EEXIST;
2194 }
2195
2196 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2197 bzero(cmd, sizeof(cmd));
2198
2199 cmd->c_cmd = IWL2100_CMD_SET_ESSID;
2200 if (essid != NULL) {
2201 KKASSERT(essid_len <= sizeof(cmd->c_param));
2202 cmd->c_param_len = essid_len;
2203 if (essid_len != 0)
2204 bcopy(essid, cmd->c_param, essid_len);
2205 }
2206
2207 error = iwl2100_wait_cmd(sc);
2208 if (error) {
2209 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2210 return error;
2211 }
2212 return 0;
2213 }
2214
2215 static int
2216 iwl2100_set_auth_ciphers(struct iwl2100_softc *sc,
2217 enum ieee80211_authmode authmode)
2218 {
2219 struct iwl2100_cmdparam_sec *sec;
2220 struct iwl2100_cmd *cmd;
2221 int error;
2222
2223 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2224 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2225 return EEXIST;
2226 }
2227
2228 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2229 bzero(cmd, sizeof(cmd));
2230
2231 cmd->c_cmd = IWL2100_CMD_SET_SECURITY;
2232 cmd->c_param_len = sizeof(*sec);
2233 sec = (struct iwl2100_cmdparam_sec *)cmd->c_param;
2234
2235 sec->sec_cipher_mask = IWL2100_CIPHER_NONE |
2236 IWL2100_CIPHER_WEP40 |
2237 IWL2100_CIPHER_TKIP |
2238 IWL2100_CIPHER_CCMP |
2239 IWL2100_CIPHER_WEP104;
2240 if (authmode == IEEE80211_AUTH_SHARED)
2241 sec->sec_authmode = IWL2100_AUTH_SHARED;
2242 else
2243 sec->sec_authmode = IWL2100_AUTH_OPEN;
2244
2245 error = iwl2100_wait_cmd(sc);
2246 if (error) {
2247 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2248 return error;
2249 }
2250 return 0;
2251 }
2252
2253 static int
2254 iwl2100_set_wepkey(struct iwl2100_softc *sc, const struct ieee80211_key *k)
2255 {
2256 struct iwl2100_cmdparam_wepkey *key;
2257 struct iwl2100_cmd *cmd;
2258 int error;
2259
2260 if (k->wk_keylen > IWL2100_KEYDATA_SIZE)
2261 return E2BIG;
2262
2263 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2264 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2265 return EEXIST;
2266 }
2267
2268 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2269 bzero(cmd, sizeof(cmd));
2270
2271 cmd->c_cmd = IWL2100_CMD_SET_WEPKEY;
2272 cmd->c_param_len = sizeof(*key);
2273 key = (struct iwl2100_cmdparam_wepkey *)cmd->c_param;
2274 key->key_index = k->wk_keyix;
2275 key->key_len = k->wk_keylen;
2276 bcopy(k->wk_key, key->key_data, key->key_len);
2277
2278 error = iwl2100_wait_cmd(sc);
2279 if (error) {
2280 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2281 return error;
2282 }
2283 return 0;
2284 }
2285
2286 static int
2287 iwl2100_set_weptxkey(struct iwl2100_softc *sc, ieee80211_keyix txkey)
2288 {
2289 struct iwl2100_cmd *cmd;
2290 int error;
2291
2292 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2293 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2294 return EEXIST;
2295 }
2296
2297 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2298 bzero(cmd, sizeof(cmd));
2299
2300 cmd->c_cmd = IWL2100_CMD_SET_WEPTXKEY;
2301 cmd->c_param_len = sizeof(cmd->c_param[0]);
2302 cmd->c_param[0] = txkey;
2303
2304 error = iwl2100_wait_cmd(sc);
2305 if (error) {
2306 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2307 return error;
2308 }
2309 return 0;
2310 }
2311
2312 static int
2313 iwl2100_set_privacy(struct iwl2100_softc *sc, int on)
2314 {
2315 struct iwl2100_cmd *cmd;
2316 int error;
2317
2318 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2319 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2320 return EEXIST;
2321 }
2322
2323 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2324 bzero(cmd, sizeof(cmd));
2325
2326 cmd->c_cmd = IWL2100_CMD_SET_PRIVACY;
2327 cmd->c_param_len = sizeof(cmd->c_param[0]);
2328 cmd->c_param[0] = on ? IWL2100_PRIVACY_ENABLE : 0;
2329
2330 error = iwl2100_wait_cmd(sc);
2331 if (error) {
2332 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2333 return error;
2334 }
2335 return 0;
2336 }
2337
2338 static int
2339 iwl2100_wait_cmd(struct iwl2100_softc *sc)
2340 {
2341 struct ifnet *ifp = &sc->sc_ic.ic_if;
2342 struct iwl2100_tx_ring *tr = &sc->sc_txring;
2343 struct mbuf *m = sc->sc_cmd;
2344 struct iwl_dmamap_ctx ctx;
2345 bus_dma_segment_t seg;
2346 struct iwl2100_desc *d;
2347 struct iwl2100_txbuf *tb;
2348 int error;
2349
2350 ASSERT_SERIALIZED(ifp->if_serializer);
2351
2352 KKASSERT(tr->tr_index < IWL2100_TX_NDESC);
2353 tb = &tr->tr_buf[tr->tr_index];
2354
2355 ctx.nsegs = 1;
2356 ctx.segs = &seg;
2357 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, tb->tb_dmap, m,
2358 iwl_dma_buf_addr, &ctx, BUS_DMA_WAITOK);
2359 if (error || ctx.nsegs == 0) {
2360 if (!error) {
2361 bus_dmamap_unload(sc->sc_mbuf_dtag, tb->tb_dmap);
2362 error = EFBIG;
2363 if_printf(ifp, "too many segments?!\n");
2364 }
2365
2366 if_printf(ifp, "can't load RX mbuf\n");
2367 return error;
2368 }
2369 tb->tb_mbuf = sc->sc_cmd;
2370 tb->tb_flags |= IWL2100_TBF_CMDBUF;
2371
2372 d = &tr->tr_desc[tr->tr_index];
2373 d->d_paddr = seg.ds_addr;
2374 d->d_len = sizeof(struct iwl2100_cmd);
2375 d->d_nfrag = 1;
2376 d->d_flags = IWL2100_TXD_F_INTR | IWL2100_TXD_F_CMD;
2377
2378 KKASSERT(tr->tr_used < IWL2100_TX_NDESC);
2379 ++tr->tr_used;
2380 tr->tr_index = (tr->tr_index + 1) % IWL2100_TX_NDESC;
2381
2382 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
2383
2384 CSR_WRITE_4(sc, IWL2100_TXQ_WRITE_IDX, tr->tr_index);
2385
2386 if (sc->sc_flags & IWL2100_F_IN_INTR)
2387 panic("sleep in interrupt thread\n");
2388
2389 sc->sc_flags |= IWL2100_F_WAITCMD;
2390 error = serialize_sleep(sc, ifp->if_serializer, 0, "iwlcmd", 2 * hz);
2391 if (!error) {
2392 sc->sc_flags &= ~IWL2100_F_WAITCMD;
2393 if (sc->sc_flags & IWL2100_F_ERROR) {
2394 if_printf(ifp, "error happened when waiting "
2395 "command to be done\n");
2396 error = EIO;
2397 }
2398 }
2399 return error;
2400 }
2401
2402 static void
2403 iwl2100_rxeof(struct iwl2100_softc *sc)
2404 {
2405 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
2406 struct ifnet *ifp = &sc->sc_ic.ic_if;
2407 int hwidx, i;
2408
2409 hwidx = CSR_READ_4(sc, IWL2100_RXQ_READ_IDX);
2410 CSR_READ_4(sc, IWL2100_RXQ_WRITE_IDX);
2411
2412 if (hwidx >= IWL2100_RX_NDESC) {
2413 if_printf(ifp, "invalid hardware RX index %d\n", hwidx);
2414 return;
2415 }
2416
2417 KKASSERT(rr->rr_index < IWL2100_RX_NDESC);
2418 i = (rr->rr_index + 1) % IWL2100_RX_NDESC;
2419 while (hwidx != i) {
2420 struct iwl2100_rx_status *st = &rr->rr_status[i];
2421 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
2422 int frame_type;
2423
2424 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap,
2425 BUS_DMASYNC_POSTREAD);
2426 frame_type = st->r_status & IWL2100_RXS_TYPE_MASK;
2427
2428 bus_dmamap_sync(sc->sc_mbuf_dtag, rb->rb_dmap,
2429 BUS_DMASYNC_POSTREAD);
2430 switch (frame_type) {
2431 case IWL2100_RXS_TYPE_CMD:
2432 iwl2100_rxeof_cmd(sc, i);
2433 break;
2434
2435 case IWL2100_RXS_TYPE_STATUS:
2436 iwl2100_rxeof_status(sc, i);
2437 break;
2438
2439 case IWL2100_RXS_TYPE_NOTE:
2440 iwl2100_rxeof_note(sc, i);
2441 break;
2442
2443 case IWL2100_RXS_TYPE_DATA:
2444 case IWL2100_RXS_TYPE_DATA1:
2445 iwl2100_rxeof_data(sc, i);
2446 break;
2447
2448 default:
2449 if_printf(ifp, "unknown frame type: %d\n", frame_type);
2450 iwl2100_rxdesc_setup(sc, i);
2451 break;
2452 }
2453 i = (i + 1) % IWL2100_RX_NDESC;
2454 }
2455 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap, BUS_DMASYNC_POSTREAD);
2456 bus_dmamap_sync(rr->rr_dtag, rr->rr_dmap, BUS_DMASYNC_POSTREAD);
2457
2458 if (i == 0)
2459 rr->rr_index = IWL2100_RX_NDESC - 1;
2460 else
2461 rr->rr_index = i - 1;
2462 CSR_WRITE_4(sc, IWL2100_RXQ_WRITE_IDX, rr->rr_index);
2463 }
2464
2465 static void
2466 iwl2100_txeof(struct iwl2100_softc *sc)
2467 {
2468 struct iwl2100_tx_ring *tr = &sc->sc_txring;
2469 struct ifnet *ifp = &sc->sc_ic.ic_if;
2470 int hwidx;
2471
2472 hwidx = CSR_READ_4(sc, IWL2100_TXQ_READ_IDX);
2473 CSR_READ_4(sc, IWL2100_TXQ_WRITE_IDX);
2474 if (hwidx >= IWL2100_TX_NDESC) {
2475 if_printf(ifp, "invalid hardware TX index %d\n", hwidx);
2476 return;
2477 }
2478
2479 KKASSERT(tr->tr_coll < IWL2100_TX_NDESC);
2480 while (tr->tr_used) {
2481 struct iwl2100_txbuf *tb;
2482
2483 if (tr->tr_coll == hwidx)
2484 break;
2485
2486 tb = &tr->tr_buf[tr->tr_coll];
2487 if (tb->tb_mbuf == NULL)
2488 goto next;
2489
2490 bus_dmamap_unload(sc->sc_mbuf_dtag, tb->tb_dmap);
2491 if (tb->tb_flags & IWL2100_TBF_CMDBUF) {
2492 tb->tb_flags &= ~IWL2100_TBF_CMDBUF;
2493 KKASSERT(tb->tb_mbuf == sc->sc_cmd);
2494 } else {
2495 m_freem(tb->tb_mbuf);
2496 }
2497 tb->tb_mbuf = NULL;
2498 next:
2499 tr->tr_coll = (tr->tr_coll + 1) % IWL2100_TX_NDESC;
2500
2501 KKASSERT(tr->tr_used > 0);
2502 --tr->tr_used;
2503 }
2504
2505 if (tr->tr_used < IWL2100_TX_USED_MAX) {
2506 if (tr->tr_used == 0) {
2507 KKASSERT(tr->tr_coll == tr->tr_index);
2508 sc->sc_tx_timer = 0;
2509 }
2510
2511 ifp->if_flags &= ~IFF_OACTIVE;
2512 if_devstart(ifp);
2513 }
2514 }
2515
2516 static int
2517 iwl2100_config(struct iwl2100_softc *sc, const uint8_t *bssid,
2518 const uint8_t *essid, uint8_t esslen, int ibss_chan)
2519 {
2520 struct ieee80211com *ic = &sc->sc_ic;
2521 struct ifnet *ifp = &ic->ic_if;
2522 int error;
2523
2524 if (ic->ic_opmode == IEEE80211_M_MONITOR) {
2525 error = iwl2100_set_chan(sc, ic->ic_curchan);
2526 if (error) {
2527 if_printf(ifp, "can't set mon channel\n");
2528 return error;
2529 }
2530 }
2531
2532 IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
2533 error = iwl2100_set_addr(sc, ic->ic_myaddr);
2534 if (error) {
2535 if_printf(ifp, "can't set MAC address\n");
2536 return error;
2537 }
2538
2539 error = iwl2100_set_opmode(sc, ic->ic_opmode);
2540 if (error) {
2541 if_printf(ifp, "can't set opmode\n");
2542 return error;
2543 }
2544
2545 if (ibss_chan) {
2546 KKASSERT(ic->ic_opmode == IEEE80211_M_IBSS);
2547 error = iwl2100_set_chan(sc, ic->ic_curchan);
2548 if (error) {
2549 if_printf(ifp, "can't set ibss channel\n");
2550 return error;
2551 }
2552 }
2553
2554 error = iwl2100_set_80211(sc);
2555 if (error) {
2556 if_printf(ifp, "can't set 802.11 config\n");
2557 return error;
2558 }
2559
2560 error = iwl2100_set_basicrates(sc);
2561 if (error) {
2562 if_printf(ifp, "can't set basicrates\n");
2563 return error;
2564 }
2565
2566 error = iwl2100_set_txrates(sc);
2567 if (error) {
2568 if_printf(ifp, "can't set TX rates\n");
2569 return error;
2570 }
2571
2572 error = iwl2100_set_powersave(sc, ic->ic_flags & IEEE80211_F_PMGTON);
2573 if (error) {
2574 if_printf(ifp, "can't turn off powersave\n");
2575 return error;
2576 }
2577
2578 error = iwl2100_set_rtsthreshold(sc, ic->ic_rtsthreshold);
2579 if (error) {
2580 if_printf(ifp, "can't set RTS threshold\n");
2581 return error;
2582 }
2583
2584 error = iwl2100_set_bssid(sc, bssid);
2585 if (error) {
2586 if_printf(ifp, "can't set bssid\n");
2587 return error;
2588 }
2589
2590 error = iwl2100_set_essid(sc, essid, esslen);
2591 if (error) {
2592 if_printf(ifp, "can't set essid\n");
2593 return error;
2594 }
2595
2596 error = iwl2100_set_auth_ciphers(sc, ic->ic_bss->ni_authmode);
2597 if (error) {
2598 if_printf(ifp, "can't set authmode and ciphers\n");
2599 return error;
2600 }
2601
2602 if (ic->ic_flags & IEEE80211_F_PRIVACY) {
2603 ieee80211_keyix txkey = IEEE80211_KEYIX_NONE;
2604 int i;
2605
2606 for (i = 0; i < IEEE80211_WEP_NKID; ++i) {
2607 const struct ieee80211_key *k = &ic->ic_nw_keys[i];
2608
2609 if (k->wk_keyix == IEEE80211_KEYIX_NONE)
2610 continue;
2611
2612 error = iwl2100_set_wepkey(sc, k);
2613 if (error == E2BIG) {
2614 continue;
2615 } else if (error) {
2616 if_printf(ifp, "can't set wepkey\n");
2617 return error;
2618 }
2619 txkey = k->wk_keyix;
2620 }
2621
2622 if (txkey != IEEE80211_KEYIX_NONE) {
2623 /*
2624 * Found some valid WEP keys.
2625 *
2626 * If WEP TX key index from 802.11 layer is not
2627 * set, then use the first valid WEP key as TX
2628 * key.
2629 */
2630 if (ic->ic_def_txkey != IEEE80211_KEYIX_NONE)
2631 txkey = ic->ic_def_txkey;
2632
2633 error = iwl2100_set_weptxkey(sc, txkey);
2634 if (error) {
2635 if_printf(ifp, "can't set weptxkey\n");
2636 return error;
2637 }
2638 }
2639 }
2640
2641 error = iwl2100_set_privacy(sc, ic->ic_flags & IEEE80211_F_PRIVACY);
2642 if (error) {
2643 if_printf(ifp, "can't set privacy\n");
2644 return error;
2645 }
2646
2647 error = iwl2100_set_optie(sc, ic->ic_opt_ie, ic->ic_opt_ie_len);
2648 if (error) {
2649 if (error != E2BIG) {
2650 if_printf(ifp, "can't set opt ie\n");
2651 return error;
2652 }
2653 }
2654
2655 if (ic->ic_opmode == IEEE80211_M_IBSS) {
2656 error = iwl2100_set_bintval(sc, ic->ic_bss->ni_intval);
2657 if (error) {
2658 if_printf(ifp, "can't set bintval\n");
2659 return error;
2660 }
2661
2662 error = iwl2100_set_txpower(sc, 32 /* XXX */);
2663 if (error) {
2664 if_printf(ifp, "can't set txpwr\n");
2665 return error;
2666 }
2667 }
2668 return 0;
2669 }
2670
2671 static int
2672 iwl2100_config_op(struct iwl2100_softc *sc, uint32_t op)
2673 {
2674 struct iwl2100_cmd *cmd;
2675 int error;
2676
2677 KASSERT(op == IWL2100_CMD_CONF_DONE || op == IWL2100_CMD_CONF_START,
2678 ("unknown config_op %u", op));
2679
2680 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2681 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2682 return EEXIST;
2683 }
2684
2685 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2686 bzero(cmd, sizeof(cmd));
2687 cmd->c_cmd = op;
2688
2689 error = iwl2100_wait_cmd(sc);
2690 if (error) {
2691 if_printf(&sc->sc_ic.ic_if, "%s(%u) failed\n", __func__, op);
2692 return error;
2693 }
2694
2695 iwl2100_read_ord1(sc, IWL2100_ORD1_CONF_START); /* dummy read */
2696 return 0;
2697 }
2698
2699 static int
2700 iwl2100_set_chan(struct iwl2100_softc *sc, const struct ieee80211_channel *c)
2701 {
2702 struct ieee80211com *ic = &sc->sc_ic;
2703 struct iwl2100_cmd *cmd;
2704 u_int chan;
2705 int error;
2706
2707 KKASSERT(ic->ic_opmode != IEEE80211_M_STA);
2708
2709 chan = ieee80211_chan2ieee(ic, c);
2710 if (chan == IEEE80211_CHAN_ANY) {
2711 if_printf(&ic->ic_if, "invalid channel!\n");
2712 return EINVAL;
2713 }
2714
2715 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2716 if_printf(&ic->ic_if, "there is command pending\n");
2717 return EEXIST;
2718 }
2719
2720 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2721 bzero(cmd, sizeof(cmd));
2722
2723 cmd->c_cmd = IWL2100_CMD_SET_CHAN;
2724 cmd->c_param_len = sizeof(cmd->c_param[0]);
2725 cmd->c_param[0] = chan;
2726
2727 error = iwl2100_wait_cmd(sc);
2728 if (error) {
2729 if_printf(&ic->ic_if, "%s failed\n", __func__);
2730 return error;
2731 }
2732 return 0;
2733 }
2734
2735 static int
2736 iwl2100_set_scanopt(struct iwl2100_softc *sc, uint32_t chans, uint32_t flags)
2737 {
2738 struct ieee80211com *ic = &sc->sc_ic;
2739 struct iwl2100_cmd *cmd;
2740 int error;
2741
2742 KKASSERT(ic->ic_opmode != IEEE80211_M_MONITOR);
2743
2744 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2745 if_printf(&ic->ic_if, "there is command pending\n");
2746 return EEXIST;
2747 }
2748
2749 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2750 bzero(cmd, sizeof(cmd));
2751
2752 /*
2753 * NOTE:
2754 * 1) IWL2100_SCANOPT_NOASSOC is ignored by firmware, but same
2755 * function could be achieved by clearing bssid.
2756 * 2) Channel mask is ignored by firmware, if NIC is in STA opmode.
2757 *
2758 * We leave the correct configuration here just with the hope
2759 * that one day firmware could do better.
2760 */
2761 cmd->c_cmd = IWL2100_CMD_SET_SCANOPT;
2762 cmd->c_param_len = sizeof(cmd->c_param[0]) * 2;
2763 cmd->c_param[0] = flags | IWL2100_SCANOPT_MIXED;
2764 cmd->c_param[1] = chans;
2765
2766 error = iwl2100_wait_cmd(sc);
2767 if (error) {
2768 if_printf(&ic->ic_if, "%s failed\n", __func__);
2769 return error;
2770 }
2771 return 0;
2772 }
2773
2774 static int
2775 iwl2100_set_scan(struct iwl2100_softc *sc)
2776 {
2777 struct ieee80211com *ic = &sc->sc_ic;
2778 struct iwl2100_cmd *cmd;
2779 int error;
2780
2781 KKASSERT(ic->ic_opmode != IEEE80211_M_MONITOR);
2782
2783 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2784 if_printf(&ic->ic_if, "there is command pending\n");
2785 return EEXIST;
2786 }
2787
2788 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2789 bzero(cmd, sizeof(cmd));
2790
2791 cmd->c_cmd = IWL2100_CMD_SCAN;
2792 cmd->c_param_len = sizeof(cmd->c_param[0]);
2793
2794 error = iwl2100_wait_cmd(sc);
2795 if (error) {
2796 if_printf(&ic->ic_if, "%s failed\n", __func__);
2797 return error;
2798 }
2799 return 0;
2800 }
2801
2802 static int
2803 iwl2100_set_optie(struct iwl2100_softc *sc, void *optie, uint16_t optie_len)
2804 {
2805 struct iwl2100_cmd *cmd;
2806 struct iwl2100_cmdparam_ie *ie;
2807 int error;
2808
2809 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2810 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2811 return EEXIST;
2812 }
2813
2814 if (optie_len > IWL2100_OPTIE_MAX) {
2815 if_printf(&sc->sc_ic.ic_if, "optie too long\n");
2816 return E2BIG;
2817 }
2818
2819 if (optie == NULL || optie_len == 0)
2820 return 0;
2821
2822 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2823 bzero(cmd, sizeof(cmd));
2824
2825 cmd->c_cmd = IWL2100_CMD_SET_IE;
2826 cmd->c_param_len = sizeof(*ie);
2827 ie = (struct iwl2100_cmdparam_ie *)cmd->c_param;
2828 ie->ie_optlen = optie_len;
2829 bcopy(optie, ie->ie_opt, optie_len);
2830
2831 error = iwl2100_wait_cmd(sc);
2832 if (error) {
2833 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2834 return error;
2835 }
2836 return 0;
2837 }
2838
2839 static int
2840 iwl2100_set_bintval(struct iwl2100_softc *sc, uint16_t bintval)
2841 {
2842 struct iwl2100_cmd *cmd;
2843 int error;
2844
2845 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2846 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2847 return EEXIST;
2848 }
2849
2850 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2851 bzero(cmd, sizeof(cmd));
2852
2853 cmd->c_cmd = IWL2100_CMD_SET_BINTVAL;
2854 cmd->c_param_len = sizeof(cmd->c_param[0]);
2855 cmd->c_param[0] = bintval;
2856
2857 error = iwl2100_wait_cmd(sc);
2858 if (error) {
2859 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2860 return error;
2861 }
2862 return 0;
2863 }
2864
2865 static int
2866 iwl2100_set_txpower(struct iwl2100_softc *sc, uint16_t txpower)
2867 {
2868 struct iwl2100_cmd *cmd;
2869 int error;
2870
2871 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2872 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2873 return EEXIST;
2874 }
2875
2876 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2877 bzero(cmd, sizeof(cmd));
2878
2879 cmd->c_cmd = IWL2100_CMD_SET_TXPOWER;
2880 cmd->c_param_len = sizeof(cmd->c_param[0]);
2881 cmd->c_param[0] = txpower;
2882
2883 error = iwl2100_wait_cmd(sc);
2884 if (error) {
2885 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2886 return error;
2887 }
2888 return 0;
2889 }
2890
2891 static void
2892 iwl2100_rxeof_status(struct iwl2100_softc *sc, int i)
2893 {
2894 struct ieee80211com *ic = &sc->sc_ic;
2895 struct ifnet *ifp = &ic->ic_if;
2896 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
2897 struct iwl2100_rx_status *st = &rr->rr_status[i];
2898 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
2899 struct mbuf *m = rb->rb_mbuf;
2900 uint32_t status;
2901
2902 if (st->r_len != sizeof(status)) {
2903 if_printf(ifp, "invalid status frame len %u\n", st->r_len);
2904 goto back;
2905 }
2906
2907 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2908 goto back;
2909
2910 if ((ic->ic_flags & IEEE80211_F_SCAN) == 0)
2911 sc->sc_flags &= ~IWL2100_F_SCANNING;
2912
2913 status = *mtod(m, uint32_t *);
2914 DPRINTF(sc, IWL2100_DBG_STATUS, "status 0x%08x\n", status);
2915
2916 switch (status) {
2917 case IWL2100_STATUS_SCANDONE:
2918 if (ic->ic_flags & IEEE80211_F_SCAN) {
2919 /*
2920 * To make sure that firmware has iterated all
2921 * of the channels, we wait for the second scan
2922 * done status change.
2923 */
2924 if (sc->sc_flags & IWL2100_F_SCANNING) {
2925 iwlmsg_send(&sc->sc_scanend_msg,
2926 &sc->sc_thread_port);
2927 } else {
2928 sc->sc_flags |= IWL2100_F_SCANNING;
2929 }
2930 }
2931 break;
2932
2933 case IWL2100_STATUS_RUNNING:
2934 iwl2100_restart_done(sc);
2935 if (ic->ic_state == IEEE80211_S_ASSOC) {
2936 KKASSERT(ic->ic_opmode == IEEE80211_M_STA);
2937 iwlmsg_send(&sc->sc_run_msg, &sc->sc_thread_port);
2938 } else if (ic->ic_state == IEEE80211_S_RUN) {
2939 if (ic->ic_opmode == IEEE80211_M_STA) {
2940 DPRINTF(sc, IWL2100_DBG_RESTART, "%s",
2941 "restart done\n");
2942 sc->sc_flags |= IWL2100_F_IFSTART;
2943 if_devstart(ifp);
2944 } else {
2945 KKASSERT(ic->ic_opmode == IEEE80211_M_IBSS);
2946 callout_reset(&sc->sc_ibss, (100 * hz) / 1000,
2947 iwl2100_ibss_bssid, sc);
2948 }
2949 }
2950 break;
2951
2952 case IWL2100_STATUS_BMISS:
2953 if (ic->ic_opmode == IEEE80211_M_STA) {
2954 DPRINTF(sc, IWL2100_DBG_SCAN, "%s", "bmiss\n");
2955 iwlmsg_send(&sc->sc_bmiss_msg, &sc->sc_thread_port);
2956 }
2957 break;
2958
2959 case IWL2100_STATUS_SCANNING:
2960 if (ic->ic_opmode == IEEE80211_M_STA &&
2961 ic->ic_state == IEEE80211_S_RUN) {
2962 /* Firmware error happens */
2963 iwl2100_restart(sc);
2964 }
2965 break;
2966 }
2967 back:
2968 iwl2100_rxdesc_setup(sc, i);
2969 }
2970
2971 static void
2972 iwl2100_rxeof_note(struct iwl2100_softc *sc, int i)
2973 {
2974 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
2975 struct iwl2100_rx_status *st = &rr->rr_status[i];
2976 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
2977 struct mbuf *m = rb->rb_mbuf;
2978 struct ieee80211com *ic = &sc->sc_ic;
2979 struct iwl2100_note *note;
2980
2981 if (st->r_len < sizeof(*note)) {
2982 if_printf(&ic->ic_if, "invalid note frame len %u\n", st->r_len);
2983 goto back;
2984 }
2985
2986 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2987 goto back;
2988
2989 note = mtod(m, struct iwl2100_note *);
2990 DPRINTF(sc, IWL2100_DBG_NOTE, "note subtype %u, size %u\n",
2991 note->nt_subtype, note->nt_size);
2992
2993 if (note->nt_subtype == 19 /* XXX */ &&
2994 ic->ic_state == IEEE80211_S_AUTH) {
2995 KKASSERT(ic->ic_opmode == IEEE80211_M_STA);
2996 iwlmsg_send(&sc->sc_assoc_msg, &sc->sc_thread_port);
2997 }
2998 back:
2999 iwl2100_rxdesc_setup(sc, i);
3000 }
3001
3002 static void
3003 iwl2100_rxeof_cmd(struct iwl2100_softc *sc, int i)
3004 {
3005 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
3006 struct iwl2100_rx_status *st = &rr->rr_status[i];
3007 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
3008 struct mbuf *m = rb->rb_mbuf;
3009 struct iwl2100_cmd *cmd;
3010
3011 if (st->r_len != sizeof(*cmd)) {
3012 if_printf(&sc->sc_ic.ic_if,
3013 "invalid cmd done frame len %u\n", st->r_len);
3014 goto back;
3015 }
3016
3017 cmd = mtod(m, struct iwl2100_cmd *);
3018 DPRINTF(sc, IWL2100_DBG_CMD, "cmd %u\n", cmd->c_cmd);
3019 if (cmd->c_cmd == 0)
3020 sc->sc_flags |= IWL2100_F_ZERO_CMD;
3021 wakeup(sc);
3022 back:
3023 iwl2100_rxdesc_setup(sc, i);
3024 }
3025
3026 static void
3027 iwl2100_rxeof_data(struct iwl2100_softc *sc, int i)
3028 {
3029 struct ieee80211com *ic = &sc->sc_ic;
3030 struct ifnet *ifp = &ic->ic_if;
3031 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
3032 struct iwl2100_rx_status *st = &rr->rr_status[i];
3033 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
3034 struct mbuf *m = rb->rb_mbuf;
3035 struct ieee80211_frame_min *wh;
3036 struct ieee80211_node *ni;
3037 int frame_len, rssi;
3038 const struct ieee80211_channel *c;
3039
3040 /*
3041 * Gather all necessary information from status ring _here_,
3042 * since the following iwl2100_newbuf() will clear them out.
3043 */
3044 rssi = st->r_rssi;
3045 frame_len = st->r_len;
3046
3047 if (iwl2100_newbuf(sc, i, 0)) {
3048 ifp->if_ierrors++;
3049 return;
3050 }
3051
3052 c = ic->ic_curchan;
3053
3054 m->m_pkthdr.rcvif = ifp;
3055 m->m_len = m->m_pkthdr.len = frame_len;
3056
3057 wh = mtod(m, struct ieee80211_frame_min *);
3058 ni = ieee80211_find_rxnode(ic, wh);
3059
3060 /*
3061 * RX radio tap
3062 */
3063 if (sc->sc_drvbpf != NULL) {
3064 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3065 sc->sc_rx_th.wr_flags = IEEE80211_RADIOTAP_F_WEP;
3066 else
3067 sc->sc_rx_th.wr_flags = 0;
3068
3069 sc->sc_rx_th.wr_antsignal = rssi + IWL2100_NOISE_FLOOR;
3070 sc->sc_rx_th.wr_antnoise = IWL2100_NOISE_FLOOR;
3071
3072 bpf_ptap(sc->sc_drvbpf, m, &sc->sc_rx_th, sc->sc_rx_th_len);
3073 }
3074
3075 ieee80211_input(ic, m, ni, rssi, 0);
3076 ieee80211_free_node(ni);
3077
3078 if (c != ic->ic_curchan) /* Happen during scanning */
3079 iwl2100_chan_change(sc, ic->ic_curchan);
3080 }
3081
3082 static void
3083 iwl2100_scanend_dispatch(struct netmsg *nmsg)
3084 {
3085 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3086 struct iwl2100_softc *sc = msg->iwlm_softc;
3087 struct ieee80211com *ic = &sc->sc_ic;
3088 struct ifnet *ifp = &ic->ic_if;
3089
3090 ASSERT_SERIALIZED(ifp->if_serializer);
3091
3092 if (sc->sc_flags & IWL2100_F_DETACH)
3093 goto reply;
3094
3095 if (ifp->if_flags & IFF_RUNNING) {
3096 ieee80211_end_scan(ic);
3097 sc->sc_flags &= ~IWL2100_F_SCANNING;
3098 }
3099 reply:
3100 lwkt_replymsg(&nmsg->nm_lmsg, 0);
3101 }
3102
3103 static int
3104 iwl2100_hw_init(struct iwl2100_softc *sc, const uint8_t *bssid,
3105 const uint8_t *essid, uint8_t esslen, uint32_t flags)
3106 {
3107 struct ieee80211com *ic = &sc->sc_ic;
3108 struct ifnet *ifp = &ic->ic_if;
3109 uint32_t db_addr;
3110 int error;
3111
3112 ASSERT_SERIALIZED(ifp->if_serializer);
3113 KKASSERT(curthread == &sc->sc_thread);
3114
3115 iwl2100_hw_stop(sc);
3116
3117 error = iwl2100_alloc_firmware(sc, ic->ic_opmode);
3118 if (error) {
3119 if_printf(ifp, "can't allocate firmware\n");
3120 goto back;
3121 }
3122
3123 error = iwl2100_load_firmware(sc, ic->ic_opmode);
3124 if (error) {
3125 if_printf(ifp, "can't load firmware\n");
3126 goto back;
3127 }
3128
3129 error = iwl2100_alloc_cmd(sc);
3130 if (error) {
3131 if_printf(ifp, "can't allocate cmd\n");
3132 goto back;
3133 }
3134
3135 error = iwl2100_init_tx_ring(sc);
3136 if (error) {
3137 if_printf(ifp, "can't init TX ring\n");
3138 goto back;
3139 }
3140
3141 error = iwl2100_init_rx_ring(sc);
3142 if (error) {
3143 if_printf(ifp, "can't init RX ring\n");
3144 goto back;
3145 }
3146
3147 error = iwl2100_init_firmware(sc);
3148 if (error) {
3149 if_printf(ifp, "can't initialize firmware\n");
3150 goto back;
3151 }
3152
3153 sc->sc_ord1 = CSR_READ_4(sc, IWL2100_ORD1_ADDR);
3154 sc->sc_ord2 = CSR_READ_4(sc, IWL2100_ORD2_ADDR);
3155
3156 db_addr = iwl2100_read_ord1(sc, IWL2100_ORD1_DBADDR);
3157 if ((IND_READ_4(sc, db_addr + 0x20) >> 24) & 0x1)
3158 sc->sc_caps &= ~IWL2100_C_RFKILL;
3159 else
3160 sc->sc_caps |= IWL2100_C_RFKILL;
3161
3162 /* Unlock firmware */
3163 iwl2100_write_ord1(sc, IWL2100_ORD1_FWLOCK, 0);
3164
3165 if (iwl2100_rfkilled(sc)) {
3166 error = ENXIO;
3167 goto back;
3168 }
3169
3170 /* Let interrupt handler run */
3171 sc->sc_flags |= IWL2100_F_INITED;
3172
3173 /* Enable interrupts */
3174 CSR_WRITE_4(sc, IWL2100_INTR_MASK, IWL2100_INTRS);
3175
3176 error = iwl2100_config(sc, bssid, essid, esslen,
3177 flags & IWL2100_INIT_F_IBSSCHAN);
3178 if (error)
3179 goto back;
3180
3181 if (flags & IWL2100_INIT_F_ENABLE) {
3182 error = iwl2100_config_done(sc);
3183 if (error) {
3184 if_printf(ifp, "can't complete config\n");
3185 goto back;
3186 }
3187 }
3188
3189 ifp->if_flags &= ~IFF_OACTIVE;
3190 ifp->if_flags |= IFF_RUNNING;
3191 back:
3192 if (error)
3193 iwl2100_stop(sc);
3194 return error;
3195 }
3196
3197 static int
3198 iwl2100_start_scan(struct iwl2100_softc *sc, uint32_t chans, uint32_t flags)
3199 {
3200 int error;
3201
3202 /*
3203 * XXX
3204 * Firmware always starts scanning once config is done
3205 */
3206 error = iwl2100_set_scanopt(sc, chans, flags);
3207 if (error) {
3208 if_printf(&sc->sc_ic.ic_if, "can't set scan opt\n");
3209 return error;
3210 }
3211
3212 error = iwl2100_set_scan(sc);
3213 if (error) {
3214 if_printf(&sc->sc_ic.ic_if, "can't set bcast scanning\n");
3215 return error;
3216 }
3217 return 0;
3218 }
3219
3220 static int
3221 iwl2100_scan(struct iwl2100_softc *sc)
3222 {
3223 struct ieee80211com *ic = &sc->sc_ic;
3224 uint32_t chans, flags;
3225 int error;
3226
3227 KKASSERT(ic->ic_opmode != IEEE80211_M_MONITOR);
3228
3229 error = iwl2100_hw_init(sc, NULL,
3230 ic->ic_des_essid, ic->ic_des_esslen, IWL2100_INIT_F_ENABLE);
3231 if (error)
3232 return error;
3233
3234 if (ic->ic_opmode == IEEE80211_M_STA) {
3235 chans = sc->sc_bss_chans;
3236 flags = IWL2100_SCANOPT_NOASSOC;
3237 } else {
3238 /*
3239 * Normally # of IBSS channels is less than BSS's
3240 * but it seems IBSS mode works on all BSS channels
3241 */
3242 #if 0
3243 chans = sc->sc_ibss_chans;
3244 #else
3245 chans = sc->sc_bss_chans;
3246 #endif
3247 /*
3248 * Don't set NOASSOC scan option, it seems that
3249 * firmware will disable itself after scanning
3250 * if this flag is set. After all, we are in
3251 * IBSS mode, which does not have concept of
3252 * association.
3253 */
3254 flags = 0;
3255 }
3256
3257 /* See NOTE in iwl2100_set_scanopt() */
3258 error = iwl2100_start_scan(sc, chans, flags);
3259 if (error)
3260 return error;
3261 return 0;
3262 }
3263
3264 static int
3265 iwl2100_auth(struct iwl2100_softc *sc)
3266 {
3267 struct ieee80211com *ic = &sc->sc_ic;
3268 struct ieee80211_node *ni = ic->ic_bss;
3269 u_int chan;
3270 int error;
3271
3272 KKASSERT(ic->ic_opmode == IEEE80211_M_STA);
3273
3274 chan = ieee80211_chan2ieee(ic, ic->ic_curchan);
3275 if (chan == IEEE80211_CHAN_ANY) {
3276 if_printf(&ic->ic_if, "invalid curchan\n");
3277 return EINVAL;
3278 }
3279
3280 error = iwl2100_hw_init(sc, ni->ni_bssid,
3281 ni->ni_essid, ni->ni_esslen, IWL2100_INIT_F_ENABLE);
3282 if (error)
3283 return error;
3284
3285 /* See NOTE in iwl2100_set_scanopt() */
3286 error = iwl2100_start_scan(sc, 1 << (chan - 1), 0);
3287 if (error)
3288 return error;
3289 return 0;
3290 }
3291
3292 static int
3293 iwl2100_ibss(struct iwl2100_softc *sc)
3294 {
3295 struct ieee80211com *ic = &sc->sc_ic;
3296 struct ieee80211_node *ni = ic->ic_bss;
3297
3298 return iwl2100_hw_init(sc, ni->ni_bssid,
3299 ni->ni_essid, ni->ni_esslen,
3300 IWL2100_INIT_F_ENABLE | IWL2100_INIT_F_IBSSCHAN);
3301 }
3302
3303 static int
3304 iwl2100_encap(struct iwl2100_softc *sc, struct mbuf *m)
3305 {
3306 struct iwl2100_tx_ring *tr = &sc->sc_txring;
3307 struct iwl2100_tx_hdr *th;
3308 struct ieee80211_frame *wh;
3309 struct iwl_dmamap_ctx ctx;
3310 bus_dma_segment_t segs[IWL2100_NSEG_MAX];
3311 uint8_t src[IEEE80211_ADDR_LEN], dst[IEEE80211_ADDR_LEN];
3312 bus_dmamap_t dmap;
3313 int maxsegs, i, first_idx, last_idx, error, host_enc;
3314
3315 /*
3316 * Save necessary information and strip 802.11 header
3317 */
3318 wh = mtod(m, struct ieee80211_frame *);
3319 IEEE80211_ADDR_COPY(src, wh->i_addr2);
3320 if (sc->sc_ic.ic_opmode == IEEE80211_M_STA)
3321 IEEE80211_ADDR_COPY(dst, wh->i_addr3);
3322 else
3323 IEEE80211_ADDR_COPY(dst, wh->i_addr1);
3324 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3325 host_enc = 1;
3326 else
3327 host_enc = 0;
3328 m_adj(m, sizeof(*wh));
3329
3330 /*
3331 * Prepend and setup hardware TX header
3332 */
3333 M_PREPEND(m, sizeof(*th), MB_DONTWAIT);
3334 if (m == NULL) {
3335 if_printf(&sc->sc_ic.ic_if, "prepend TX header failed\n");
3336 return ENOBUFS;
3337 }
3338 th = mtod(m, struct iwl2100_tx_hdr *);
3339
3340 bzero(th, sizeof(*th));
3341 th->th_cmd = IWL2100_CMD_TX_DATA;
3342 th->th_host_enc = host_enc;
3343 IEEE80211_ADDR_COPY(th->th_src, src);
3344 IEEE80211_ADDR_COPY(th->th_dst, dst);
3345
3346 /*
3347 * Load mbuf into DMA map
3348 */
3349 maxsegs = IWL2100_TX_USED_MAX - tr->tr_used;
3350 if (maxsegs > IWL2100_NSEG_MAX)
3351 maxsegs = IWL2100_NSEG_MAX;
3352
3353 KKASSERT(tr->tr_index < IWL2100_TX_NDESC);
3354 first_idx = tr->tr_index;
3355 dmap = tr->tr_buf[first_idx].tb_dmap;
3356
3357 ctx.nsegs = maxsegs;
3358 ctx.segs = segs;
3359 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, dmap, m,
3360 iwl_dma_buf_addr, &ctx, BUS_DMA_NOWAIT);
3361 if (!error && ctx.nsegs == 0) {
3362 bus_dmamap_unload(sc->sc_mbuf_dtag, dmap);
3363 error = EFBIG;
3364 }
3365 if (error && error != EFBIG) {
3366 if_printf(&sc->sc_ic.ic_if, "can't load TX mbuf, error %d\n",
3367 error);
3368 goto back;
3369 }
3370 if (error) { /* error == EFBIG */
3371 struct mbuf *m_new;
3372
3373 m_new = m_defrag(m, MB_DONTWAIT);
3374 if (m_new == NULL) {
3375 if_printf(&sc->sc_ic.ic_if, "can't defrag TX mbuf\n");
3376 error = ENOBUFS;
3377 goto back;
3378 } else {
3379 m = m_new;
3380 }
3381
3382 ctx.nsegs = maxsegs;
3383 ctx.segs = segs;
3384 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, dmap, m,
3385 iwl_dma_buf_addr, &ctx,
3386 BUS_DMA_NOWAIT);
3387 if (error || ctx.nsegs == 0) {
3388 if (ctx.nsegs == 0) {
3389 bus_dmamap_unload(sc->sc_mbuf_dtag, dmap);
3390 error = EFBIG;
3391 }
3392 if_printf(&sc->sc_ic.ic_if,
3393 "can't load defraged TX mbuf\n");
3394 goto back;
3395 }
3396 }
3397 bus_dmamap_sync(sc->sc_mbuf_dtag, dmap, BUS_DMASYNC_PREWRITE);
3398
3399 /*
3400 * Fill TX desc ring
3401 */
3402 last_idx = -1;
3403 for (i = 0; i < ctx.nsegs; ++i) {
3404 struct iwl2100_desc *d = &tr->tr_desc[tr->tr_index];
3405
3406 d->d_paddr = segs[i].ds_addr;
3407 d->d_len = segs[i].ds_len;
3408 if (i != 0)
3409 d->d_nfrag = 0;
3410 else
3411 d->d_nfrag = ctx.nsegs;
3412
3413 if (i == ctx.nsegs - 1) {
3414 d->d_flags = IWL2100_TXD_F_INTR;
3415 last_idx = tr->tr_index;
3416 } else {
3417 d->d_flags = IWL2100_TXD_F_NOTLAST;
3418 }
3419
3420 tr->tr_index = (tr->tr_index + 1) % IWL2100_TX_NDESC;
3421 }
3422 KKASSERT(last_idx >= 0);
3423
3424 tr->tr_buf[first_idx].tb_dmap = tr->tr_buf[last_idx].tb_dmap;
3425 tr->tr_buf[last_idx].tb_dmap = dmap;
3426 tr->tr_buf[last_idx].tb_mbuf = m;
3427
3428 tr->tr_used += ctx.nsegs;
3429 KKASSERT(tr->tr_used <= IWL2100_TX_USED_MAX);
3430
3431 error = 0;
3432 back:
3433 if (error)
3434 m_freem(m);
3435 return error;
3436 }
3437
3438 static void
3439 iwl2100_restart_dispatch(struct netmsg *nmsg)
3440 {
3441 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3442 struct iwl2100_softc *sc = msg->iwlm_softc;
3443 struct ieee80211com *ic = &sc->sc_ic;
3444 struct ifnet *ifp = &ic->ic_if;
3445 int error = 0;
3446
3447 ASSERT_SERIALIZED(ifp->if_serializer);
3448
3449 if (sc->sc_flags & IWL2100_F_DETACH)
3450 goto reply;
3451
3452 if ((ifp->if_flags & IFF_RUNNING) == 0)
3453 goto reply;
3454
3455 if (msg->iwlm_arg != sc->sc_state_age) {
3456 /*
3457 * Restarting was triggered in old 802.11 state
3458 * Don't do anything, this is a staled restarting.
3459 */
3460 goto reply;
3461 }
3462
3463 if (ic->ic_state != IEEE80211_S_RUN) {
3464 if_printf(ifp, "restart happened when not in RUN state\n");
3465 goto reply;
3466 }
3467
3468 /*
3469 * iwl2100_auth() may release slizer, so stop all
3470 * callouts to prevent them from misfiring.
3471 */
3472 callout_stop(&sc->sc_restart_bmiss);
3473 callout_stop(&sc->sc_ibss);
3474
3475 if (ic->ic_opmode == IEEE80211_M_STA) {
3476 error = iwl2100_auth(sc);
3477 if (error)
3478 goto reply;
3479
3480 /*
3481 * Start software beacon missing to handle missing
3482 * firmware bmiss status change when we restarting
3483 */
3484 callout_reset(&sc->sc_restart_bmiss, IEEE80211_TU_TO_TICKS(
3485 2 * ic->ic_bmissthreshold * ic->ic_bss->ni_intval),
3486 iwl2100_restart_bmiss, sc);
3487 } else if (ic->ic_opmode == IEEE80211_M_IBSS) {
3488 error = iwl2100_ibss(sc);
3489 if (error)
3490 goto reply;
3491 }
3492
3493 /* Turn on restarting flag before reply this message */
3494 sc->sc_flags |= IWL2100_F_RESTARTING;
3495 reply:
3496 lwkt_replymsg(&nmsg->nm_lmsg, error);
3497 }
3498
3499 static void
3500 iwl2100_restart(struct iwl2100_softc *sc)
3501 {
3502 if ((sc->sc_flags & (IWL2100_F_RESTARTING | IWL2100_F_DETACH)) == 0) {
3503 struct iwlmsg *msg = &sc->sc_restart_msg;
3504 struct lwkt_msg *lmsg = &msg->iwlm_nmsg.nm_lmsg;
3505
3506 DPRINTF(sc, IWL2100_DBG_RESTART, "%s", "restart\n");
3507 if (lmsg->ms_flags & MSGF_DONE) {
3508 sc->sc_flags &= ~IWL2100_F_IFSTART;
3509 msg->iwlm_arg = sc->sc_state_age;
3510 lwkt_sendmsg(&sc->sc_thread_port, lmsg);
3511 }
3512 }
3513 }
3514
3515 static void
3516 iwl2100_bmiss_dispatch(struct netmsg *nmsg)
3517 {
3518 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3519 struct iwl2100_softc *sc = msg->iwlm_softc;
3520 struct ieee80211com *ic = &sc->sc_ic;
3521 struct ifnet *ifp = &ic->ic_if;
3522
3523 ASSERT_SERIALIZED(ifp->if_serializer);
3524
3525 if (sc->sc_flags & IWL2100_F_DETACH)
3526 goto reply;
3527
3528 if (ifp->if_flags & IFF_RUNNING) {
3529 /*
3530 * Fake a ic_bmiss_count to make sure that
3531 * ieee80211_beacon_miss() will do its job
3532 */
3533 ic->ic_bmiss_count = ic->ic_bmiss_max;
3534 ieee80211_beacon_miss(ic);
3535 }
3536 reply:
3537 lwkt_replymsg(&nmsg->nm_lmsg, 0);
3538 }
3539
3540 static void
3541 iwl2100_restart_bmiss(void *xsc)
3542 {
3543 struct iwl2100_softc *sc = xsc;
3544 struct ifnet *ifp = &sc->sc_ic.ic_if;
3545
3546 lwkt_serialize_enter(ifp->if_serializer);
3547
3548 if (sc->sc_flags & IWL2100_F_DETACH)
3549 goto back;
3550
3551 if ((ifp->if_flags & IFF_RUNNING) == 0)
3552 goto back;
3553
3554 if (sc->sc_flags & IWL2100_F_RESTARTING) {
3555 DPRINTF(sc, IWL2100_DBG_SCAN | IWL2100_DBG_RESTART, "%s",
3556 "restart bmiss\n");
3557 iwlmsg_send(&sc->sc_bmiss_msg, &sc->sc_thread_port);
3558 }
3559 back:
3560 lwkt_serialize_exit(ifp->if_serializer);
3561 }
3562
3563 static void
3564 iwl2100_ibss_bssid(void *xsc)
3565 {
3566 struct iwl2100_softc *sc = xsc;
3567 struct ieee80211com *ic = &sc->sc_ic;
3568 struct ifnet *ifp = &ic->ic_if;
3569
3570 lwkt_serialize_enter(ifp->if_serializer);
3571
3572 if (sc->sc_flags & IWL2100_F_DETACH)
3573 goto back;
3574
3575 if ((ifp->if_flags & IFF_RUNNING) == 0)
3576 goto back;
3577
3578 if (ic->ic_state == IEEE80211_S_RUN &&
3579 ic->ic_opmode == IEEE80211_M_IBSS) {
3580 uint8_t bssid[IEEE80211_ADDR_LEN];
3581 int len;
3582
3583 len = iwl2100_read_ord2(sc, IWL2100_ORD2_BSSID,
3584 bssid, sizeof(bssid));
3585 if (len < (int)sizeof(bssid)) {
3586 if_printf(ifp, "can't get IBSS bssid\n");
3587 } else {
3588 DPRINTF(sc, IWL2100_DBG_IBSS, "IBSS bssid: %6D\n",
3589 bssid, ":");
3590 IEEE80211_ADDR_COPY(ic->ic_bss->ni_bssid, bssid);
3591
3592 sc->sc_flags |= IWL2100_F_IFSTART;
3593 if_devstart(ifp);
3594 }
3595 }
3596 back:
3597 lwkt_serialize_exit(ifp->if_serializer);
3598 }
3599
3600 static void
3601 iwl2100_reinit(struct iwl2100_softc *sc)
3602 {
3603 struct ifnet *ifp = &sc->sc_ic.ic_if;
3604
3605 callout_stop(&sc->sc_restart_bmiss);
3606 callout_stop(&sc->sc_ibss);
3607
3608 ifp->if_flags &= ~IFF_RUNNING;
3609 ifp->if_timer = 0;
3610
3611 sc->sc_flags &= ~IWL2100_F_INITED;
3612 sc->sc_tx_timer = 0;
3613
3614 /* Mark error happened, and wake up the pending command */
3615 sc->sc_flags |= IWL2100_F_ERROR;
3616 wakeup(sc);
3617
3618 if ((sc->sc_flags & IWL2100_F_DETACH) == 0) {
3619 /*
3620 * Schedule complete initialization,
3621 * i.e. blow away current state
3622 */
3623 iwlmsg_send(&sc->sc_reinit_msg, &sc->sc_thread_port);
3624 }
3625 }
3626
3627 static void
3628 iwl2100_reinit_dispatch(struct netmsg *nmsg)
3629 {
3630 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3631 struct iwl2100_softc *sc = msg->iwlm_softc;
3632 struct ifnet *ifp = &sc->sc_ic.ic_if;
3633
3634 ASSERT_SERIALIZED(ifp->if_serializer);
3635
3636 /*
3637 * NOTE: Reply ASAP, so reinit msg could be used if error intr
3638 * happened again during following iwl2100_init()
3639 */
3640 lwkt_replymsg(&nmsg->nm_lmsg, 0);
3641
3642 if (sc->sc_flags & IWL2100_F_DETACH)
3643 return;
3644
3645 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == IFF_UP)
3646 iwl2100_init(sc);
3647 }
3648
3649 static void
3650 iwl2100_reinit_callout(void *xsc)
3651 {
3652 struct iwl2100_softc *sc = xsc;
3653 struct ifnet *ifp = &sc->sc_ic.ic_if;
3654
3655 lwkt_serialize_enter(ifp->if_serializer);
3656 if ((sc->sc_flags & IWL2100_F_DETACH) == 0)
3657 iwl2100_reinit(sc);
3658 lwkt_serialize_exit(ifp->if_serializer);
3659 }
3660
3661 static void
3662 iwl2100_chan_change(struct iwl2100_softc *sc, const struct ieee80211_channel *c)
3663 {
3664 sc->sc_tx_th.wt_chan_freq = sc->sc_rx_th.wr_chan_freq =
3665 htole16(c->ic_freq);
3666 }
3667
3668 static void
3669 iwl2100_stop_callouts(struct iwl2100_softc *sc)
3670 {
3671 callout_stop(&sc->sc_restart_bmiss);
3672 callout_stop(&sc->sc_ibss);
3673 callout_stop(&sc->sc_reinit);
3674 }
DragonFly BSD