Deleted Added
sdiff udiff text old ( 285234 ) new ( 286410 )
full compact
if_iwn.c (285234) if_iwn.c (286410)
1/*-
2 * Copyright (c) 2007-2009 Damien Bergamini <damien.bergamini@free.fr>
3 * Copyright (c) 2008 Benjamin Close <benjsc@FreeBSD.org>
4 * Copyright (c) 2008 Sam Leffler, Errno Consulting
5 * Copyright (c) 2011 Intel Corporation
6 * Copyright (c) 2013 Cedric GROSS <c.gross@kreiz-it.fr>
7 * Copyright (c) 2013 Adrian Chadd <adrian@FreeBSD.org>
8 *

--- 11 unchanged lines hidden (view full) ---

20 */
21
22/*
23 * Driver for Intel WiFi Link 4965 and 1000/5000/6000 Series 802.11 network
24 * adapters.
25 */
26
27#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 2007-2009 Damien Bergamini <damien.bergamini@free.fr>
3 * Copyright (c) 2008 Benjamin Close <benjsc@FreeBSD.org>
4 * Copyright (c) 2008 Sam Leffler, Errno Consulting
5 * Copyright (c) 2011 Intel Corporation
6 * Copyright (c) 2013 Cedric GROSS <c.gross@kreiz-it.fr>
7 * Copyright (c) 2013 Adrian Chadd <adrian@FreeBSD.org>
8 *

--- 11 unchanged lines hidden (view full) ---

20 */
21
22/*
23 * Driver for Intel WiFi Link 4965 and 1000/5000/6000 Series 802.11 network
24 * adapters.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sys/dev/iwn/if_iwn.c 285234 2015-07-07 03:51:29Z adrian $");
28__FBSDID("$FreeBSD: head/sys/dev/iwn/if_iwn.c 286410 2015-08-07 11:43:14Z glebius $");
29
30#include "opt_wlan.h"
31#include "opt_iwn.h"
32
33#include <sys/param.h>
34#include <sys/sockio.h>
35#include <sys/sysctl.h>
36#include <sys/mbuf.h>

--- 193 unchanged lines hidden (view full) ---

230static int iwn_tx_data(struct iwn_softc *, struct mbuf *,
231 struct ieee80211_node *);
232static int iwn_tx_data_raw(struct iwn_softc *, struct mbuf *,
233 struct ieee80211_node *,
234 const struct ieee80211_bpf_params *params);
235static void iwn_xmit_task(void *arg0, int pending);
236static int iwn_raw_xmit(struct ieee80211_node *, struct mbuf *,
237 const struct ieee80211_bpf_params *);
29
30#include "opt_wlan.h"
31#include "opt_iwn.h"
32
33#include <sys/param.h>
34#include <sys/sockio.h>
35#include <sys/sysctl.h>
36#include <sys/mbuf.h>

--- 193 unchanged lines hidden (view full) ---

230static int iwn_tx_data(struct iwn_softc *, struct mbuf *,
231 struct ieee80211_node *);
232static int iwn_tx_data_raw(struct iwn_softc *, struct mbuf *,
233 struct ieee80211_node *,
234 const struct ieee80211_bpf_params *params);
235static void iwn_xmit_task(void *arg0, int pending);
236static int iwn_raw_xmit(struct ieee80211_node *, struct mbuf *,
237 const struct ieee80211_bpf_params *);
238static void iwn_start(struct ifnet *);
239static void iwn_start_locked(struct ifnet *);
238static int iwn_transmit(struct ieee80211com *, struct mbuf *);
239static void iwn_start_locked(struct iwn_softc *);
240static void iwn_watchdog(void *);
240static void iwn_watchdog(void *);
241static int iwn_ioctl(struct ifnet *, u_long, caddr_t);
241static int iwn_ioctl(struct ieee80211com *, u_long , void *);
242static void iwn_parent(struct ieee80211com *);
242static int iwn_cmd(struct iwn_softc *, int, const void *, int, int);
243static int iwn4965_add_node(struct iwn_softc *, struct iwn_node_info *,
244 int);
245static int iwn5000_add_node(struct iwn_softc *, struct iwn_node_info *,
246 int);
247static int iwn_set_link_quality(struct iwn_softc *,
248 struct ieee80211_node *);
249static int iwn_add_broadcast_node(struct iwn_softc *, int);

--- 81 unchanged lines hidden (view full) ---

331static int iwn5000_nic_config(struct iwn_softc *);
332static int iwn_hw_prepare(struct iwn_softc *);
333static int iwn_hw_init(struct iwn_softc *);
334static void iwn_hw_stop(struct iwn_softc *);
335static void iwn_radio_on(void *, int);
336static void iwn_radio_off(void *, int);
337static void iwn_panicked(void *, int);
338static void iwn_init_locked(struct iwn_softc *);
243static int iwn_cmd(struct iwn_softc *, int, const void *, int, int);
244static int iwn4965_add_node(struct iwn_softc *, struct iwn_node_info *,
245 int);
246static int iwn5000_add_node(struct iwn_softc *, struct iwn_node_info *,
247 int);
248static int iwn_set_link_quality(struct iwn_softc *,
249 struct ieee80211_node *);
250static int iwn_add_broadcast_node(struct iwn_softc *, int);

--- 81 unchanged lines hidden (view full) ---

332static int iwn5000_nic_config(struct iwn_softc *);
333static int iwn_hw_prepare(struct iwn_softc *);
334static int iwn_hw_init(struct iwn_softc *);
335static void iwn_hw_stop(struct iwn_softc *);
336static void iwn_radio_on(void *, int);
337static void iwn_radio_off(void *, int);
338static void iwn_panicked(void *, int);
339static void iwn_init_locked(struct iwn_softc *);
339static void iwn_init(void *);
340static void iwn_init(struct iwn_softc *);
340static void iwn_stop_locked(struct iwn_softc *);
341static void iwn_stop(struct iwn_softc *);
342static void iwn_scan_start(struct ieee80211com *);
343static void iwn_scan_end(struct ieee80211com *);
344static void iwn_set_channel(struct ieee80211com *);
345static void iwn_scan_curchan(struct ieee80211_scan_state *, unsigned long);
346static void iwn_scan_mindwell(struct ieee80211_scan_state *);
347static void iwn_hw_reset(void *, int);

--- 53 unchanged lines hidden (view full) ---

401 return (0);
402}
403
404static int
405iwn_attach(device_t dev)
406{
407 struct iwn_softc *sc = (struct iwn_softc *)device_get_softc(dev);
408 struct ieee80211com *ic;
341static void iwn_stop_locked(struct iwn_softc *);
342static void iwn_stop(struct iwn_softc *);
343static void iwn_scan_start(struct ieee80211com *);
344static void iwn_scan_end(struct ieee80211com *);
345static void iwn_set_channel(struct ieee80211com *);
346static void iwn_scan_curchan(struct ieee80211_scan_state *, unsigned long);
347static void iwn_scan_mindwell(struct ieee80211_scan_state *);
348static void iwn_hw_reset(void *, int);

--- 53 unchanged lines hidden (view full) ---

402 return (0);
403}
404
405static int
406iwn_attach(device_t dev)
407{
408 struct iwn_softc *sc = (struct iwn_softc *)device_get_softc(dev);
409 struct ieee80211com *ic;
409 struct ifnet *ifp;
410 int i, error, rid;
410 int i, error, rid;
411 uint8_t macaddr[IEEE80211_ADDR_LEN];
412
413 sc->sc_dev = dev;
414
415#ifdef IWN_DEBUG
416 error = resource_int_value(device_get_name(sc->sc_dev),
417 device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug));
418 if (error != 0)
419 sc->sc_debug = 0;

--- 39 unchanged lines hidden (view full) ---

459 (rid != 0 ? 0 : RF_SHAREABLE));
460 if (sc->irq == NULL) {
461 device_printf(dev, "can't map interrupt\n");
462 error = ENOMEM;
463 goto fail;
464 }
465
466 IWN_LOCK_INIT(sc);
411
412 sc->sc_dev = dev;
413
414#ifdef IWN_DEBUG
415 error = resource_int_value(device_get_name(sc->sc_dev),
416 device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug));
417 if (error != 0)
418 sc->sc_debug = 0;

--- 39 unchanged lines hidden (view full) ---

458 (rid != 0 ? 0 : RF_SHAREABLE));
459 if (sc->irq == NULL) {
460 device_printf(dev, "can't map interrupt\n");
461 error = ENOMEM;
462 goto fail;
463 }
464
465 IWN_LOCK_INIT(sc);
466 mbufq_init(&sc->sc_snd, ifqmaxlen);
467
468 /* Read hardware revision and attach. */
469 sc->hw_type = (IWN_READ(sc, IWN_HW_REV) >> IWN_HW_REV_TYPE_SHIFT)
470 & IWN_HW_REV_TYPE_MASK;
471 sc->subdevice_id = pci_get_subdevice(dev);
472
473 /*
474 * 4965 versus 5000 and later have different methods.

--- 69 unchanged lines hidden (view full) ---

544 device_printf(dev, "could not allocate RX ring, error %d\n",
545 error);
546 goto fail;
547 }
548
549 /* Clear pending interrupts. */
550 IWN_WRITE(sc, IWN_INT, 0xffffffff);
551
467
468 /* Read hardware revision and attach. */
469 sc->hw_type = (IWN_READ(sc, IWN_HW_REV) >> IWN_HW_REV_TYPE_SHIFT)
470 & IWN_HW_REV_TYPE_MASK;
471 sc->subdevice_id = pci_get_subdevice(dev);
472
473 /*
474 * 4965 versus 5000 and later have different methods.

--- 69 unchanged lines hidden (view full) ---

544 device_printf(dev, "could not allocate RX ring, error %d\n",
545 error);
546 goto fail;
547 }
548
549 /* Clear pending interrupts. */
550 IWN_WRITE(sc, IWN_INT, 0xffffffff);
551
552 ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211);
553 if (ifp == NULL) {
554 device_printf(dev, "can not allocate ifnet structure\n");
555 goto fail;
556 }
557
558 ic = ifp->if_l2com;
559 ic->ic_ifp = ifp;
552 ic = &sc->sc_ic;
560 ic->ic_softc = sc;
561 ic->ic_name = device_get_nameunit(dev);
562 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
563 ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
564
565 /* Set device capabilities. */
566 ic->ic_caps =
567 IEEE80211_C_STA /* station mode supported */

--- 8 unchanged lines hidden (view full) ---

576#if 0
577 | IEEE80211_C_IBSS /* ibss/adhoc mode */
578#endif
579 | IEEE80211_C_WME /* WME */
580 | IEEE80211_C_PMGT /* Station-side power mgmt */
581 ;
582
583 /* Read MAC address, channels, etc from EEPROM. */
553 ic->ic_softc = sc;
554 ic->ic_name = device_get_nameunit(dev);
555 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
556 ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
557
558 /* Set device capabilities. */
559 ic->ic_caps =
560 IEEE80211_C_STA /* station mode supported */

--- 8 unchanged lines hidden (view full) ---

569#if 0
570 | IEEE80211_C_IBSS /* ibss/adhoc mode */
571#endif
572 | IEEE80211_C_WME /* WME */
573 | IEEE80211_C_PMGT /* Station-side power mgmt */
574 ;
575
576 /* Read MAC address, channels, etc from EEPROM. */
584 if ((error = iwn_read_eeprom(sc, macaddr)) != 0) {
577 if ((error = iwn_read_eeprom(sc, ic->ic_macaddr)) != 0) {
585 device_printf(dev, "could not read EEPROM, error %d\n",
586 error);
587 goto fail;
588 }
589
590 /* Count the number of available chains. */
591 sc->ntxchains =
592 ((sc->txchainmask >> 2) & 1) +
593 ((sc->txchainmask >> 1) & 1) +
594 ((sc->txchainmask >> 0) & 1);
595 sc->nrxchains =
596 ((sc->rxchainmask >> 2) & 1) +
597 ((sc->rxchainmask >> 1) & 1) +
598 ((sc->rxchainmask >> 0) & 1);
599 if (bootverbose) {
600 device_printf(dev, "MIMO %dT%dR, %.4s, address %6D\n",
601 sc->ntxchains, sc->nrxchains, sc->eeprom_domain,
578 device_printf(dev, "could not read EEPROM, error %d\n",
579 error);
580 goto fail;
581 }
582
583 /* Count the number of available chains. */
584 sc->ntxchains =
585 ((sc->txchainmask >> 2) & 1) +
586 ((sc->txchainmask >> 1) & 1) +
587 ((sc->txchainmask >> 0) & 1);
588 sc->nrxchains =
589 ((sc->rxchainmask >> 2) & 1) +
590 ((sc->rxchainmask >> 1) & 1) +
591 ((sc->rxchainmask >> 0) & 1);
592 if (bootverbose) {
593 device_printf(dev, "MIMO %dT%dR, %.4s, address %6D\n",
594 sc->ntxchains, sc->nrxchains, sc->eeprom_domain,
602 macaddr, ":");
595 ic->ic_macaddr, ":");
603 }
604
605 if (sc->sc_flags & IWN_FLAG_HAS_11N) {
606 ic->ic_rxstream = sc->nrxchains;
607 ic->ic_txstream = sc->ntxchains;
608
609 /*
610 * Some of the 3 antenna devices (ie, the 4965) only supports

--- 24 unchanged lines hidden (view full) ---

635 | IEEE80211_HTC_HT /* HT operation */
636 | IEEE80211_HTC_AMPDU /* tx A-MPDU */
637#ifdef notyet
638 | IEEE80211_HTC_AMSDU /* tx A-MSDU */
639#endif
640 ;
641 }
642
596 }
597
598 if (sc->sc_flags & IWN_FLAG_HAS_11N) {
599 ic->ic_rxstream = sc->nrxchains;
600 ic->ic_txstream = sc->ntxchains;
601
602 /*
603 * Some of the 3 antenna devices (ie, the 4965) only supports

--- 24 unchanged lines hidden (view full) ---

628 | IEEE80211_HTC_HT /* HT operation */
629 | IEEE80211_HTC_AMPDU /* tx A-MPDU */
630#ifdef notyet
631 | IEEE80211_HTC_AMSDU /* tx A-MSDU */
632#endif
633 ;
634 }
635
643 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
644 ifp->if_softc = sc;
645 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
646 ifp->if_init = iwn_init;
647 ifp->if_ioctl = iwn_ioctl;
648 ifp->if_start = iwn_start;
649 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
650 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
651 IFQ_SET_READY(&ifp->if_snd);
652
653 ieee80211_ifattach(ic, macaddr);
636 ieee80211_ifattach(ic);
654 ic->ic_vap_create = iwn_vap_create;
637 ic->ic_vap_create = iwn_vap_create;
638 ic->ic_ioctl = iwn_ioctl;
639 ic->ic_parent = iwn_parent;
655 ic->ic_vap_delete = iwn_vap_delete;
640 ic->ic_vap_delete = iwn_vap_delete;
641 ic->ic_transmit = iwn_transmit;
656 ic->ic_raw_xmit = iwn_raw_xmit;
657 ic->ic_node_alloc = iwn_node_alloc;
658 sc->sc_ampdu_rx_start = ic->ic_ampdu_rx_start;
659 ic->ic_ampdu_rx_start = iwn_ampdu_rx_start;
660 sc->sc_ampdu_rx_stop = ic->ic_ampdu_rx_stop;
661 ic->ic_ampdu_rx_stop = iwn_ampdu_rx_stop;
662 sc->sc_addba_request = ic->ic_addba_request;
663 ic->ic_addba_request = iwn_addba_request;

--- 624 unchanged lines hidden (view full) ---

1288}
1289
1290/*
1291 * Attach the interface to 802.11 radiotap.
1292 */
1293static void
1294iwn_radiotap_attach(struct iwn_softc *sc)
1295{
642 ic->ic_raw_xmit = iwn_raw_xmit;
643 ic->ic_node_alloc = iwn_node_alloc;
644 sc->sc_ampdu_rx_start = ic->ic_ampdu_rx_start;
645 ic->ic_ampdu_rx_start = iwn_ampdu_rx_start;
646 sc->sc_ampdu_rx_stop = ic->ic_ampdu_rx_stop;
647 ic->ic_ampdu_rx_stop = iwn_ampdu_rx_stop;
648 sc->sc_addba_request = ic->ic_addba_request;
649 ic->ic_addba_request = iwn_addba_request;

--- 624 unchanged lines hidden (view full) ---

1274}
1275
1276/*
1277 * Attach the interface to 802.11 radiotap.
1278 */
1279static void
1280iwn_radiotap_attach(struct iwn_softc *sc)
1281{
1296 struct ifnet *ifp = sc->sc_ifp;
1297 struct ieee80211com *ic = ifp->if_l2com;
1282
1298 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
1283 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
1299 ieee80211_radiotap_attach(ic,
1284 ieee80211_radiotap_attach(&sc->sc_ic,
1300 &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
1301 IWN_TX_RADIOTAP_PRESENT,
1302 &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
1303 IWN_RX_RADIOTAP_PRESENT);
1304 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s end\n", __func__);
1305}
1306
1307static void

--- 13 unchanged lines hidden (view full) ---

1321iwn_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
1322 enum ieee80211_opmode opmode, int flags,
1323 const uint8_t bssid[IEEE80211_ADDR_LEN],
1324 const uint8_t mac[IEEE80211_ADDR_LEN])
1325{
1326 struct iwn_softc *sc = ic->ic_softc;
1327 struct iwn_vap *ivp;
1328 struct ieee80211vap *vap;
1285 &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
1286 IWN_TX_RADIOTAP_PRESENT,
1287 &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
1288 IWN_RX_RADIOTAP_PRESENT);
1289 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s end\n", __func__);
1290}
1291
1292static void

--- 13 unchanged lines hidden (view full) ---

1306iwn_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
1307 enum ieee80211_opmode opmode, int flags,
1308 const uint8_t bssid[IEEE80211_ADDR_LEN],
1309 const uint8_t mac[IEEE80211_ADDR_LEN])
1310{
1311 struct iwn_softc *sc = ic->ic_softc;
1312 struct iwn_vap *ivp;
1313 struct ieee80211vap *vap;
1329 uint8_t mac1[IEEE80211_ADDR_LEN];
1330
1331 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */
1332 return NULL;
1333
1314
1315 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */
1316 return NULL;
1317
1334 IEEE80211_ADDR_COPY(mac1, mac);
1335
1336 ivp = (struct iwn_vap *) malloc(sizeof(struct iwn_vap),
1337 M_80211_VAP, M_NOWAIT | M_ZERO);
1338 if (ivp == NULL)
1339 return NULL;
1318 ivp = malloc(sizeof(struct iwn_vap), M_80211_VAP, M_WAITOK | M_ZERO);
1340 vap = &ivp->iv_vap;
1319 vap = &ivp->iv_vap;
1341 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac1);
1320 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid);
1342 ivp->ctx = IWN_RXON_BSS_CTX;
1321 ivp->ctx = IWN_RXON_BSS_CTX;
1343 IEEE80211_ADDR_COPY(ivp->macaddr, mac1);
1344 vap->iv_bmissthreshold = 10; /* override default */
1345 /* Override with driver methods. */
1346 ivp->iv_newstate = vap->iv_newstate;
1347 vap->iv_newstate = iwn_newstate;
1348 sc->ivap[IWN_RXON_BSS_CTX] = vap;
1349
1350 ieee80211_ratectl_init(vap);
1351 /* Complete setup. */
1322 vap->iv_bmissthreshold = 10; /* override default */
1323 /* Override with driver methods. */
1324 ivp->iv_newstate = vap->iv_newstate;
1325 vap->iv_newstate = iwn_newstate;
1326 sc->ivap[IWN_RXON_BSS_CTX] = vap;
1327
1328 ieee80211_ratectl_init(vap);
1329 /* Complete setup. */
1352 ieee80211_vap_attach(vap, iwn_media_change, ieee80211_media_status);
1330 ieee80211_vap_attach(vap, iwn_media_change, ieee80211_media_status,
1331 mac);
1353 ic->ic_opmode = opmode;
1354 return vap;
1355}
1356
1357static void
1358iwn_vap_delete(struct ieee80211vap *vap)
1359{
1360 struct iwn_vap *ivp = IWN_VAP(vap);

--- 24 unchanged lines hidden (view full) ---

1385 IWN_LOCK_ASSERT(sc);
1386 return (mbufq_enqueue(&sc->sc_xmit_queue, m));
1387}
1388
1389static int
1390iwn_detach(device_t dev)
1391{
1392 struct iwn_softc *sc = device_get_softc(dev);
1332 ic->ic_opmode = opmode;
1333 return vap;
1334}
1335
1336static void
1337iwn_vap_delete(struct ieee80211vap *vap)
1338{
1339 struct iwn_vap *ivp = IWN_VAP(vap);

--- 24 unchanged lines hidden (view full) ---

1364 IWN_LOCK_ASSERT(sc);
1365 return (mbufq_enqueue(&sc->sc_xmit_queue, m));
1366}
1367
1368static int
1369iwn_detach(device_t dev)
1370{
1371 struct iwn_softc *sc = device_get_softc(dev);
1393 struct ifnet *ifp = sc->sc_ifp;
1394 struct ieee80211com *ic;
1395 int qid;
1396
1397 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
1398
1372 int qid;
1373
1374 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
1375
1399 if (ifp != NULL) {
1400 ic = ifp->if_l2com;
1401
1376 if (sc->sc_ic.ic_softc != NULL) {
1402 /* Free the mbuf queue and node references */
1403 IWN_LOCK(sc);
1404 iwn_xmit_queue_drain(sc);
1405 IWN_UNLOCK(sc);
1406
1377 /* Free the mbuf queue and node references */
1378 IWN_LOCK(sc);
1379 iwn_xmit_queue_drain(sc);
1380 IWN_UNLOCK(sc);
1381
1407 ieee80211_draintask(ic, &sc->sc_reinit_task);
1408 ieee80211_draintask(ic, &sc->sc_radioon_task);
1409 ieee80211_draintask(ic, &sc->sc_radiooff_task);
1410
1382 ieee80211_draintask(&sc->sc_ic, &sc->sc_reinit_task);
1383 ieee80211_draintask(&sc->sc_ic, &sc->sc_radioon_task);
1384 ieee80211_draintask(&sc->sc_ic, &sc->sc_radiooff_task);
1411 iwn_stop(sc);
1412
1413 taskqueue_drain_all(sc->sc_tq);
1414 taskqueue_free(sc->sc_tq);
1415
1416 callout_drain(&sc->watchdog_to);
1417 callout_drain(&sc->calib_to);
1385 iwn_stop(sc);
1386
1387 taskqueue_drain_all(sc->sc_tq);
1388 taskqueue_free(sc->sc_tq);
1389
1390 callout_drain(&sc->watchdog_to);
1391 callout_drain(&sc->calib_to);
1418 ieee80211_ifdetach(ic);
1392 ieee80211_ifdetach(&sc->sc_ic);
1419 }
1420
1393 }
1394
1395 mbufq_drain(&sc->sc_snd);
1396
1421 /* Uninstall interrupt handler. */
1422 if (sc->irq != NULL) {
1423 bus_teardown_intr(dev, sc->irq, sc->sc_ih);
1424 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq),
1425 sc->irq);
1426 pci_release_msi(dev);
1427 }
1428

--- 6 unchanged lines hidden (view full) ---

1435 if (sc->ict != NULL)
1436 iwn_free_ict(sc);
1437 iwn_free_fwmem(sc);
1438
1439 if (sc->mem != NULL)
1440 bus_release_resource(dev, SYS_RES_MEMORY,
1441 rman_get_rid(sc->mem), sc->mem);
1442
1397 /* Uninstall interrupt handler. */
1398 if (sc->irq != NULL) {
1399 bus_teardown_intr(dev, sc->irq, sc->sc_ih);
1400 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq),
1401 sc->irq);
1402 pci_release_msi(dev);
1403 }
1404

--- 6 unchanged lines hidden (view full) ---

1411 if (sc->ict != NULL)
1412 iwn_free_ict(sc);
1413 iwn_free_fwmem(sc);
1414
1415 if (sc->mem != NULL)
1416 bus_release_resource(dev, SYS_RES_MEMORY,
1417 rman_get_rid(sc->mem), sc->mem);
1418
1443 if (ifp != NULL)
1444 if_free(ifp);
1445
1446 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n", __func__);
1447 IWN_LOCK_DESTROY(sc);
1448 return 0;
1449}
1450
1451static int
1452iwn_shutdown(device_t dev)
1453{
1454 struct iwn_softc *sc = device_get_softc(dev);
1455
1456 iwn_stop(sc);
1457 return 0;
1458}
1459
1460static int
1461iwn_suspend(device_t dev)
1462{
1463 struct iwn_softc *sc = device_get_softc(dev);
1419 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n", __func__);
1420 IWN_LOCK_DESTROY(sc);
1421 return 0;
1422}
1423
1424static int
1425iwn_shutdown(device_t dev)
1426{
1427 struct iwn_softc *sc = device_get_softc(dev);
1428
1429 iwn_stop(sc);
1430 return 0;
1431}
1432
1433static int
1434iwn_suspend(device_t dev)
1435{
1436 struct iwn_softc *sc = device_get_softc(dev);
1464 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
1465
1437
1466 ieee80211_suspend_all(ic);
1438 ieee80211_suspend_all(&sc->sc_ic);
1467 return 0;
1468}
1469
1470static int
1471iwn_resume(device_t dev)
1472{
1473 struct iwn_softc *sc = device_get_softc(dev);
1439 return 0;
1440}
1441
1442static int
1443iwn_resume(device_t dev)
1444{
1445 struct iwn_softc *sc = device_get_softc(dev);
1474 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
1475
1476 /* Clear device-specific "PCI retry timeout" register (41h). */
1477 pci_write_config(dev, 0x41, 0, 1);
1478
1446
1447 /* Clear device-specific "PCI retry timeout" register (41h). */
1448 pci_write_config(dev, 0x41, 0, 1);
1449
1479 ieee80211_resume_all(ic);
1450 ieee80211_resume_all(&sc->sc_ic);
1480 return 0;
1481}
1482
1483static int
1484iwn_nic_lock(struct iwn_softc *sc)
1485{
1486 int ntries;
1487

--- 892 unchanged lines hidden (view full) ---

2380 }
2381
2382 return nflags;
2383}
2384
2385static void
2386iwn_read_eeprom_band(struct iwn_softc *sc, int n)
2387{
1451 return 0;
1452}
1453
1454static int
1455iwn_nic_lock(struct iwn_softc *sc)
1456{
1457 int ntries;
1458

--- 892 unchanged lines hidden (view full) ---

2351 }
2352
2353 return nflags;
2354}
2355
2356static void
2357iwn_read_eeprom_band(struct iwn_softc *sc, int n)
2358{
2388 struct ifnet *ifp = sc->sc_ifp;
2389 struct ieee80211com *ic = ifp->if_l2com;
2359 struct ieee80211com *ic = &sc->sc_ic;
2390 struct iwn_eeprom_chan *channels = sc->eeprom_channels[n];
2391 const struct iwn_chan_band *band = &iwn_bands[n];
2392 struct ieee80211_channel *c;
2393 uint8_t chan;
2394 int i, nflags;
2395
2396 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
2397

--- 42 unchanged lines hidden (view full) ---

2440
2441 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s end\n", __func__);
2442
2443}
2444
2445static void
2446iwn_read_eeprom_ht40(struct iwn_softc *sc, int n)
2447{
2360 struct iwn_eeprom_chan *channels = sc->eeprom_channels[n];
2361 const struct iwn_chan_band *band = &iwn_bands[n];
2362 struct ieee80211_channel *c;
2363 uint8_t chan;
2364 int i, nflags;
2365
2366 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
2367

--- 42 unchanged lines hidden (view full) ---

2410
2411 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s end\n", __func__);
2412
2413}
2414
2415static void
2416iwn_read_eeprom_ht40(struct iwn_softc *sc, int n)
2417{
2448 struct ifnet *ifp = sc->sc_ifp;
2449 struct ieee80211com *ic = ifp->if_l2com;
2418 struct ieee80211com *ic = &sc->sc_ic;
2450 struct iwn_eeprom_chan *channels = sc->eeprom_channels[n];
2451 const struct iwn_chan_band *band = &iwn_bands[n];
2452 struct ieee80211_channel *c, *cent, *extc;
2453 uint8_t chan;
2454 int i, nflags;
2455
2456 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s start\n", __func__);
2457

--- 51 unchanged lines hidden (view full) ---

2509
2510 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s end\n", __func__);
2511
2512}
2513
2514static void
2515iwn_read_eeprom_channels(struct iwn_softc *sc, int n, uint32_t addr)
2516{
2419 struct iwn_eeprom_chan *channels = sc->eeprom_channels[n];
2420 const struct iwn_chan_band *band = &iwn_bands[n];
2421 struct ieee80211_channel *c, *cent, *extc;
2422 uint8_t chan;
2423 int i, nflags;
2424
2425 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s start\n", __func__);
2426

--- 51 unchanged lines hidden (view full) ---

2478
2479 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s end\n", __func__);
2480
2481}
2482
2483static void
2484iwn_read_eeprom_channels(struct iwn_softc *sc, int n, uint32_t addr)
2485{
2517 struct ifnet *ifp = sc->sc_ifp;
2518 struct ieee80211com *ic = ifp->if_l2com;
2486 struct ieee80211com *ic = &sc->sc_ic;
2519
2520 iwn_read_prom_data(sc, addr, &sc->eeprom_channels[n],
2521 iwn_bands[n].nchan * sizeof (struct iwn_eeprom_chan));
2522
2523 if (n < 5)
2524 iwn_read_eeprom_band(sc, n);
2525 else
2526 iwn_read_eeprom_ht40(sc, n);

--- 51 unchanged lines hidden (view full) ---

2578
2579 return 0;
2580}
2581
2582static void
2583iwn_read_eeprom_enhinfo(struct iwn_softc *sc)
2584{
2585 struct iwn_eeprom_enhinfo enhinfo[35];
2487
2488 iwn_read_prom_data(sc, addr, &sc->eeprom_channels[n],
2489 iwn_bands[n].nchan * sizeof (struct iwn_eeprom_chan));
2490
2491 if (n < 5)
2492 iwn_read_eeprom_band(sc, n);
2493 else
2494 iwn_read_eeprom_ht40(sc, n);

--- 51 unchanged lines hidden (view full) ---

2546
2547 return 0;
2548}
2549
2550static void
2551iwn_read_eeprom_enhinfo(struct iwn_softc *sc)
2552{
2553 struct iwn_eeprom_enhinfo enhinfo[35];
2586 struct ifnet *ifp = sc->sc_ifp;
2587 struct ieee80211com *ic = ifp->if_l2com;
2554 struct ieee80211com *ic = &sc->sc_ic;
2588 struct ieee80211_channel *c;
2589 uint16_t val, base;
2590 int8_t maxpwr;
2591 uint8_t flags;
2592 int i, j;
2593
2594 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
2595

--- 366 unchanged lines hidden (view full) ---

2962 * Process an RX_DONE (4965AGN only) or MPDU_RX_DONE firmware notification.
2963 * Each MPDU_RX_DONE notification must be preceded by an RX_PHY one.
2964 */
2965static void
2966iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
2967 struct iwn_rx_data *data)
2968{
2969 struct iwn_ops *ops = &sc->ops;
2555 struct ieee80211_channel *c;
2556 uint16_t val, base;
2557 int8_t maxpwr;
2558 uint8_t flags;
2559 int i, j;
2560
2561 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
2562

--- 366 unchanged lines hidden (view full) ---

2929 * Process an RX_DONE (4965AGN only) or MPDU_RX_DONE firmware notification.
2930 * Each MPDU_RX_DONE notification must be preceded by an RX_PHY one.
2931 */
2932static void
2933iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
2934 struct iwn_rx_data *data)
2935{
2936 struct iwn_ops *ops = &sc->ops;
2970 struct ifnet *ifp = sc->sc_ifp;
2971 struct ieee80211com *ic = ifp->if_l2com;
2937 struct ieee80211com *ic = &sc->sc_ic;
2972 struct iwn_rx_ring *ring = &sc->rxq;
2973 struct ieee80211_frame *wh;
2974 struct ieee80211_node *ni;
2975 struct mbuf *m, *m1;
2976 struct iwn_rx_stat *stat;
2977 caddr_t head;
2978 bus_addr_t paddr;
2979 uint32_t flags;

--- 30 unchanged lines hidden (view full) ---

3010 }
3011
3012 flags = le32toh(*(uint32_t *)(head + len));
3013
3014 /* Discard frames with a bad FCS early. */
3015 if ((flags & IWN_RX_NOERROR) != IWN_RX_NOERROR) {
3016 DPRINTF(sc, IWN_DEBUG_RECV, "%s: RX flags error %x\n",
3017 __func__, flags);
2938 struct iwn_rx_ring *ring = &sc->rxq;
2939 struct ieee80211_frame *wh;
2940 struct ieee80211_node *ni;
2941 struct mbuf *m, *m1;
2942 struct iwn_rx_stat *stat;
2943 caddr_t head;
2944 bus_addr_t paddr;
2945 uint32_t flags;

--- 30 unchanged lines hidden (view full) ---

2976 }
2977
2978 flags = le32toh(*(uint32_t *)(head + len));
2979
2980 /* Discard frames with a bad FCS early. */
2981 if ((flags & IWN_RX_NOERROR) != IWN_RX_NOERROR) {
2982 DPRINTF(sc, IWN_DEBUG_RECV, "%s: RX flags error %x\n",
2983 __func__, flags);
3018 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
2984 counter_u64_add(ic->ic_ierrors, 1);
3019 return;
3020 }
3021 /* Discard frames that are too short. */
3022 if (len < sizeof (struct ieee80211_frame_ack)) {
3023 DPRINTF(sc, IWN_DEBUG_RECV, "%s: frame too short: %d\n",
3024 __func__, len);
2985 return;
2986 }
2987 /* Discard frames that are too short. */
2988 if (len < sizeof (struct ieee80211_frame_ack)) {
2989 DPRINTF(sc, IWN_DEBUG_RECV, "%s: frame too short: %d\n",
2990 __func__, len);
3025 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
2991 counter_u64_add(ic->ic_ierrors, 1);
3026 return;
3027 }
3028
3029 m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, IWN_RBUF_SIZE);
3030 if (m1 == NULL) {
3031 DPRINTF(sc, IWN_DEBUG_ANY, "%s: no mbuf to restock ring\n",
3032 __func__);
2992 return;
2993 }
2994
2995 m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, IWN_RBUF_SIZE);
2996 if (m1 == NULL) {
2997 DPRINTF(sc, IWN_DEBUG_ANY, "%s: no mbuf to restock ring\n",
2998 __func__);
3033 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
2999 counter_u64_add(ic->ic_ierrors, 1);
3034 return;
3035 }
3036 bus_dmamap_unload(ring->data_dmat, data->map);
3037
3038 error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *),
3039 IWN_RBUF_SIZE, iwn_dma_map_addr, &paddr, BUS_DMA_NOWAIT);
3040 if (error != 0 && error != EFBIG) {
3041 device_printf(sc->sc_dev,

--- 6 unchanged lines hidden (view full) ---

3048 &paddr, BUS_DMA_NOWAIT);
3049 if (error != 0 && error != EFBIG) {
3050 panic("%s: could not load old RX mbuf", __func__);
3051 }
3052 /* Physical address may have changed. */
3053 ring->desc[ring->cur] = htole32(paddr >> 8);
3054 bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map,
3055 BUS_DMASYNC_PREWRITE);
3000 return;
3001 }
3002 bus_dmamap_unload(ring->data_dmat, data->map);
3003
3004 error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *),
3005 IWN_RBUF_SIZE, iwn_dma_map_addr, &paddr, BUS_DMA_NOWAIT);
3006 if (error != 0 && error != EFBIG) {
3007 device_printf(sc->sc_dev,

--- 6 unchanged lines hidden (view full) ---

3014 &paddr, BUS_DMA_NOWAIT);
3015 if (error != 0 && error != EFBIG) {
3016 panic("%s: could not load old RX mbuf", __func__);
3017 }
3018 /* Physical address may have changed. */
3019 ring->desc[ring->cur] = htole32(paddr >> 8);
3020 bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map,
3021 BUS_DMASYNC_PREWRITE);
3056 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
3022 counter_u64_add(ic->ic_ierrors, 1);
3057 return;
3058 }
3059
3060 m = data->m;
3061 data->m = m1;
3062 /* Update RX descriptor. */
3063 ring->desc[ring->cur] = htole32(paddr >> 8);
3064 bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
3065 BUS_DMASYNC_PREWRITE);
3066
3067 /* Finalize mbuf. */
3023 return;
3024 }
3025
3026 m = data->m;
3027 data->m = m1;
3028 /* Update RX descriptor. */
3029 ring->desc[ring->cur] = htole32(paddr >> 8);
3030 bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
3031 BUS_DMASYNC_PREWRITE);
3032
3033 /* Finalize mbuf. */
3068 m->m_pkthdr.rcvif = ifp;
3069 m->m_data = head;
3070 m->m_pkthdr.len = m->m_len = len;
3071
3072 /* Grab a reference to the source node. */
3073 wh = mtod(m, struct ieee80211_frame *);
3074 if (len >= sizeof(struct ieee80211_frame_min))
3075 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);
3076 else

--- 77 unchanged lines hidden (view full) ---

3154}
3155
3156/* Process an incoming Compressed BlockAck. */
3157static void
3158iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc,
3159 struct iwn_rx_data *data)
3160{
3161 struct iwn_ops *ops = &sc->ops;
3034 m->m_data = head;
3035 m->m_pkthdr.len = m->m_len = len;
3036
3037 /* Grab a reference to the source node. */
3038 wh = mtod(m, struct ieee80211_frame *);
3039 if (len >= sizeof(struct ieee80211_frame_min))
3040 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);
3041 else

--- 77 unchanged lines hidden (view full) ---

3119}
3120
3121/* Process an incoming Compressed BlockAck. */
3122static void
3123iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc,
3124 struct iwn_rx_data *data)
3125{
3126 struct iwn_ops *ops = &sc->ops;
3162 struct ifnet *ifp = sc->sc_ifp;
3163 struct iwn_node *wn;
3164 struct ieee80211_node *ni;
3165 struct iwn_compressed_ba *ba = (struct iwn_compressed_ba *)(desc + 1);
3166 struct iwn_tx_ring *txq;
3167 struct iwn_tx_data *txdata;
3168 struct ieee80211_tx_ampdu *tap;
3169 struct mbuf *m;
3170 uint64_t bitmap;

--- 64 unchanged lines hidden (view full) ---

3235 *
3236 * Yes, the rate control code doesn't know these are A-MPDU
3237 * subframes and that it's okay to fail some of these.
3238 */
3239 ni = tap->txa_ni;
3240 bitmap = (le64toh(ba->bitmap) >> shift) & wn->agg[tid].bitmap;
3241 for (i = 0; bitmap; i++) {
3242 if ((bitmap & 1) == 0) {
3127 struct iwn_node *wn;
3128 struct ieee80211_node *ni;
3129 struct iwn_compressed_ba *ba = (struct iwn_compressed_ba *)(desc + 1);
3130 struct iwn_tx_ring *txq;
3131 struct iwn_tx_data *txdata;
3132 struct ieee80211_tx_ampdu *tap;
3133 struct mbuf *m;
3134 uint64_t bitmap;

--- 64 unchanged lines hidden (view full) ---

3199 *
3200 * Yes, the rate control code doesn't know these are A-MPDU
3201 * subframes and that it's okay to fail some of these.
3202 */
3203 ni = tap->txa_ni;
3204 bitmap = (le64toh(ba->bitmap) >> shift) & wn->agg[tid].bitmap;
3205 for (i = 0; bitmap; i++) {
3206 if ((bitmap & 1) == 0) {
3243 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
3244 tx_err ++;
3245 ieee80211_ratectl_tx_complete(ni->ni_vap, ni,
3246 IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL);
3247 } else {
3207 tx_err ++;
3208 ieee80211_ratectl_tx_complete(ni->ni_vap, ni,
3209 IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL);
3210 } else {
3248 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
3249 tx_ok ++;
3250 ieee80211_ratectl_tx_complete(ni->ni_vap, ni,
3251 IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL);
3252 }
3253 bitmap >>= 1;
3254 }
3255
3256 DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT,

--- 129 unchanged lines hidden (view full) ---

3386 * Process an RX_STATISTICS or BEACON_STATISTICS firmware notification.
3387 * The latter is sent by the firmware after each received beacon.
3388 */
3389static void
3390iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc,
3391 struct iwn_rx_data *data)
3392{
3393 struct iwn_ops *ops = &sc->ops;
3211 tx_ok ++;
3212 ieee80211_ratectl_tx_complete(ni->ni_vap, ni,
3213 IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL);
3214 }
3215 bitmap >>= 1;
3216 }
3217
3218 DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT,

--- 129 unchanged lines hidden (view full) ---

3348 * Process an RX_STATISTICS or BEACON_STATISTICS firmware notification.
3349 * The latter is sent by the firmware after each received beacon.
3350 */
3351static void
3352iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc,
3353 struct iwn_rx_data *data)
3354{
3355 struct iwn_ops *ops = &sc->ops;
3394 struct ifnet *ifp = sc->sc_ifp;
3395 struct ieee80211com *ic = ifp->if_l2com;
3356 struct ieee80211com *ic = &sc->sc_ic;
3396 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3397 struct iwn_calib_state *calib = &sc->calib;
3398 struct iwn_stats *stats = (struct iwn_stats *)(desc + 1);
3399 struct iwn_stats *lstats;
3400 int temp;
3401
3402 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
3403

--- 156 unchanged lines hidden (view full) ---

3560
3561/*
3562 * Adapter-independent backend for TX_DONE firmware notifications.
3563 */
3564static void
3565iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt,
3566 uint8_t status)
3567{
3357 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3358 struct iwn_calib_state *calib = &sc->calib;
3359 struct iwn_stats *stats = (struct iwn_stats *)(desc + 1);
3360 struct iwn_stats *lstats;
3361 int temp;
3362
3363 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
3364

--- 156 unchanged lines hidden (view full) ---

3521
3522/*
3523 * Adapter-independent backend for TX_DONE firmware notifications.
3524 */
3525static void
3526iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt,
3527 uint8_t status)
3528{
3568 struct ifnet *ifp = sc->sc_ifp;
3569 struct iwn_tx_ring *ring = &sc->txq[desc->qid & 0xf];
3570 struct iwn_tx_data *data = &ring->data[desc->idx];
3571 struct mbuf *m;
3572 struct ieee80211_node *ni;
3573 struct ieee80211vap *vap;
3574
3575 KASSERT(data->ni != NULL, ("no node"));
3576

--- 4 unchanged lines hidden (view full) ---

3581 bus_dmamap_unload(ring->data_dmat, data->map);
3582 m = data->m, data->m = NULL;
3583 ni = data->ni, data->ni = NULL;
3584 vap = ni->ni_vap;
3585
3586 /*
3587 * Update rate control statistics for the node.
3588 */
3529 struct iwn_tx_ring *ring = &sc->txq[desc->qid & 0xf];
3530 struct iwn_tx_data *data = &ring->data[desc->idx];
3531 struct mbuf *m;
3532 struct ieee80211_node *ni;
3533 struct ieee80211vap *vap;
3534
3535 KASSERT(data->ni != NULL, ("no node"));
3536

--- 4 unchanged lines hidden (view full) ---

3541 bus_dmamap_unload(ring->data_dmat, data->map);
3542 m = data->m, data->m = NULL;
3543 ni = data->ni, data->ni = NULL;
3544 vap = ni->ni_vap;
3545
3546 /*
3547 * Update rate control statistics for the node.
3548 */
3589 if (status & IWN_TX_FAIL) {
3590 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
3549 if (status & IWN_TX_FAIL)
3591 ieee80211_ratectl_tx_complete(vap, ni,
3592 IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL);
3550 ieee80211_ratectl_tx_complete(vap, ni,
3551 IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL);
3593 } else {
3594 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
3552 else
3595 ieee80211_ratectl_tx_complete(vap, ni,
3596 IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL);
3553 ieee80211_ratectl_tx_complete(vap, ni,
3554 IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL);
3597 }
3598
3599 /*
3600 * Channels marked for "radar" require traffic to be received
3601 * to unlock before we can transmit. Until traffic is seen
3602 * any attempt to transmit is returned immediately with status
3603 * set to IWN_TX_FAIL_TX_LOCKED. Unfortunately this can easily
3604 * happen on first authenticate after scanning. To workaround
3605 * this we ignore a failure of this sort in AUTH state so the

--- 9 unchanged lines hidden (view full) ---

3615 ieee80211_tx_complete(ni, m, 0);
3616 else
3617 ieee80211_tx_complete(ni, m,
3618 (status & IWN_TX_FAIL) != 0);
3619
3620 sc->sc_tx_timer = 0;
3621 if (--ring->queued < IWN_TX_RING_LOMARK) {
3622 sc->qfullmsk &= ~(1 << ring->qid);
3555
3556 /*
3557 * Channels marked for "radar" require traffic to be received
3558 * to unlock before we can transmit. Until traffic is seen
3559 * any attempt to transmit is returned immediately with status
3560 * set to IWN_TX_FAIL_TX_LOCKED. Unfortunately this can easily
3561 * happen on first authenticate after scanning. To workaround
3562 * this we ignore a failure of this sort in AUTH state so the

--- 9 unchanged lines hidden (view full) ---

3572 ieee80211_tx_complete(ni, m, 0);
3573 else
3574 ieee80211_tx_complete(ni, m,
3575 (status & IWN_TX_FAIL) != 0);
3576
3577 sc->sc_tx_timer = 0;
3578 if (--ring->queued < IWN_TX_RING_LOMARK) {
3579 sc->qfullmsk &= ~(1 << ring->qid);
3623 if (sc->qfullmsk == 0 &&
3624 (ifp->if_drv_flags & IFF_DRV_OACTIVE)) {
3625 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
3626 iwn_start_locked(ifp);
3627 }
3580 if (sc->qfullmsk == 0)
3581 iwn_start_locked(sc);
3628 }
3629
3630 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__);
3631
3632}
3633
3634/*
3635 * Process a "command done" firmware notification. This is where we wakeup

--- 28 unchanged lines hidden (view full) ---

3664 wakeup(&ring->desc[desc->idx]);
3665}
3666
3667static void
3668iwn_ampdu_tx_done(struct iwn_softc *sc, int qid, int idx, int nframes,
3669 int ackfailcnt, void *stat)
3670{
3671 struct iwn_ops *ops = &sc->ops;
3582 }
3583
3584 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__);
3585
3586}
3587
3588/*
3589 * Process a "command done" firmware notification. This is where we wakeup

--- 28 unchanged lines hidden (view full) ---

3618 wakeup(&ring->desc[desc->idx]);
3619}
3620
3621static void
3622iwn_ampdu_tx_done(struct iwn_softc *sc, int qid, int idx, int nframes,
3623 int ackfailcnt, void *stat)
3624{
3625 struct iwn_ops *ops = &sc->ops;
3672 struct ifnet *ifp = sc->sc_ifp;
3673 struct iwn_tx_ring *ring = &sc->txq[qid];
3674 struct iwn_tx_data *data;
3675 struct mbuf *m;
3676 struct iwn_node *wn;
3677 struct ieee80211_node *ni;
3678 struct ieee80211_tx_ampdu *tap;
3679 uint64_t bitmap;
3680 uint32_t *status = stat;

--- 122 unchanged lines hidden (view full) ---

3803 sc->qid2tap[qid] = NULL;
3804 free(res, M_DEVBUF);
3805 return;
3806 }
3807
3808 sc->sc_tx_timer = 0;
3809 if (ring->queued < IWN_TX_RING_LOMARK) {
3810 sc->qfullmsk &= ~(1 << ring->qid);
3626 struct iwn_tx_ring *ring = &sc->txq[qid];
3627 struct iwn_tx_data *data;
3628 struct mbuf *m;
3629 struct iwn_node *wn;
3630 struct ieee80211_node *ni;
3631 struct ieee80211_tx_ampdu *tap;
3632 uint64_t bitmap;
3633 uint32_t *status = stat;

--- 122 unchanged lines hidden (view full) ---

3756 sc->qid2tap[qid] = NULL;
3757 free(res, M_DEVBUF);
3758 return;
3759 }
3760
3761 sc->sc_tx_timer = 0;
3762 if (ring->queued < IWN_TX_RING_LOMARK) {
3763 sc->qfullmsk &= ~(1 << ring->qid);
3811 if (sc->qfullmsk == 0 &&
3812 (ifp->if_drv_flags & IFF_DRV_OACTIVE)) {
3813 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
3814 iwn_start_locked(ifp);
3815 }
3764 if (sc->qfullmsk == 0)
3765 iwn_start_locked(sc);
3816 }
3817
3818 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__);
3819
3820}
3821
3822/*
3823 * Process an INT_FH_RX or INT_SW_RX interrupt.
3824 */
3825static void
3826iwn_notif_intr(struct iwn_softc *sc)
3827{
3828 struct iwn_ops *ops = &sc->ops;
3766 }
3767
3768 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__);
3769
3770}
3771
3772/*
3773 * Process an INT_FH_RX or INT_SW_RX interrupt.
3774 */
3775static void
3776iwn_notif_intr(struct iwn_softc *sc)
3777{
3778 struct iwn_ops *ops = &sc->ops;
3829 struct ifnet *ifp = sc->sc_ifp;
3830 struct ieee80211com *ic = ifp->if_l2com;
3779 struct ieee80211com *ic = &sc->sc_ic;
3831 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3832 uint16_t hw;
3833
3834 bus_dmamap_sync(sc->rxq.stat_dma.tag, sc->rxq.stat_dma.map,
3835 BUS_DMASYNC_POSTREAD);
3836
3837 hw = le16toh(sc->rxq.stat->closed_count) & 0xfff;
3838 while (sc->rxq.cur != hw) {

--- 177 unchanged lines hidden (view full) ---

4016 struct iwn_tx_ring *ring = &sc->txq[qid];
4017 IWN_WRITE(sc, IWN_HBUS_TARG_WRPTR, qid << 8 | ring->cur);
4018 }
4019}
4020
4021static void
4022iwn_rftoggle_intr(struct iwn_softc *sc)
4023{
3780 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3781 uint16_t hw;
3782
3783 bus_dmamap_sync(sc->rxq.stat_dma.tag, sc->rxq.stat_dma.map,
3784 BUS_DMASYNC_POSTREAD);
3785
3786 hw = le16toh(sc->rxq.stat->closed_count) & 0xfff;
3787 while (sc->rxq.cur != hw) {

--- 177 unchanged lines hidden (view full) ---

3965 struct iwn_tx_ring *ring = &sc->txq[qid];
3966 IWN_WRITE(sc, IWN_HBUS_TARG_WRPTR, qid << 8 | ring->cur);
3967 }
3968}
3969
3970static void
3971iwn_rftoggle_intr(struct iwn_softc *sc)
3972{
4024 struct ifnet *ifp = sc->sc_ifp;
4025 struct ieee80211com *ic = ifp->if_l2com;
3973 struct ieee80211com *ic = &sc->sc_ic;
4026 uint32_t tmp = IWN_READ(sc, IWN_GP_CNTRL);
4027
4028 IWN_LOCK_ASSERT(sc);
4029
4030 device_printf(sc->sc_dev, "RF switch: radio %s\n",
4031 (tmp & IWN_GP_CNTRL_RFKILL) ? "enabled" : "disabled");
4032 if (tmp & IWN_GP_CNTRL_RFKILL)
4033 ieee80211_runtask(ic, &sc->sc_radioon_task);

--- 62 unchanged lines hidden (view full) ---

4096 }
4097 printf(" rx ring: cur=%d\n", sc->rxq.cur);
4098}
4099
4100static void
4101iwn_intr(void *arg)
4102{
4103 struct iwn_softc *sc = arg;
3974 uint32_t tmp = IWN_READ(sc, IWN_GP_CNTRL);
3975
3976 IWN_LOCK_ASSERT(sc);
3977
3978 device_printf(sc->sc_dev, "RF switch: radio %s\n",
3979 (tmp & IWN_GP_CNTRL_RFKILL) ? "enabled" : "disabled");
3980 if (tmp & IWN_GP_CNTRL_RFKILL)
3981 ieee80211_runtask(ic, &sc->sc_radioon_task);

--- 62 unchanged lines hidden (view full) ---

4044 }
4045 printf(" rx ring: cur=%d\n", sc->rxq.cur);
4046}
4047
4048static void
4049iwn_intr(void *arg)
4050{
4051 struct iwn_softc *sc = arg;
4104 struct ifnet *ifp = sc->sc_ifp;
4105 uint32_t r1, r2, tmp;
4106
4107 IWN_LOCK(sc);
4108
4109 /* Disable interrupts. */
4110 IWN_WRITE(sc, IWN_INT_MASK, 0);
4111
4112 /* Read interrupts from ICT (fast) or from registers (slow). */

--- 76 unchanged lines hidden (view full) ---

4189 if (r1 & IWN_INT_ALIVE)
4190 wakeup(sc); /* Firmware is alive. */
4191
4192 if (r1 & IWN_INT_WAKEUP)
4193 iwn_wakeup_intr(sc);
4194
4195done:
4196 /* Re-enable interrupts. */
4052 uint32_t r1, r2, tmp;
4053
4054 IWN_LOCK(sc);
4055
4056 /* Disable interrupts. */
4057 IWN_WRITE(sc, IWN_INT_MASK, 0);
4058
4059 /* Read interrupts from ICT (fast) or from registers (slow). */

--- 76 unchanged lines hidden (view full) ---

4136 if (r1 & IWN_INT_ALIVE)
4137 wakeup(sc); /* Firmware is alive. */
4138
4139 if (r1 & IWN_INT_WAKEUP)
4140 iwn_wakeup_intr(sc);
4141
4142done:
4143 /* Re-enable interrupts. */
4197 if (ifp->if_flags & IFF_UP)
4144 if (sc->sc_flags & IWN_FLAG_RUNNING)
4198 IWN_WRITE(sc, IWN_INT_MASK, sc->int_mask);
4199
4200 IWN_UNLOCK(sc);
4201}
4202
4203/*
4204 * Update TX scheduler ring when transmitting an 802.11 frame (4965AGN and
4205 * 5000 adapters use a slightly different format).

--- 467 unchanged lines hidden (view full) ---

4673 return 0;
4674}
4675
4676static int
4677iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m,
4678 struct ieee80211_node *ni, const struct ieee80211_bpf_params *params)
4679{
4680 struct iwn_ops *ops = &sc->ops;
4145 IWN_WRITE(sc, IWN_INT_MASK, sc->int_mask);
4146
4147 IWN_UNLOCK(sc);
4148}
4149
4150/*
4151 * Update TX scheduler ring when transmitting an 802.11 frame (4965AGN and
4152 * 5000 adapters use a slightly different format).

--- 467 unchanged lines hidden (view full) ---

4620 return 0;
4621}
4622
4623static int
4624iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m,
4625 struct ieee80211_node *ni, const struct ieee80211_bpf_params *params)
4626{
4627 struct iwn_ops *ops = &sc->ops;
4681// struct ifnet *ifp = sc->sc_ifp;
4682 struct ieee80211vap *vap = ni->ni_vap;
4628 struct ieee80211vap *vap = ni->ni_vap;
4683// struct ieee80211com *ic = ifp->if_l2com;
4684 struct iwn_tx_cmd *cmd;
4685 struct iwn_cmd_data *tx;
4686 struct ieee80211_frame *wh;
4687 struct iwn_tx_ring *ring;
4688 struct iwn_tx_desc *desc;
4689 struct iwn_tx_data *data;
4690 struct mbuf *m1;
4691 bus_dma_segment_t *seg, segs[IWN_MAX_SCATTER];

--- 178 unchanged lines hidden (view full) ---

4870
4871 return 0;
4872}
4873
4874static void
4875iwn_xmit_task(void *arg0, int pending)
4876{
4877 struct iwn_softc *sc = arg0;
4629 struct iwn_tx_cmd *cmd;
4630 struct iwn_cmd_data *tx;
4631 struct ieee80211_frame *wh;
4632 struct iwn_tx_ring *ring;
4633 struct iwn_tx_desc *desc;
4634 struct iwn_tx_data *data;
4635 struct mbuf *m1;
4636 bus_dma_segment_t *seg, segs[IWN_MAX_SCATTER];

--- 178 unchanged lines hidden (view full) ---

4815
4816 return 0;
4817}
4818
4819static void
4820iwn_xmit_task(void *arg0, int pending)
4821{
4822 struct iwn_softc *sc = arg0;
4878 struct ifnet *ifp = sc->sc_ifp;
4879 struct ieee80211_node *ni;
4880 struct mbuf *m;
4881 int error;
4882 struct ieee80211_bpf_params p;
4883 int have_p;
4884
4885 DPRINTF(sc, IWN_DEBUG_XMIT, "%s: called\n", __func__);
4886

--- 15 unchanged lines hidden (view full) ---

4902
4903 /* If we have xmit params, use them */
4904 if (have_p)
4905 error = iwn_tx_data_raw(sc, m, ni, &p);
4906 else
4907 error = iwn_tx_data(sc, m, ni);
4908
4909 if (error != 0) {
4823 struct ieee80211_node *ni;
4824 struct mbuf *m;
4825 int error;
4826 struct ieee80211_bpf_params p;
4827 int have_p;
4828
4829 DPRINTF(sc, IWN_DEBUG_XMIT, "%s: called\n", __func__);
4830

--- 15 unchanged lines hidden (view full) ---

4846
4847 /* If we have xmit params, use them */
4848 if (have_p)
4849 error = iwn_tx_data_raw(sc, m, ni, &p);
4850 else
4851 error = iwn_tx_data(sc, m, ni);
4852
4853 if (error != 0) {
4854 if_inc_counter(ni->ni_vap->iv_ifp,
4855 IFCOUNTER_OERRORS, 1);
4910 ieee80211_free_node(ni);
4856 ieee80211_free_node(ni);
4911 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
4912 }
4913 }
4914
4915 sc->sc_beacon_wait = 0;
4916 IWN_UNLOCK(sc);
4917}
4918
4919static int
4920iwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
4921 const struct ieee80211_bpf_params *params)
4922{
4923 struct ieee80211com *ic = ni->ni_ic;
4857 }
4858 }
4859
4860 sc->sc_beacon_wait = 0;
4861 IWN_UNLOCK(sc);
4862}
4863
4864static int
4865iwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
4866 const struct ieee80211_bpf_params *params)
4867{
4868 struct ieee80211com *ic = ni->ni_ic;
4924 struct ifnet *ifp = ic->ic_ifp;
4925 struct iwn_softc *sc = ifp->if_softc;
4869 struct iwn_softc *sc = ic->ic_softc;
4926 int error = 0;
4927
4928 DPRINTF(sc, IWN_DEBUG_XMIT | IWN_DEBUG_TRACE, "->%s begin\n", __func__);
4929
4870 int error = 0;
4871
4872 DPRINTF(sc, IWN_DEBUG_XMIT | IWN_DEBUG_TRACE, "->%s begin\n", __func__);
4873
4930 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
4874 if ((sc->sc_flags & IWN_FLAG_RUNNING) == 0) {
4931 ieee80211_free_node(ni);
4932 m_freem(m);
4933 return ENETDOWN;
4934 }
4935
4936 /* XXX? net80211 doesn't set this on xmit'ed raw frames? */
4937 m->m_pkthdr.rcvif = (void *) ni;
4938
4939 IWN_LOCK(sc);
4940
4941 /* queue frame if we have to */
4942 if (sc->sc_beacon_wait) {
4943 if (iwn_xmit_queue_enqueue(sc, m) != 0) {
4944 m_freem(m);
4875 ieee80211_free_node(ni);
4876 m_freem(m);
4877 return ENETDOWN;
4878 }
4879
4880 /* XXX? net80211 doesn't set this on xmit'ed raw frames? */
4881 m->m_pkthdr.rcvif = (void *) ni;
4882
4883 IWN_LOCK(sc);
4884
4885 /* queue frame if we have to */
4886 if (sc->sc_beacon_wait) {
4887 if (iwn_xmit_queue_enqueue(sc, m) != 0) {
4888 m_freem(m);
4889 if_inc_counter(ni->ni_vap->iv_ifp,
4890 IFCOUNTER_OERRORS, 1);
4945 ieee80211_free_node(ni);
4891 ieee80211_free_node(ni);
4946 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
4947 IWN_UNLOCK(sc);
4948 return (ENOBUFS);
4949 }
4950 /* Queued, so just return OK */
4951 IWN_UNLOCK(sc);
4952 return (0);
4953 }
4954

--- 8 unchanged lines hidden (view full) ---

4963 * Caller supplied explicit parameters to use in
4964 * sending the frame.
4965 */
4966 error = iwn_tx_data_raw(sc, m, ni, params);
4967 }
4968 if (error != 0) {
4969 /* NB: m is reclaimed on tx failure */
4970 ieee80211_free_node(ni);
4892 IWN_UNLOCK(sc);
4893 return (ENOBUFS);
4894 }
4895 /* Queued, so just return OK */
4896 IWN_UNLOCK(sc);
4897 return (0);
4898 }
4899

--- 8 unchanged lines hidden (view full) ---

4908 * Caller supplied explicit parameters to use in
4909 * sending the frame.
4910 */
4911 error = iwn_tx_data_raw(sc, m, ni, params);
4912 }
4913 if (error != 0) {
4914 /* NB: m is reclaimed on tx failure */
4915 ieee80211_free_node(ni);
4971 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
4972 } else
4973 sc->sc_tx_timer = 5;
4974
4975 IWN_UNLOCK(sc);
4976
4977 DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT, "->%s: end\n",__func__);
4978
4979 return error;
4980}
4981
4916 } else
4917 sc->sc_tx_timer = 5;
4918
4919 IWN_UNLOCK(sc);
4920
4921 DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT, "->%s: end\n",__func__);
4922
4923 return error;
4924}
4925
4982static void
4983iwn_start(struct ifnet *ifp)
4926static int
4927iwn_transmit(struct ieee80211com *ic, struct mbuf *m)
4984{
4928{
4985 struct iwn_softc *sc = ifp->if_softc;
4929 struct iwn_softc *sc;
4930 int error;
4986
4931
4932 sc = ic->ic_softc;
4933
4987 IWN_LOCK(sc);
4934 IWN_LOCK(sc);
4988 iwn_start_locked(ifp);
4935 if ((sc->sc_flags & IWN_FLAG_RUNNING) == 0) {
4936 IWN_UNLOCK(sc);
4937 return (ENXIO);
4938 }
4939 error = mbufq_enqueue(&sc->sc_snd, m);
4940 if (error) {
4941 IWN_UNLOCK(sc);
4942 return (error);
4943 }
4944 iwn_start_locked(sc);
4989 IWN_UNLOCK(sc);
4945 IWN_UNLOCK(sc);
4946 return (0);
4990}
4991
4992static void
4947}
4948
4949static void
4993iwn_start_locked(struct ifnet *ifp)
4950iwn_start_locked(struct iwn_softc *sc)
4994{
4951{
4995 struct iwn_softc *sc = ifp->if_softc;
4996 struct ieee80211_node *ni;
4997 struct mbuf *m;
4998
4999 IWN_LOCK_ASSERT(sc);
5000
5001 /*
5002 * If we're waiting for a beacon, we can just exit out here
5003 * and wait for the taskqueue to be kicked.
5004 */
5005 if (sc->sc_beacon_wait) {
5006 return;
5007 }
5008
5009 DPRINTF(sc, IWN_DEBUG_XMIT, "%s: called\n", __func__);
4952 struct ieee80211_node *ni;
4953 struct mbuf *m;
4954
4955 IWN_LOCK_ASSERT(sc);
4956
4957 /*
4958 * If we're waiting for a beacon, we can just exit out here
4959 * and wait for the taskqueue to be kicked.
4960 */
4961 if (sc->sc_beacon_wait) {
4962 return;
4963 }
4964
4965 DPRINTF(sc, IWN_DEBUG_XMIT, "%s: called\n", __func__);
5010
5011 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
5012 (ifp->if_drv_flags & IFF_DRV_OACTIVE))
5013 return;
5014
5015 for (;;) {
5016 if (sc->qfullmsk != 0) {
5017 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
5018 break;
5019 }
5020 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
5021 if (m == NULL)
5022 break;
4966 while (sc->qfullmsk == 0 &&
4967 (m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
5023 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
5024 if (iwn_tx_data(sc, m, ni) != 0) {
4968 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
4969 if (iwn_tx_data(sc, m, ni) != 0) {
4970 if_inc_counter(ni->ni_vap->iv_ifp,
4971 IFCOUNTER_OERRORS, 1);
5025 ieee80211_free_node(ni);
4972 ieee80211_free_node(ni);
5026 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
5027 } else
5028 sc->sc_tx_timer = 5;
5029 }
4973 } else
4974 sc->sc_tx_timer = 5;
4975 }
5030
5031 DPRINTF(sc, IWN_DEBUG_XMIT, "%s: done\n", __func__);
5032}
5033
5034static void
5035iwn_watchdog(void *arg)
5036{
5037 struct iwn_softc *sc = arg;
4976 DPRINTF(sc, IWN_DEBUG_XMIT, "%s: done\n", __func__);
4977}
4978
4979static void
4980iwn_watchdog(void *arg)
4981{
4982 struct iwn_softc *sc = arg;
5038 struct ifnet *ifp = sc->sc_ifp;
5039 struct ieee80211com *ic = ifp->if_l2com;
4983 struct ieee80211com *ic = &sc->sc_ic;
5040
5041 IWN_LOCK_ASSERT(sc);
5042
4984
4985 IWN_LOCK_ASSERT(sc);
4986
5043 KASSERT(ifp->if_drv_flags & IFF_DRV_RUNNING, ("not running"));
4987 KASSERT(sc->sc_flags & IWN_FLAG_RUNNING, ("not running"));
5044
5045 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
5046
5047 if (sc->sc_tx_timer > 0) {
5048 if (--sc->sc_tx_timer == 0) {
5049 ic_printf(ic, "device timeout\n");
5050 ieee80211_runtask(ic, &sc->sc_reinit_task);
5051 return;
5052 }
5053 }
5054 callout_reset(&sc->watchdog_to, hz, iwn_watchdog, sc);
5055}
5056
5057static int
4988
4989 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
4990
4991 if (sc->sc_tx_timer > 0) {
4992 if (--sc->sc_tx_timer == 0) {
4993 ic_printf(ic, "device timeout\n");
4994 ieee80211_runtask(ic, &sc->sc_reinit_task);
4995 return;
4996 }
4997 }
4998 callout_reset(&sc->watchdog_to, hz, iwn_watchdog, sc);
4999}
5000
5001static int
5058iwn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
5002iwn_ioctl(struct ieee80211com *ic, u_long cmd, void *data)
5059{
5003{
5060 struct iwn_softc *sc = ifp->if_softc;
5061 struct ieee80211com *ic = ifp->if_l2com;
5062 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
5063 struct ifreq *ifr = (struct ifreq *) data;
5064 int error = 0, startall = 0, stop = 0;
5065
5004 struct ifreq *ifr = data;
5005 struct iwn_softc *sc = ic->ic_softc;
5006 int error = 0;
5007
5066 switch (cmd) {
5008 switch (cmd) {
5067 case SIOCGIFADDR:
5068 error = ether_ioctl(ifp, cmd, data);
5069 break;
5070 case SIOCSIFFLAGS:
5071 IWN_LOCK(sc);
5072 if (ifp->if_flags & IFF_UP) {
5073 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
5074 iwn_init_locked(sc);
5075 if (IWN_READ(sc, IWN_GP_CNTRL) & IWN_GP_CNTRL_RFKILL)
5076 startall = 1;
5077 else
5078 stop = 1;
5079 }
5080 } else {
5081 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
5082 iwn_stop_locked(sc);
5083 }
5084 IWN_UNLOCK(sc);
5085 if (startall)
5086 ieee80211_start_all(ic);
5087 else if (vap != NULL && stop)
5088 ieee80211_stop(vap);
5089 break;
5090 case SIOCGIFMEDIA:
5091 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
5092 break;
5093 case SIOCGIWNSTATS:
5094 IWN_LOCK(sc);
5095 /* XXX validate permissions/memory/etc? */
5096 error = copyout(&sc->last_stat, ifr->ifr_data,
5097 sizeof(struct iwn_stats));
5098 IWN_UNLOCK(sc);
5099 break;
5100 case SIOCZIWNSTATS:
5101 IWN_LOCK(sc);
5102 memset(&sc->last_stat, 0, sizeof(struct iwn_stats));
5103 IWN_UNLOCK(sc);
5104 break;
5105 default:
5009 case SIOCGIWNSTATS:
5010 IWN_LOCK(sc);
5011 /* XXX validate permissions/memory/etc? */
5012 error = copyout(&sc->last_stat, ifr->ifr_data,
5013 sizeof(struct iwn_stats));
5014 IWN_UNLOCK(sc);
5015 break;
5016 case SIOCZIWNSTATS:
5017 IWN_LOCK(sc);
5018 memset(&sc->last_stat, 0, sizeof(struct iwn_stats));
5019 IWN_UNLOCK(sc);
5020 break;
5021 default:
5106 error = EINVAL;
5022 error = ENOTTY;
5107 break;
5108 }
5023 break;
5024 }
5109 return error;
5025 return (error);
5110}
5111
5026}
5027
5028static void
5029iwn_parent(struct ieee80211com *ic)
5030{
5031 struct iwn_softc *sc = ic->ic_softc;
5032 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
5033 int startall = 0, stop = 0;
5034
5035 IWN_LOCK(sc);
5036 if (ic->ic_nrunning > 0) {
5037 if (!(sc->sc_flags & IWN_FLAG_RUNNING)) {
5038 iwn_init_locked(sc);
5039 if (IWN_READ(sc, IWN_GP_CNTRL) & IWN_GP_CNTRL_RFKILL)
5040 startall = 1;
5041 else
5042 stop = 1;
5043 }
5044 } else if (sc->sc_flags & IWN_FLAG_RUNNING)
5045 iwn_stop_locked(sc);
5046 IWN_UNLOCK(sc);
5047 if (startall)
5048 ieee80211_start_all(ic);
5049 else if (vap != NULL && stop)
5050 ieee80211_stop(vap);
5051}
5052
5112/*
5113 * Send a command to the firmware.
5114 */
5115static int
5116iwn_cmd(struct iwn_softc *sc, int code, const void *buf, int size, int async)
5117{
5118 struct iwn_tx_ring *ring;
5119 struct iwn_tx_desc *desc;

--- 215 unchanged lines hidden (view full) ---

5335
5336/*
5337 * Broadcast node is used to send group-addressed and management frames.
5338 */
5339static int
5340iwn_add_broadcast_node(struct iwn_softc *sc, int async)
5341{
5342 struct iwn_ops *ops = &sc->ops;
5053/*
5054 * Send a command to the firmware.
5055 */
5056static int
5057iwn_cmd(struct iwn_softc *sc, int code, const void *buf, int size, int async)
5058{
5059 struct iwn_tx_ring *ring;
5060 struct iwn_tx_desc *desc;

--- 215 unchanged lines hidden (view full) ---

5276
5277/*
5278 * Broadcast node is used to send group-addressed and management frames.
5279 */
5280static int
5281iwn_add_broadcast_node(struct iwn_softc *sc, int async)
5282{
5283 struct iwn_ops *ops = &sc->ops;
5343 struct ifnet *ifp = sc->sc_ifp;
5344 struct ieee80211com *ic = ifp->if_l2com;
5284 struct ieee80211com *ic = &sc->sc_ic;
5345 struct iwn_node_info node;
5346 struct iwn_cmd_link_quality linkq;
5347 uint8_t txant;
5348 int i, error;
5349
5350 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
5351
5352 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
5353
5354 memset(&node, 0, sizeof node);
5285 struct iwn_node_info node;
5286 struct iwn_cmd_link_quality linkq;
5287 uint8_t txant;
5288 int i, error;
5289
5290 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
5291
5292 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
5293
5294 memset(&node, 0, sizeof node);
5355 IEEE80211_ADDR_COPY(node.macaddr, ifp->if_broadcastaddr);
5295 IEEE80211_ADDR_COPY(node.macaddr, ieee80211broadcastaddr);
5356 node.id = sc->broadcast_id;
5357 DPRINTF(sc, IWN_DEBUG_RESET, "%s: adding broadcast node\n", __func__);
5358 if ((error = ops->add_node(sc, &node, async)) != 0)
5359 return error;
5360
5361 /* Use the first valid TX antenna. */
5362 txant = IWN_LSB(sc->txchainmask);
5363

--- 132 unchanged lines hidden (view full) ---

5496 ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod));
5497
5498 return iwn_cmd(sc, IWN_CMD_TIMING, &cmd, sizeof cmd, 1);
5499}
5500
5501static void
5502iwn4965_power_calibration(struct iwn_softc *sc, int temp)
5503{
5296 node.id = sc->broadcast_id;
5297 DPRINTF(sc, IWN_DEBUG_RESET, "%s: adding broadcast node\n", __func__);
5298 if ((error = ops->add_node(sc, &node, async)) != 0)
5299 return error;
5300
5301 /* Use the first valid TX antenna. */
5302 txant = IWN_LSB(sc->txchainmask);
5303

--- 132 unchanged lines hidden (view full) ---

5436 ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod));
5437
5438 return iwn_cmd(sc, IWN_CMD_TIMING, &cmd, sizeof cmd, 1);
5439}
5440
5441static void
5442iwn4965_power_calibration(struct iwn_softc *sc, int temp)
5443{
5504 struct ifnet *ifp = sc->sc_ifp;
5505 struct ieee80211com *ic = ifp->if_l2com;
5444 struct ieee80211com *ic = &sc->sc_ic;
5506
5507 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
5508
5509 /* Adjust TX power if need be (delta >= 3 degC). */
5510 DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: temperature %d->%d\n",
5511 __func__, sc->temp, temp);
5512 if (abs(temp - sc->temp) >= 3) {
5513 /* Record temperature of last calibration. */

--- 353 unchanged lines hidden (view full) ---

5867 * to set differential gains.
5868 */
5869static void
5870iwn_collect_noise(struct iwn_softc *sc,
5871 const struct iwn_rx_general_stats *stats)
5872{
5873 struct iwn_ops *ops = &sc->ops;
5874 struct iwn_calib_state *calib = &sc->calib;
5445
5446 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
5447
5448 /* Adjust TX power if need be (delta >= 3 degC). */
5449 DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: temperature %d->%d\n",
5450 __func__, sc->temp, temp);
5451 if (abs(temp - sc->temp) >= 3) {
5452 /* Record temperature of last calibration. */

--- 353 unchanged lines hidden (view full) ---

5806 * to set differential gains.
5807 */
5808static void
5809iwn_collect_noise(struct iwn_softc *sc,
5810 const struct iwn_rx_general_stats *stats)
5811{
5812 struct iwn_ops *ops = &sc->ops;
5813 struct iwn_calib_state *calib = &sc->calib;
5875 struct ifnet *ifp = sc->sc_ifp;
5876 struct ieee80211com *ic = ifp->if_l2com;
5814 struct ieee80211com *ic = &sc->sc_ic;
5877 uint32_t val;
5878 int i;
5879
5880 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
5881
5882 /* Accumulate RSSI and noise for all 3 antennas. */
5883 for (i = 0; i < 3; i++) {
5884 calib->rssi[i] += le32toh(stats->rssi[i]) & 0xff;

--- 616 unchanged lines hidden (view full) ---

6501 DPRINTF(sc, IWN_DEBUG_CALIBRATE,
6502 "%s: configuring runtime calibration\n", __func__);
6503 return iwn_cmd(sc, IWN5000_CMD_CALIB_CONFIG, &cmd, sizeof(cmd), 0);
6504}
6505
6506static uint32_t
6507iwn_get_rxon_ht_flags(struct iwn_softc *sc, struct ieee80211_channel *c)
6508{
5815 uint32_t val;
5816 int i;
5817
5818 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
5819
5820 /* Accumulate RSSI and noise for all 3 antennas. */
5821 for (i = 0; i < 3; i++) {
5822 calib->rssi[i] += le32toh(stats->rssi[i]) & 0xff;

--- 616 unchanged lines hidden (view full) ---

6439 DPRINTF(sc, IWN_DEBUG_CALIBRATE,
6440 "%s: configuring runtime calibration\n", __func__);
6441 return iwn_cmd(sc, IWN5000_CMD_CALIB_CONFIG, &cmd, sizeof(cmd), 0);
6442}
6443
6444static uint32_t
6445iwn_get_rxon_ht_flags(struct iwn_softc *sc, struct ieee80211_channel *c)
6446{
6447 struct ieee80211com *ic = &sc->sc_ic;
6509 uint32_t htflags = 0;
6448 uint32_t htflags = 0;
6510 struct ifnet *ifp = sc->sc_ifp;
6511 struct ieee80211com *ic = ifp->if_l2com;
6512
6513 if (! IEEE80211_IS_CHAN_HT(c))
6514 return (0);
6515
6516 htflags |= IWN_RXON_HT_PROTMODE(ic->ic_curhtprotmode);
6517
6518 if (IEEE80211_IS_CHAN_HT40(c)) {
6519 switch (ic->ic_curhtprotmode) {

--- 10 unchanged lines hidden (view full) ---

6530
6531 return (htflags);
6532}
6533
6534static int
6535iwn_config(struct iwn_softc *sc)
6536{
6537 struct iwn_ops *ops = &sc->ops;
6449
6450 if (! IEEE80211_IS_CHAN_HT(c))
6451 return (0);
6452
6453 htflags |= IWN_RXON_HT_PROTMODE(ic->ic_curhtprotmode);
6454
6455 if (IEEE80211_IS_CHAN_HT40(c)) {
6456 switch (ic->ic_curhtprotmode) {

--- 10 unchanged lines hidden (view full) ---

6467
6468 return (htflags);
6469}
6470
6471static int
6472iwn_config(struct iwn_softc *sc)
6473{
6474 struct iwn_ops *ops = &sc->ops;
6538 struct ifnet *ifp = sc->sc_ifp;
6539 struct ieee80211com *ic = ifp->if_l2com;
6475 struct ieee80211com *ic = &sc->sc_ic;
6476 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
6477 const uint8_t *macaddr;
6540 uint32_t txmask;
6541 uint16_t rxchain;
6542 int error;
6543
6544 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
6545
6546 if ((sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET)
6547 && (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2)) {

--- 65 unchanged lines hidden (view full) ---

6613 "%s: could not configure bluetooth coexistence, error %d\n",
6614 __func__, error);
6615 return error;
6616 }
6617
6618 /* Set mode, channel, RX filter and enable RX. */
6619 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
6620 memset(sc->rxon, 0, sizeof (struct iwn_rxon));
6478 uint32_t txmask;
6479 uint16_t rxchain;
6480 int error;
6481
6482 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
6483
6484 if ((sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET)
6485 && (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2)) {

--- 65 unchanged lines hidden (view full) ---

6551 "%s: could not configure bluetooth coexistence, error %d\n",
6552 __func__, error);
6553 return error;
6554 }
6555
6556 /* Set mode, channel, RX filter and enable RX. */
6557 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
6558 memset(sc->rxon, 0, sizeof (struct iwn_rxon));
6621 IEEE80211_ADDR_COPY(sc->rxon->myaddr, IF_LLADDR(ifp));
6622 IEEE80211_ADDR_COPY(sc->rxon->wlap, IF_LLADDR(ifp));
6559 macaddr = vap ? vap->iv_myaddr : ic->ic_macaddr;
6560 IEEE80211_ADDR_COPY(sc->rxon->myaddr, macaddr);
6561 IEEE80211_ADDR_COPY(sc->rxon->wlap, macaddr);
6623 sc->rxon->chan = ieee80211_chan2ieee(ic, ic->ic_curchan);
6624 sc->rxon->flags = htole32(IWN_RXON_TSF | IWN_RXON_CTS_TO_SELF);
6625 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
6626 sc->rxon->flags |= htole32(IWN_RXON_AUTO | IWN_RXON_24GHZ);
6627 switch (ic->ic_opmode) {
6628 case IEEE80211_M_STA:
6629 sc->rxon->mode = IWN_MODE_STA;
6630 sc->rxon->filter = htole32(IWN_FILTER_MULTICAST);

--- 96 unchanged lines hidden (view full) ---

6727/*
6728 * Limit the total dwell time to 85% of the beacon interval.
6729 *
6730 * Returns the dwell time in milliseconds.
6731 */
6732static uint16_t
6733iwn_limit_dwell(struct iwn_softc *sc, uint16_t dwell_time)
6734{
6562 sc->rxon->chan = ieee80211_chan2ieee(ic, ic->ic_curchan);
6563 sc->rxon->flags = htole32(IWN_RXON_TSF | IWN_RXON_CTS_TO_SELF);
6564 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
6565 sc->rxon->flags |= htole32(IWN_RXON_AUTO | IWN_RXON_24GHZ);
6566 switch (ic->ic_opmode) {
6567 case IEEE80211_M_STA:
6568 sc->rxon->mode = IWN_MODE_STA;
6569 sc->rxon->filter = htole32(IWN_FILTER_MULTICAST);

--- 96 unchanged lines hidden (view full) ---

6666/*
6667 * Limit the total dwell time to 85% of the beacon interval.
6668 *
6669 * Returns the dwell time in milliseconds.
6670 */
6671static uint16_t
6672iwn_limit_dwell(struct iwn_softc *sc, uint16_t dwell_time)
6673{
6735 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
6674 struct ieee80211com *ic = &sc->sc_ic;
6736 struct ieee80211vap *vap = NULL;
6737 int bintval = 0;
6738
6739 /* bintval is in TU (1.024mS) */
6740 if (! TAILQ_EMPTY(&ic->ic_vaps)) {
6741 vap = TAILQ_FIRST(&ic->ic_vaps);
6742 bintval = vap->iv_bss->ni_intval;
6743 }

--- 31 unchanged lines hidden (view full) ---

6775 /* Clamp to the beacon interval if we're associated */
6776 return (iwn_limit_dwell(sc, passive));
6777}
6778
6779static int
6780iwn_scan(struct iwn_softc *sc, struct ieee80211vap *vap,
6781 struct ieee80211_scan_state *ss, struct ieee80211_channel *c)
6782{
6675 struct ieee80211vap *vap = NULL;
6676 int bintval = 0;
6677
6678 /* bintval is in TU (1.024mS) */
6679 if (! TAILQ_EMPTY(&ic->ic_vaps)) {
6680 vap = TAILQ_FIRST(&ic->ic_vaps);
6681 bintval = vap->iv_bss->ni_intval;
6682 }

--- 31 unchanged lines hidden (view full) ---

6714 /* Clamp to the beacon interval if we're associated */
6715 return (iwn_limit_dwell(sc, passive));
6716}
6717
6718static int
6719iwn_scan(struct iwn_softc *sc, struct ieee80211vap *vap,
6720 struct ieee80211_scan_state *ss, struct ieee80211_channel *c)
6721{
6783 struct ifnet *ifp = sc->sc_ifp;
6784 struct ieee80211com *ic = ifp->if_l2com;
6722 struct ieee80211com *ic = &sc->sc_ic;
6785 struct ieee80211_node *ni = vap->iv_bss;
6786 struct iwn_scan_hdr *hdr;
6787 struct iwn_cmd_data *tx;
6788 struct iwn_scan_essid *essid;
6789 struct iwn_scan_chan *chan;
6790 struct ieee80211_frame *wh;
6791 struct ieee80211_rateset *rs;
6792 uint8_t *buf, *frm;

--- 121 unchanged lines hidden (view full) ---

6914 /*
6915 * Build a probe request frame. Most of the following code is a
6916 * copy & paste of what is done in net80211.
6917 */
6918 wh = (struct ieee80211_frame *)(essid + 20);
6919 wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
6920 IEEE80211_FC0_SUBTYPE_PROBE_REQ;
6921 wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
6723 struct ieee80211_node *ni = vap->iv_bss;
6724 struct iwn_scan_hdr *hdr;
6725 struct iwn_cmd_data *tx;
6726 struct iwn_scan_essid *essid;
6727 struct iwn_scan_chan *chan;
6728 struct ieee80211_frame *wh;
6729 struct ieee80211_rateset *rs;
6730 uint8_t *buf, *frm;

--- 121 unchanged lines hidden (view full) ---

6852 /*
6853 * Build a probe request frame. Most of the following code is a
6854 * copy & paste of what is done in net80211.
6855 */
6856 wh = (struct ieee80211_frame *)(essid + 20);
6857 wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
6858 IEEE80211_FC0_SUBTYPE_PROBE_REQ;
6859 wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
6922 IEEE80211_ADDR_COPY(wh->i_addr1, ifp->if_broadcastaddr);
6923 IEEE80211_ADDR_COPY(wh->i_addr2, IF_LLADDR(ifp));
6924 IEEE80211_ADDR_COPY(wh->i_addr3, ifp->if_broadcastaddr);
6860 IEEE80211_ADDR_COPY(wh->i_addr1, vap->iv_ifp->if_broadcastaddr);
6861 IEEE80211_ADDR_COPY(wh->i_addr2, IF_LLADDR(vap->iv_ifp));
6862 IEEE80211_ADDR_COPY(wh->i_addr3, vap->iv_ifp->if_broadcastaddr);
6925 *(uint16_t *)&wh->i_dur[0] = 0; /* filled by HW */
6926 *(uint16_t *)&wh->i_seq[0] = 0; /* filled by HW */
6927
6928 frm = (uint8_t *)(wh + 1);
6929 frm = ieee80211_add_ssid(frm, NULL, 0);
6930 frm = ieee80211_add_rates(frm, rs);
6931 if (rs->rs_nrates > IEEE80211_RATE_SIZE)
6932 frm = ieee80211_add_xrates(frm, rs);

--- 102 unchanged lines hidden (view full) ---

7035
7036 return error;
7037}
7038
7039static int
7040iwn_auth(struct iwn_softc *sc, struct ieee80211vap *vap)
7041{
7042 struct iwn_ops *ops = &sc->ops;
6863 *(uint16_t *)&wh->i_dur[0] = 0; /* filled by HW */
6864 *(uint16_t *)&wh->i_seq[0] = 0; /* filled by HW */
6865
6866 frm = (uint8_t *)(wh + 1);
6867 frm = ieee80211_add_ssid(frm, NULL, 0);
6868 frm = ieee80211_add_rates(frm, rs);
6869 if (rs->rs_nrates > IEEE80211_RATE_SIZE)
6870 frm = ieee80211_add_xrates(frm, rs);

--- 102 unchanged lines hidden (view full) ---

6973
6974 return error;
6975}
6976
6977static int
6978iwn_auth(struct iwn_softc *sc, struct ieee80211vap *vap)
6979{
6980 struct iwn_ops *ops = &sc->ops;
7043 struct ifnet *ifp = sc->sc_ifp;
7044 struct ieee80211com *ic = ifp->if_l2com;
6981 struct ieee80211com *ic = &sc->sc_ic;
7045 struct ieee80211_node *ni = vap->iv_bss;
7046 int error;
7047
7048 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
7049
7050 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
7051 /* Update adapter configuration. */
7052 IEEE80211_ADDR_COPY(sc->rxon->bssid, ni->ni_bssid);

--- 55 unchanged lines hidden (view full) ---

7108
7109 return 0;
7110}
7111
7112static int
7113iwn_run(struct iwn_softc *sc, struct ieee80211vap *vap)
7114{
7115 struct iwn_ops *ops = &sc->ops;
6982 struct ieee80211_node *ni = vap->iv_bss;
6983 int error;
6984
6985 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
6986
6987 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
6988 /* Update adapter configuration. */
6989 IEEE80211_ADDR_COPY(sc->rxon->bssid, ni->ni_bssid);

--- 55 unchanged lines hidden (view full) ---

7045
7046 return 0;
7047}
7048
7049static int
7050iwn_run(struct iwn_softc *sc, struct ieee80211vap *vap)
7051{
7052 struct iwn_ops *ops = &sc->ops;
7116 struct ifnet *ifp = sc->sc_ifp;
7117 struct ieee80211com *ic = ifp->if_l2com;
7053 struct ieee80211com *ic = &sc->sc_ic;
7118 struct ieee80211_node *ni = vap->iv_bss;
7119 struct iwn_node_info node;
7120 int error;
7121
7122 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
7123
7124 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
7125 if (ic->ic_opmode == IEEE80211_M_MONITOR) {

--- 1554 unchanged lines hidden (view full) ---

8680 /* Power OFF adapter. */
8681 iwn_apm_stop(sc);
8682}
8683
8684static void
8685iwn_radio_on(void *arg0, int pending)
8686{
8687 struct iwn_softc *sc = arg0;
7054 struct ieee80211_node *ni = vap->iv_bss;
7055 struct iwn_node_info node;
7056 int error;
7057
7058 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
7059
7060 sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX];
7061 if (ic->ic_opmode == IEEE80211_M_MONITOR) {

--- 1554 unchanged lines hidden (view full) ---

8616 /* Power OFF adapter. */
8617 iwn_apm_stop(sc);
8618}
8619
8620static void
8621iwn_radio_on(void *arg0, int pending)
8622{
8623 struct iwn_softc *sc = arg0;
8688 struct ifnet *ifp = sc->sc_ifp;
8689 struct ieee80211com *ic = ifp->if_l2com;
8624 struct ieee80211com *ic = &sc->sc_ic;
8690 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8691
8692 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8693
8694 if (vap != NULL) {
8695 iwn_init(sc);
8696 ieee80211_init(vap);
8697 }
8698}
8699
8700static void
8701iwn_radio_off(void *arg0, int pending)
8702{
8703 struct iwn_softc *sc = arg0;
8625 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8626
8627 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8628
8629 if (vap != NULL) {
8630 iwn_init(sc);
8631 ieee80211_init(vap);
8632 }
8633}
8634
8635static void
8636iwn_radio_off(void *arg0, int pending)
8637{
8638 struct iwn_softc *sc = arg0;
8704 struct ifnet *ifp = sc->sc_ifp;
8705 struct ieee80211com *ic = ifp->if_l2com;
8639 struct ieee80211com *ic = &sc->sc_ic;
8706 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8707
8708 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8709
8710 iwn_stop(sc);
8711 if (vap != NULL)
8712 ieee80211_stop(vap);
8713
8714 /* Enable interrupts to get RF toggle notification. */
8715 IWN_LOCK(sc);
8716 IWN_WRITE(sc, IWN_INT, 0xffffffff);
8717 IWN_WRITE(sc, IWN_INT_MASK, sc->int_mask);
8718 IWN_UNLOCK(sc);
8719}
8720
8721static void
8722iwn_panicked(void *arg0, int pending)
8723{
8724 struct iwn_softc *sc = arg0;
8640 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8641
8642 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8643
8644 iwn_stop(sc);
8645 if (vap != NULL)
8646 ieee80211_stop(vap);
8647
8648 /* Enable interrupts to get RF toggle notification. */
8649 IWN_LOCK(sc);
8650 IWN_WRITE(sc, IWN_INT, 0xffffffff);
8651 IWN_WRITE(sc, IWN_INT_MASK, sc->int_mask);
8652 IWN_UNLOCK(sc);
8653}
8654
8655static void
8656iwn_panicked(void *arg0, int pending)
8657{
8658 struct iwn_softc *sc = arg0;
8725 struct ifnet *ifp = sc->sc_ifp;
8726 struct ieee80211com *ic = ifp->if_l2com;
8659 struct ieee80211com *ic = &sc->sc_ic;
8727 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8728 int error;
8729
8730 if (vap == NULL) {
8731 printf("%s: null vap\n", __func__);
8732 return;
8733 }
8734

--- 11 unchanged lines hidden (view full) ---

8746 }
8747 if (vap->iv_state >= IEEE80211_S_RUN &&
8748 (error = iwn_run(sc, vap)) != 0) {
8749 device_printf(sc->sc_dev,
8750 "%s: could not move to run state\n", __func__);
8751 }
8752
8753 /* Only run start once the NIC is in a useful state, like associated */
8660 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8661 int error;
8662
8663 if (vap == NULL) {
8664 printf("%s: null vap\n", __func__);
8665 return;
8666 }
8667

--- 11 unchanged lines hidden (view full) ---

8679 }
8680 if (vap->iv_state >= IEEE80211_S_RUN &&
8681 (error = iwn_run(sc, vap)) != 0) {
8682 device_printf(sc->sc_dev,
8683 "%s: could not move to run state\n", __func__);
8684 }
8685
8686 /* Only run start once the NIC is in a useful state, like associated */
8754 iwn_start_locked(sc->sc_ifp);
8687 iwn_start_locked(sc);
8755
8756 IWN_UNLOCK(sc);
8757}
8758
8759static void
8760iwn_init_locked(struct iwn_softc *sc)
8761{
8688
8689 IWN_UNLOCK(sc);
8690}
8691
8692static void
8693iwn_init_locked(struct iwn_softc *sc)
8694{
8762 struct ifnet *ifp = sc->sc_ifp;
8763 int error;
8764
8765 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
8766
8767 IWN_LOCK_ASSERT(sc);
8768
8695 int error;
8696
8697 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__);
8698
8699 IWN_LOCK_ASSERT(sc);
8700
8701 sc->sc_flags |= IWN_FLAG_RUNNING;
8702
8769 if ((error = iwn_hw_prepare(sc)) != 0) {
8770 device_printf(sc->sc_dev, "%s: hardware not ready, error %d\n",
8771 __func__, error);
8772 goto fail;
8773 }
8774
8775 /* Initialize interrupt mask to default value. */
8776 sc->int_mask = IWN_INT_MASK_DEF;

--- 31 unchanged lines hidden (view full) ---

8808 /* Configure adapter now that it is ready. */
8809 if ((error = iwn_config(sc)) != 0) {
8810 device_printf(sc->sc_dev,
8811 "%s: could not configure device, error %d\n", __func__,
8812 error);
8813 goto fail;
8814 }
8815
8703 if ((error = iwn_hw_prepare(sc)) != 0) {
8704 device_printf(sc->sc_dev, "%s: hardware not ready, error %d\n",
8705 __func__, error);
8706 goto fail;
8707 }
8708
8709 /* Initialize interrupt mask to default value. */
8710 sc->int_mask = IWN_INT_MASK_DEF;

--- 31 unchanged lines hidden (view full) ---

8742 /* Configure adapter now that it is ready. */
8743 if ((error = iwn_config(sc)) != 0) {
8744 device_printf(sc->sc_dev,
8745 "%s: could not configure device, error %d\n", __func__,
8746 error);
8747 goto fail;
8748 }
8749
8816 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
8817 ifp->if_drv_flags |= IFF_DRV_RUNNING;
8818
8819 callout_reset(&sc->watchdog_to, hz, iwn_watchdog, sc);
8820
8821 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__);
8822
8823 return;
8824
8750 callout_reset(&sc->watchdog_to, hz, iwn_watchdog, sc);
8751
8752 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__);
8753
8754 return;
8755
8825fail: iwn_stop_locked(sc);
8756fail:
8757 sc->sc_flags &= ~IWN_FLAG_RUNNING;
8758 iwn_stop_locked(sc);
8826 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end in error\n",__func__);
8827}
8828
8829static void
8759 DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end in error\n",__func__);
8760}
8761
8762static void
8830iwn_init(void *arg)
8763iwn_init(struct iwn_softc *sc)
8831{
8764{
8832 struct iwn_softc *sc = arg;
8833 struct ifnet *ifp = sc->sc_ifp;
8834 struct ieee80211com *ic = ifp->if_l2com;
8835
8836 IWN_LOCK(sc);
8837 iwn_init_locked(sc);
8838 IWN_UNLOCK(sc);
8839
8765
8766 IWN_LOCK(sc);
8767 iwn_init_locked(sc);
8768 IWN_UNLOCK(sc);
8769
8840 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
8841 ieee80211_start_all(ic);
8770 if (sc->sc_flags & IWN_FLAG_RUNNING)
8771 ieee80211_start_all(&sc->sc_ic);
8842}
8843
8844static void
8845iwn_stop_locked(struct iwn_softc *sc)
8846{
8772}
8773
8774static void
8775iwn_stop_locked(struct iwn_softc *sc)
8776{
8847 struct ifnet *ifp = sc->sc_ifp;
8848
8849 IWN_LOCK_ASSERT(sc);
8850
8851 sc->sc_is_scanning = 0;
8852 sc->sc_tx_timer = 0;
8853 callout_stop(&sc->watchdog_to);
8854 callout_stop(&sc->calib_to);
8777
8778 IWN_LOCK_ASSERT(sc);
8779
8780 sc->sc_is_scanning = 0;
8781 sc->sc_tx_timer = 0;
8782 callout_stop(&sc->watchdog_to);
8783 callout_stop(&sc->calib_to);
8855 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
8784 sc->sc_flags &= ~IWN_FLAG_RUNNING;
8856
8857 /* Power OFF hardware. */
8858 iwn_hw_stop(sc);
8859}
8860
8861static void
8862iwn_stop(struct iwn_softc *sc)
8863{
8864 IWN_LOCK(sc);
8865 iwn_stop_locked(sc);
8866 IWN_UNLOCK(sc);
8867}
8868
8869/*
8870 * Callback from net80211 to start a scan.
8871 */
8872static void
8873iwn_scan_start(struct ieee80211com *ic)
8874{
8785
8786 /* Power OFF hardware. */
8787 iwn_hw_stop(sc);
8788}
8789
8790static void
8791iwn_stop(struct iwn_softc *sc)
8792{
8793 IWN_LOCK(sc);
8794 iwn_stop_locked(sc);
8795 IWN_UNLOCK(sc);
8796}
8797
8798/*
8799 * Callback from net80211 to start a scan.
8800 */
8801static void
8802iwn_scan_start(struct ieee80211com *ic)
8803{
8875 struct ifnet *ifp = ic->ic_ifp;
8876 struct iwn_softc *sc = ifp->if_softc;
8804 struct iwn_softc *sc = ic->ic_softc;
8877
8878 IWN_LOCK(sc);
8879 /* make the link LED blink while we're scanning */
8880 iwn_set_led(sc, IWN_LED_LINK, 20, 2);
8881 IWN_UNLOCK(sc);
8882}
8883
8884/*
8885 * Callback from net80211 to terminate a scan.
8886 */
8887static void
8888iwn_scan_end(struct ieee80211com *ic)
8889{
8805
8806 IWN_LOCK(sc);
8807 /* make the link LED blink while we're scanning */
8808 iwn_set_led(sc, IWN_LED_LINK, 20, 2);
8809 IWN_UNLOCK(sc);
8810}
8811
8812/*
8813 * Callback from net80211 to terminate a scan.
8814 */
8815static void
8816iwn_scan_end(struct ieee80211com *ic)
8817{
8890 struct ifnet *ifp = ic->ic_ifp;
8891 struct iwn_softc *sc = ifp->if_softc;
8818 struct iwn_softc *sc = ic->ic_softc;
8892 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8893
8894 IWN_LOCK(sc);
8895 if (vap->iv_state == IEEE80211_S_RUN) {
8896 /* Set link LED to ON status if we are associated */
8897 iwn_set_led(sc, IWN_LED_LINK, 0, 1);
8898 }
8899 IWN_UNLOCK(sc);
8900}
8901
8902/*
8903 * Callback from net80211 to force a channel change.
8904 */
8905static void
8906iwn_set_channel(struct ieee80211com *ic)
8907{
8908 const struct ieee80211_channel *c = ic->ic_curchan;
8819 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
8820
8821 IWN_LOCK(sc);
8822 if (vap->iv_state == IEEE80211_S_RUN) {
8823 /* Set link LED to ON status if we are associated */
8824 iwn_set_led(sc, IWN_LED_LINK, 0, 1);
8825 }
8826 IWN_UNLOCK(sc);
8827}
8828
8829/*
8830 * Callback from net80211 to force a channel change.
8831 */
8832static void
8833iwn_set_channel(struct ieee80211com *ic)
8834{
8835 const struct ieee80211_channel *c = ic->ic_curchan;
8909 struct ifnet *ifp = ic->ic_ifp;
8910 struct iwn_softc *sc = ifp->if_softc;
8836 struct iwn_softc *sc = ic->ic_softc;
8911 int error;
8912
8913 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8914
8915 IWN_LOCK(sc);
8916 sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq);
8917 sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags);
8918 sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq);

--- 40 unchanged lines hidden (view full) ---

8959{
8960 /* NB: don't try to abort scan; wait for firmware to finish */
8961}
8962
8963static void
8964iwn_hw_reset(void *arg0, int pending)
8965{
8966 struct iwn_softc *sc = arg0;
8837 int error;
8838
8839 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8840
8841 IWN_LOCK(sc);
8842 sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq);
8843 sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags);
8844 sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq);

--- 40 unchanged lines hidden (view full) ---

8885{
8886 /* NB: don't try to abort scan; wait for firmware to finish */
8887}
8888
8889static void
8890iwn_hw_reset(void *arg0, int pending)
8891{
8892 struct iwn_softc *sc = arg0;
8967 struct ifnet *ifp = sc->sc_ifp;
8968 struct ieee80211com *ic = ifp->if_l2com;
8893 struct ieee80211com *ic = &sc->sc_ic;
8969
8970 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8971
8972 iwn_stop(sc);
8973 iwn_init(sc);
8974 ieee80211_notify_radio(ic, 1);
8975}
8976#ifdef IWN_DEBUG

--- 80 unchanged lines hidden --- 		8894
8895 DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__);
8896
8897 iwn_stop(sc);
8898 iwn_init(sc);
8899 ieee80211_notify_radio(ic, 1);
8900}
8901#ifdef IWN_DEBUG

--- 80 unchanged lines hidden ---