Deleted Added
sdiff udiff text old ( 188418 ) new ( 188419 )
full compact
if_rum.c (188418) if_rum.c (188419)
1/* $FreeBSD: head/sys/dev/usb2/wlan/if_rum2.c 188418 2009-02-09 22:14:38Z thompsa $ */
1/* $FreeBSD: head/sys/dev/usb2/wlan/if_rum2.c 188419 2009-02-09 22:18:11Z thompsa $ */
2
3/*-
4 * Copyright (c) 2005-2007 Damien Bergamini <damien.bergamini@free.fr>
5 * Copyright (c) 2006 Niall O'Higgins <niallo@openbsd.org>
6 * Copyright (c) 2007-2008 Hans Petter Selasky <hselasky@freebsd.org>
7 *
8 * Permission to use, copy, modify, and distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above

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

14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 */
20
21#include <sys/cdefs.h>
2
3/*-
4 * Copyright (c) 2005-2007 Damien Bergamini <damien.bergamini@free.fr>
5 * Copyright (c) 2006 Niall O'Higgins <niallo@openbsd.org>
6 * Copyright (c) 2007-2008 Hans Petter Selasky <hselasky@freebsd.org>
7 *
8 * Permission to use, copy, modify, and distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above

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

14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 */
20
21#include <sys/cdefs.h>
22__FBSDID("$FreeBSD: head/sys/dev/usb2/wlan/if_rum2.c 188418 2009-02-09 22:14:38Z thompsa $");
22__FBSDID("$FreeBSD: head/sys/dev/usb2/wlan/if_rum2.c 188419 2009-02-09 22:18:11Z thompsa $");
23
24/*-
25 * Ralink Technology RT2501USB/RT2601USB chipset driver
26 * http://www.ralinktech.com.tw/
27 */
28
29#include <dev/usb2/include/usb2_devid.h>
30#include <dev/usb2/include/usb2_standard.h>

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

49#if USB_DEBUG
50static int rum_debug = 0;
51
52SYSCTL_NODE(_hw_usb2, OID_AUTO, rum, CTLFLAG_RW, 0, "USB rum");
53SYSCTL_INT(_hw_usb2_rum, OID_AUTO, debug, CTLFLAG_RW, &rum_debug, 0,
54 "Debug level");
55#endif
56
23
24/*-
25 * Ralink Technology RT2501USB/RT2601USB chipset driver
26 * http://www.ralinktech.com.tw/
27 */
28
29#include <dev/usb2/include/usb2_devid.h>
30#include <dev/usb2/include/usb2_standard.h>

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

49#if USB_DEBUG
50static int rum_debug = 0;
51
52SYSCTL_NODE(_hw_usb2, OID_AUTO, rum, CTLFLAG_RW, 0, "USB rum");
53SYSCTL_INT(_hw_usb2_rum, OID_AUTO, debug, CTLFLAG_RW, &rum_debug, 0,
54 "Debug level");
55#endif
56
57#define rum_do_request(sc,req,data) \
58 usb2_do_request_proc((sc)->sc_udev, &(sc)->sc_tq, req, data, 0, NULL, 5000)
59
57static const struct usb2_device_id rum_devs[] = {
58 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_HWU54DM) },
59 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT2573_2) },
60 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT2573_3) },
61 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT2573_4) },
62 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_WUG2700) },
63 { USB_VP(USB_VENDOR_AMIT, USB_PRODUCT_AMIT_CGWLUSB2GO) },
64 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2573_1) },

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

111
112static device_probe_t rum_match;
113static device_attach_t rum_attach;
114static device_detach_t rum_detach;
115
116static usb2_callback_t rum_bulk_read_callback;
117static usb2_callback_t rum_bulk_write_callback;
118
60static const struct usb2_device_id rum_devs[] = {
61 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_HWU54DM) },
62 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT2573_2) },
63 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT2573_3) },
64 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT2573_4) },
65 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_WUG2700) },
66 { USB_VP(USB_VENDOR_AMIT, USB_PRODUCT_AMIT_CGWLUSB2GO) },
67 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2573_1) },

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

114
115static device_probe_t rum_match;
116static device_attach_t rum_attach;
117static device_detach_t rum_detach;
118
119static usb2_callback_t rum_bulk_read_callback;
120static usb2_callback_t rum_bulk_write_callback;
121
122static usb2_proc_callback_t rum_attach_post;
119static usb2_proc_callback_t rum_task;
120static usb2_proc_callback_t rum_scantask;
121static usb2_proc_callback_t rum_promisctask;
122static usb2_proc_callback_t rum_amrr_task;
123static usb2_proc_callback_t rum_task;
124static usb2_proc_callback_t rum_scantask;
125static usb2_proc_callback_t rum_promisctask;
126static usb2_proc_callback_t rum_amrr_task;
127static usb2_proc_callback_t rum_init_task;
128static usb2_proc_callback_t rum_stop_task;
123
124static struct ieee80211vap *rum_vap_create(struct ieee80211com *,
125 const char name[IFNAMSIZ], int unit, int opmode,
126 int flags, const uint8_t bssid[IEEE80211_ADDR_LEN],
127 const uint8_t mac[IEEE80211_ADDR_LEN]);
128static void rum_vap_delete(struct ieee80211vap *);
129static void rum_tx_free(struct rum_tx_data *, int);
129
130static struct ieee80211vap *rum_vap_create(struct ieee80211com *,
131 const char name[IFNAMSIZ], int unit, int opmode,
132 int flags, const uint8_t bssid[IEEE80211_ADDR_LEN],
133 const uint8_t mac[IEEE80211_ADDR_LEN]);
134static void rum_vap_delete(struct ieee80211vap *);
135static void rum_tx_free(struct rum_tx_data *, int);
130static int rum_alloc_tx_list(struct rum_softc *);
131static void rum_free_tx_list(struct rum_softc *);
136static void rum_setup_tx_list(struct rum_softc *);
137static void rum_unsetup_tx_list(struct rum_softc *);
132static int rum_newstate(struct ieee80211vap *,
133 enum ieee80211_state, int);
134static void rum_setup_tx_desc(struct rum_softc *,
135 struct rum_tx_desc *, uint32_t, uint16_t, int,
136 int);
137static int rum_tx_mgt(struct rum_softc *, struct mbuf *,
138 struct ieee80211_node *);
139static int rum_tx_raw(struct rum_softc *, struct mbuf *,

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

164 struct ieee80211_channel *);
165static void rum_enable_tsf_sync(struct rum_softc *);
166static void rum_update_slot(struct ifnet *);
167static void rum_set_bssid(struct rum_softc *, const uint8_t *);
168static void rum_set_macaddr(struct rum_softc *, const uint8_t *);
169static const char *rum_get_rf(int);
170static void rum_read_eeprom(struct rum_softc *);
171static int rum_bbp_init(struct rum_softc *);
138static int rum_newstate(struct ieee80211vap *,
139 enum ieee80211_state, int);
140static void rum_setup_tx_desc(struct rum_softc *,
141 struct rum_tx_desc *, uint32_t, uint16_t, int,
142 int);
143static int rum_tx_mgt(struct rum_softc *, struct mbuf *,
144 struct ieee80211_node *);
145static int rum_tx_raw(struct rum_softc *, struct mbuf *,

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

170 struct ieee80211_channel *);
171static void rum_enable_tsf_sync(struct rum_softc *);
172static void rum_update_slot(struct ifnet *);
173static void rum_set_bssid(struct rum_softc *, const uint8_t *);
174static void rum_set_macaddr(struct rum_softc *, const uint8_t *);
175static const char *rum_get_rf(int);
176static void rum_read_eeprom(struct rum_softc *);
177static int rum_bbp_init(struct rum_softc *);
172static void rum_init_locked(struct rum_softc *);
173static void rum_init(void *);
178static void rum_init(void *);
174static void rum_stop(void *);
175static int rum_load_microcode(struct rum_softc *, const u_char *,
176 size_t);
177static int rum_prepare_beacon(struct rum_softc *,
178 struct ieee80211vap *);
179static int rum_raw_xmit(struct ieee80211_node *, struct mbuf *,
180 const struct ieee80211_bpf_params *);
181static struct ieee80211_node *rum_node_alloc(struct ieee80211vap *,
182 const uint8_t mac[IEEE80211_ADDR_LEN]);

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

386 return (usb2_lookup_id_by_uaa(rum_devs, sizeof(rum_devs), uaa));
387}
388
389static int
390rum_attach(device_t self)
391{
392 struct usb2_attach_arg *uaa = device_get_ivars(self);
393 struct rum_softc *sc = device_get_softc(self);
179static int rum_load_microcode(struct rum_softc *, const u_char *,
180 size_t);
181static int rum_prepare_beacon(struct rum_softc *,
182 struct ieee80211vap *);
183static int rum_raw_xmit(struct ieee80211_node *, struct mbuf *,
184 const struct ieee80211_bpf_params *);
185static struct ieee80211_node *rum_node_alloc(struct ieee80211vap *,
186 const uint8_t mac[IEEE80211_ADDR_LEN]);

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

390 return (usb2_lookup_id_by_uaa(rum_devs, sizeof(rum_devs), uaa));
391}
392
393static int
394rum_attach(device_t self)
395{
396 struct usb2_attach_arg *uaa = device_get_ivars(self);
397 struct rum_softc *sc = device_get_softc(self);
394 struct ieee80211com *ic;
395 struct ifnet *ifp;
396 const uint8_t *ucode = NULL;
397 uint8_t bands, iface_index;
398 uint32_t tmp;
399 int error, ntries, size;
398 uint8_t iface_index;
399 int error;
400
401 device_set_usb2_desc(self);
402 sc->sc_udev = uaa->device;
403 sc->sc_dev = self;
404
405 mtx_init(&sc->sc_mtx, device_get_nameunit(self),
406 MTX_NETWORK_LOCK, MTX_DEF);
407

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

415 }
416 error = usb2_proc_create(&sc->sc_tq, &sc->sc_mtx,
417 device_get_nameunit(self), USB_PRI_MED);
418 if (error) {
419 device_printf(self, "could not setup config thread!\n");
420 goto detach;
421 }
422
400
401 device_set_usb2_desc(self);
402 sc->sc_udev = uaa->device;
403 sc->sc_dev = self;
404
405 mtx_init(&sc->sc_mtx, device_get_nameunit(self),
406 MTX_NETWORK_LOCK, MTX_DEF);
407

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

415 }
416 error = usb2_proc_create(&sc->sc_tq, &sc->sc_mtx,
417 device_get_nameunit(self), USB_PRI_MED);
418 if (error) {
419 device_printf(self, "could not setup config thread!\n");
420 goto detach;
421 }
422
423 ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211);
424 if (ifp == NULL) {
425 device_printf(sc->sc_dev, "can not if_alloc()\n");
426 goto detach;
427 }
428 ic = ifp->if_l2com;
429
423 /* fork rest of the attach code */
430 RUM_LOCK(sc);
424 RUM_LOCK(sc);
425 rum_queue_command(sc, rum_attach_post,
426 &sc->sc_synctask[0].hdr,
427 &sc->sc_synctask[1].hdr);
428 RUM_UNLOCK(sc);
429 return (0);
430
431detach:
432 rum_detach(self);
433 return (ENXIO); /* failure */
434}
435
436static void
437rum_attach_post(struct usb2_proc_msg *pm)
438{
439 struct rum_task *task = (struct rum_task *)pm;
440 struct rum_softc *sc = task->sc;
441 struct ifnet *ifp;
442 struct ieee80211com *ic;
443 unsigned int ntries;
444 int error;
445 uint32_t tmp;
446 uint8_t bands;
447
431 /* retrieve RT2573 rev. no */
448 /* retrieve RT2573 rev. no */
432 for (ntries = 0; ntries < 1000; ntries++) {
449 for (ntries = 0; ntries != 1000; ntries++) {
433 if ((tmp = rum_read(sc, RT2573_MAC_CSR0)) != 0)
434 break;
450 if ((tmp = rum_read(sc, RT2573_MAC_CSR0)) != 0)
451 break;
435 DELAY(1000);
452 usb2_pause_mtx(&sc->sc_mtx, hz / 1000);
436 }
437 if (ntries == 1000) {
453 }
454 if (ntries == 1000) {
438 device_printf(self, "timeout waiting for chip to settle\n");
439 RUM_UNLOCK(sc);
440 goto detach;
455 device_printf(sc->sc_dev, "timeout waiting for chip to settle\n");
456 return;
441 }
442
443 /* retrieve MAC address and various other things from EEPROM */
444 rum_read_eeprom(sc);
445
457 }
458
459 /* retrieve MAC address and various other things from EEPROM */
460 rum_read_eeprom(sc);
461
446 device_printf(self, "MAC/BBP RT2573 (rev 0x%05x), RF %s\n",
462 device_printf(sc->sc_dev, "MAC/BBP RT2573 (rev 0x%05x), RF %s\n",
447 tmp, rum_get_rf(sc->rf_rev));
448
463 tmp, rum_get_rf(sc->rf_rev));
464
449 ucode = rt2573_ucode;
450 size = sizeof rt2573_ucode;
451 error = rum_load_microcode(sc, ucode, size);
465 error = rum_load_microcode(sc, rt2573_ucode, sizeof(rt2573_ucode));
452 if (error != 0) {
466 if (error != 0) {
453 device_printf(self, "could not load 8051 microcode\n");
454 RUM_UNLOCK(sc);
467 RUM_UNLOCK(sc);
455 goto detach;
468 device_printf(sc->sc_dev, "could not load 8051 microcode\n");
469 return;
456 }
457 RUM_UNLOCK(sc);
458
470 }
471 RUM_UNLOCK(sc);
472
473 ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211);
474 if (ifp == NULL) {
475 device_printf(sc->sc_dev, "can not if_alloc()\n");
476 RUM_LOCK(sc);
477 return;
478 }
479 ic = ifp->if_l2com;
480
459 ifp->if_softc = sc;
460 if_initname(ifp, "rum", device_get_unit(sc->sc_dev));
461 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
462 ifp->if_init = rum_init;
463 ifp->if_ioctl = rum_ioctl;
464 ifp->if_start = rum_start;
465 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
466 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
467 IFQ_SET_READY(&ifp->if_snd);
468
469 ic->ic_ifp = ifp;
470 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
481 ifp->if_softc = sc;
482 if_initname(ifp, "rum", device_get_unit(sc->sc_dev));
483 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
484 ifp->if_init = rum_init;
485 ifp->if_ioctl = rum_ioctl;
486 ifp->if_start = rum_start;
487 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
488 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
489 IFQ_SET_READY(&ifp->if_snd);
490
491 ic->ic_ifp = ifp;
492 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
493 IEEE80211_ADDR_COPY(ic->ic_myaddr, sc->sc_bssid);
471
472 /* set device capabilities */
473 ic->ic_caps =
474 IEEE80211_C_STA /* station mode supported */
475 | IEEE80211_C_IBSS /* IBSS mode supported */
476 | IEEE80211_C_MONITOR /* monitor mode supported */
477 | IEEE80211_C_HOSTAP /* HostAp mode supported */
478 | IEEE80211_C_TXPMGT /* tx power management */

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

511
512 sc->sc_txtap_len = sizeof sc->sc_txtap;
513 sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
514 sc->sc_txtap.wt_ihdr.it_present = htole32(RT2573_TX_RADIOTAP_PRESENT);
515
516 if (bootverbose)
517 ieee80211_announce(ic);
518
494
495 /* set device capabilities */
496 ic->ic_caps =
497 IEEE80211_C_STA /* station mode supported */
498 | IEEE80211_C_IBSS /* IBSS mode supported */
499 | IEEE80211_C_MONITOR /* monitor mode supported */
500 | IEEE80211_C_HOSTAP /* HostAp mode supported */
501 | IEEE80211_C_TXPMGT /* tx power management */

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

534
535 sc->sc_txtap_len = sizeof sc->sc_txtap;
536 sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
537 sc->sc_txtap.wt_ihdr.it_present = htole32(RT2573_TX_RADIOTAP_PRESENT);
538
539 if (bootverbose)
540 ieee80211_announce(ic);
541
519 return 0;
520detach:
521 rum_detach(self);
522 return (ENXIO); /* failure */
542 RUM_LOCK(sc);
523}
524
525static int
526rum_detach(device_t self)
527{
528 struct rum_softc *sc = device_get_softc(self);
529 struct ifnet *ifp = sc->sc_ifp;
530 struct ieee80211com *ic = ifp->if_l2com;
531
543}
544
545static int
546rum_detach(device_t self)
547{
548 struct rum_softc *sc = device_get_softc(self);
549 struct ifnet *ifp = sc->sc_ifp;
550 struct ieee80211com *ic = ifp->if_l2com;
551
532 RUM_LOCK(sc);
533 sc->sc_flags |= RUM_FLAG_DETACH;
534 rum_stop(sc);
535 RUM_UNLOCK(sc);
552 /* wait for any post attach or other command to complete */
553 usb2_proc_drain(&sc->sc_tq);
536
554
537 /* stop all USB transfers first */
555 /* stop all USB transfers */
538 usb2_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER);
539 usb2_proc_free(&sc->sc_tq);
540
556 usb2_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER);
557 usb2_proc_free(&sc->sc_tq);
558
559 /* free TX list, if any */
560 RUM_LOCK(sc);
561 rum_unsetup_tx_list(sc);
562 RUM_UNLOCK(sc);
563
541 if (ifp) {
542 bpfdetach(ifp);
543 ieee80211_ifdetach(ic);
544 if_free(ifp);
545 }
564 if (ifp) {
565 bpfdetach(ifp);
566 ieee80211_ifdetach(ic);
567 if_free(ifp);
568 }
569
546 mtx_destroy(&sc->sc_mtx);
547
548 return (0);
549}
550
551static struct ieee80211vap *
552rum_vap_create(struct ieee80211com *ic,
553 const char name[IFNAMSIZ], int unit, int opmode, int flags,

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

585 ic->ic_opmode = opmode;
586 return vap;
587}
588
589static void
590rum_vap_delete(struct ieee80211vap *vap)
591{
592 struct rum_vap *rvp = RUM_VAP(vap);
570 mtx_destroy(&sc->sc_mtx);
571
572 return (0);
573}
574
575static struct ieee80211vap *
576rum_vap_create(struct ieee80211com *ic,
577 const char name[IFNAMSIZ], int unit, int opmode, int flags,

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

609 ic->ic_opmode = opmode;
610 return vap;
611}
612
613static void
614rum_vap_delete(struct ieee80211vap *vap)
615{
616 struct rum_vap *rvp = RUM_VAP(vap);
593 struct rum_softc *sc = rvp->sc;
594
617
595 RUM_LOCK(sc);
596 usb2_callout_stop(&rvp->amrr_ch);
597 RUM_UNLOCK(sc);
618 usb2_callout_drain(&rvp->amrr_ch);
598 ieee80211_amrr_cleanup(&rvp->amrr);
599 ieee80211_vap_detach(vap);
600 free(rvp, M_80211_VAP);
601}
602
603static void
604rum_tx_free(struct rum_tx_data *data, int txerr)
605{

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

614
615 ieee80211_free_node(data->ni);
616 data->ni = NULL;
617 }
618 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
619 sc->tx_nfree++;
620}
621
619 ieee80211_amrr_cleanup(&rvp->amrr);
620 ieee80211_vap_detach(vap);
621 free(rvp, M_80211_VAP);
622}
623
624static void
625rum_tx_free(struct rum_tx_data *data, int txerr)
626{

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

635
636 ieee80211_free_node(data->ni);
637 data->ni = NULL;
638 }
639 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
640 sc->tx_nfree++;
641}
642
622static int
623rum_alloc_tx_list(struct rum_softc *sc)
643static void
644rum_setup_tx_list(struct rum_softc *sc)
624{
625 struct rum_tx_data *data;
626 int i;
627
645{
646 struct rum_tx_data *data;
647 int i;
648
628 sc->tx_data = malloc(sizeof(struct rum_tx_data) * RUM_TX_LIST_COUNT,
629 M_USB, M_NOWAIT|M_ZERO);
630 if (sc->tx_data == NULL)
631 return (ENOMEM);
632
633 sc->tx_nfree = 0;
634 STAILQ_INIT(&sc->tx_q);
635 STAILQ_INIT(&sc->tx_free);
636
637 for (i = 0; i < RUM_TX_LIST_COUNT; i++) {
638 data = &sc->tx_data[i];
639
640 data->sc = sc;
641 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
642 sc->tx_nfree++;
643 }
649 sc->tx_nfree = 0;
650 STAILQ_INIT(&sc->tx_q);
651 STAILQ_INIT(&sc->tx_free);
652
653 for (i = 0; i < RUM_TX_LIST_COUNT; i++) {
654 data = &sc->tx_data[i];
655
656 data->sc = sc;
657 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
658 sc->tx_nfree++;
659 }
644 return 0;
645}
646
647static void
660}
661
662static void
648rum_free_tx_list(struct rum_softc *sc)
663rum_unsetup_tx_list(struct rum_softc *sc)
649{
650 struct rum_tx_data *data;
651 int i;
652
664{
665 struct rum_tx_data *data;
666 int i;
667
653 if (sc->tx_data == NULL)
654 return;
668 /* make sure any subsequent use of the queues will fail */
669 sc->tx_nfree = 0;
670 STAILQ_INIT(&sc->tx_q);
671 STAILQ_INIT(&sc->tx_free);
655
672
673 /* free up all node references and mbufs */
656 for (i = 0; i < RUM_TX_LIST_COUNT; i++) {
657 data = &sc->tx_data[i];
658
659 if (data->m != NULL) {
660 m_freem(data->m);
661 data->m = NULL;
662 }
663 if (data->ni != NULL) {
664 ieee80211_free_node(data->ni);
665 data->ni = NULL;
666 }
667 }
674 for (i = 0; i < RUM_TX_LIST_COUNT; i++) {
675 data = &sc->tx_data[i];
676
677 if (data->m != NULL) {
678 m_freem(data->m);
679 data->m = NULL;
680 }
681 if (data->ni != NULL) {
682 ieee80211_free_node(data->ni);
683 data->ni = NULL;
684 }
685 }
668 free(sc->tx_data, M_USB);
669 sc->tx_data = NULL;
670}
671
672static void
673rum_task(struct usb2_proc_msg *pm)
674{
675 struct rum_task *task = (struct rum_task *)pm;
676 struct rum_softc *sc = task->sc;
677 struct ifnet *ifp = sc->sc_ifp;
678 struct ieee80211com *ic = ifp->if_l2com;
679 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
680 struct rum_vap *rvp = RUM_VAP(vap);
681 const struct ieee80211_txparam *tp;
682 enum ieee80211_state ostate;
683 struct ieee80211_node *ni;
684 uint32_t tmp;
685
686}
687
688static void
689rum_task(struct usb2_proc_msg *pm)
690{
691 struct rum_task *task = (struct rum_task *)pm;
692 struct rum_softc *sc = task->sc;
693 struct ifnet *ifp = sc->sc_ifp;
694 struct ieee80211com *ic = ifp->if_l2com;
695 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
696 struct rum_vap *rvp = RUM_VAP(vap);
697 const struct ieee80211_txparam *tp;
698 enum ieee80211_state ostate;
699 struct ieee80211_node *ni;
700 uint32_t tmp;
701
686 if (sc->sc_flags & RUM_FLAG_DETACH)
687 return;
688
689 ostate = vap->iv_state;
690
691 switch (sc->sc_state) {
692 case IEEE80211_S_INIT:
693 if (ostate == IEEE80211_S_RUN) {
694 /* abort TSF synchronization */
695 tmp = rum_read(sc, RT2573_TXRX_CSR9);
696 rum_write(sc, RT2573_TXRX_CSR9, tmp & ~0x00ffffff);
697 }
698 break;
699
700 case IEEE80211_S_RUN:
701 ni = vap->iv_bss;
702
703 if (vap->iv_opmode != IEEE80211_M_MONITOR) {
704 rum_update_slot(ic->ic_ifp);
705 rum_enable_mrr(sc);
706 rum_set_txpreamble(sc);
707 rum_set_basicrates(sc);
702 ostate = vap->iv_state;
703
704 switch (sc->sc_state) {
705 case IEEE80211_S_INIT:
706 if (ostate == IEEE80211_S_RUN) {
707 /* abort TSF synchronization */
708 tmp = rum_read(sc, RT2573_TXRX_CSR9);
709 rum_write(sc, RT2573_TXRX_CSR9, tmp & ~0x00ffffff);
710 }
711 break;
712
713 case IEEE80211_S_RUN:
714 ni = vap->iv_bss;
715
716 if (vap->iv_opmode != IEEE80211_M_MONITOR) {
717 rum_update_slot(ic->ic_ifp);
718 rum_enable_mrr(sc);
719 rum_set_txpreamble(sc);
720 rum_set_basicrates(sc);
708 rum_set_bssid(sc, ni->ni_bssid);
721 IEEE80211_ADDR_COPY(sc->sc_bssid, ni->ni_bssid);
722 rum_set_bssid(sc, sc->sc_bssid);
709 }
710
711 if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
712 vap->iv_opmode == IEEE80211_M_IBSS)
713 rum_prepare_beacon(sc, vap);
714
715 if (vap->iv_opmode != IEEE80211_M_MONITOR)
716 rum_enable_tsf_sync(sc);

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

768rum_bulk_write_callback(struct usb2_xfer *xfer)
769{
770 struct rum_softc *sc = xfer->priv_sc;
771 struct ifnet *ifp = sc->sc_ifp;
772 struct ieee80211com *ic = ifp->if_l2com;
773 struct ieee80211_channel *c = ic->ic_curchan;
774 struct rum_tx_data *data;
775 struct mbuf *m;
723 }
724
725 if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
726 vap->iv_opmode == IEEE80211_M_IBSS)
727 rum_prepare_beacon(sc, vap);
728
729 if (vap->iv_opmode != IEEE80211_M_MONITOR)
730 rum_enable_tsf_sync(sc);

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

782rum_bulk_write_callback(struct usb2_xfer *xfer)
783{
784 struct rum_softc *sc = xfer->priv_sc;
785 struct ifnet *ifp = sc->sc_ifp;
786 struct ieee80211com *ic = ifp->if_l2com;
787 struct ieee80211_channel *c = ic->ic_curchan;
788 struct rum_tx_data *data;
789 struct mbuf *m;
776 int len;
790 unsigned int len;
777
778 switch (USB_GET_STATE(xfer)) {
779 case USB_ST_TRANSFERRED:
780 DPRINTFN(11, "transfer complete, %d bytes\n", xfer->actlen);
781
782 /* free resources */
783 data = xfer->priv_fifo;
784 rum_tx_free(data, 0);
785 xfer->priv_fifo = NULL;
786
787 ifp->if_opackets++;
788 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
789
790 /* FALLTHROUGH */
791 case USB_ST_SETUP:
792tr_setup:
791
792 switch (USB_GET_STATE(xfer)) {
793 case USB_ST_TRANSFERRED:
794 DPRINTFN(11, "transfer complete, %d bytes\n", xfer->actlen);
795
796 /* free resources */
797 data = xfer->priv_fifo;
798 rum_tx_free(data, 0);
799 xfer->priv_fifo = NULL;
800
801 ifp->if_opackets++;
802 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
803
804 /* FALLTHROUGH */
805 case USB_ST_SETUP:
806tr_setup:
793#if 0
794 if (sc->sc_flags & RUM_FLAG_WAIT_COMMAND) {
795 /*
796 * don't send anything while a command is pending !
797 */
798 break;
799 }
800#endif
801
802 data = STAILQ_FIRST(&sc->tx_q);
803 if (data) {
804 STAILQ_REMOVE_HEAD(&sc->tx_q, next);
805 m = data->m;
806
807 if (m->m_pkthdr.len > (MCLBYTES + RT2573_TX_DESC_SIZE)) {
808 DPRINTFN(0, "data overflow, %u bytes\n",
809 m->m_pkthdr.len);

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

840 usb2_start_hardware(xfer);
841 }
842 break;
843
844 default: /* Error */
845 DPRINTFN(11, "transfer error, %s\n",
846 usb2_errstr(xfer->error));
847
807 data = STAILQ_FIRST(&sc->tx_q);
808 if (data) {
809 STAILQ_REMOVE_HEAD(&sc->tx_q, next);
810 m = data->m;
811
812 if (m->m_pkthdr.len > (MCLBYTES + RT2573_TX_DESC_SIZE)) {
813 DPRINTFN(0, "data overflow, %u bytes\n",
814 m->m_pkthdr.len);

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

845 usb2_start_hardware(xfer);
846 }
847 break;
848
849 default: /* Error */
850 DPRINTFN(11, "transfer error, %s\n",
851 usb2_errstr(xfer->error));
852
853 ifp->if_oerrors++;
854 data = xfer->priv_fifo;
855 if (data != NULL) {
856 rum_tx_free(data, xfer->error);
857 xfer->priv_fifo = NULL;
858 }
859
848 if (xfer->error == USB_ERR_STALLED) {
849 /* try to clear stall first */
850 xfer->flags.stall_pipe = 1;
851 goto tr_setup;
852 }
853 if (xfer->error == USB_ERR_TIMEOUT)
854 device_printf(sc->sc_dev, "device timeout\n");
860 if (xfer->error == USB_ERR_STALLED) {
861 /* try to clear stall first */
862 xfer->flags.stall_pipe = 1;
863 goto tr_setup;
864 }
865 if (xfer->error == USB_ERR_TIMEOUT)
866 device_printf(sc->sc_dev, "device timeout\n");
855
856 ifp->if_oerrors++;
857 data = xfer->priv_fifo;
858 if (data != NULL) {
859 rum_tx_free(data, xfer->error);
860 xfer->priv_fifo = NULL;
861 }
862 break;
863 }
864}
865
866static void
867rum_bulk_read_callback(struct usb2_xfer *xfer)
868{
869 struct rum_softc *sc = xfer->priv_sc;
870 struct ifnet *ifp = sc->sc_ifp;
871 struct ieee80211com *ic = ifp->if_l2com;
872 struct ieee80211_node *ni;
873 struct mbuf *m = NULL;
874 uint32_t flags;
875 uint8_t rssi = 0;
867 break;
868 }
869}
870
871static void
872rum_bulk_read_callback(struct usb2_xfer *xfer)
873{
874 struct rum_softc *sc = xfer->priv_sc;
875 struct ifnet *ifp = sc->sc_ifp;
876 struct ieee80211com *ic = ifp->if_l2com;
877 struct ieee80211_node *ni;
878 struct mbuf *m = NULL;
879 uint32_t flags;
880 uint8_t rssi = 0;
876 int len;
881 unsigned int len;
877
878 switch (USB_GET_STATE(xfer)) {
879 case USB_ST_TRANSFERRED:
880
881 DPRINTFN(15, "rx done, actlen=%d\n", xfer->actlen);
882
883 len = xfer->actlen;
884 if (len < RT2573_RX_DESC_SIZE + IEEE80211_MIN_LEN) {

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

960
961 default: /* Error */
962 if (xfer->error != USB_ERR_CANCELLED) {
963 /* try to clear stall first */
964 xfer->flags.stall_pipe = 1;
965 goto tr_setup;
966 }
967 return;
882
883 switch (USB_GET_STATE(xfer)) {
884 case USB_ST_TRANSFERRED:
885
886 DPRINTFN(15, "rx done, actlen=%d\n", xfer->actlen);
887
888 len = xfer->actlen;
889 if (len < RT2573_RX_DESC_SIZE + IEEE80211_MIN_LEN) {

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

965
966 default: /* Error */
967 if (xfer->error != USB_ERR_CANCELLED) {
968 /* try to clear stall first */
969 xfer->flags.stall_pipe = 1;
970 goto tr_setup;
971 }
972 return;
968
969 }
970}
971
972static uint8_t
973rum_plcp_signal(int rate)
974{
975 switch (rate) {
976 /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */

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

1328 struct ifreq *ifr = (struct ifreq *) data;
1329 int error = 0, startall = 0;
1330
1331 switch (cmd) {
1332 case SIOCSIFFLAGS:
1333 RUM_LOCK(sc);
1334 if (ifp->if_flags & IFF_UP) {
1335 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
973 }
974}
975
976static uint8_t
977rum_plcp_signal(int rate)
978{
979 switch (rate) {
980 /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */

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

1332 struct ifreq *ifr = (struct ifreq *) data;
1333 int error = 0, startall = 0;
1334
1335 switch (cmd) {
1336 case SIOCSIFFLAGS:
1337 RUM_LOCK(sc);
1338 if (ifp->if_flags & IFF_UP) {
1339 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
1336 rum_init_locked(sc);
1340 rum_queue_command(sc, rum_init_task,
1341 &sc->sc_synctask[0].hdr,
1342 &sc->sc_synctask[1].hdr);
1337 startall = 1;
1338 } else
1339 rum_queue_command(sc, rum_promisctask,
1340 &sc->sc_promisctask[0].hdr,
1341 &sc->sc_promisctask[1].hdr);
1342 } else {
1343 startall = 1;
1344 } else
1345 rum_queue_command(sc, rum_promisctask,
1346 &sc->sc_promisctask[0].hdr,
1347 &sc->sc_promisctask[1].hdr);
1348 } else {
1343 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1344 rum_stop(sc);
1349 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1350 rum_queue_command(sc, rum_stop_task,
1351 &sc->sc_synctask[0].hdr,
1352 &sc->sc_synctask[1].hdr);
1353 }
1345 }
1346 RUM_UNLOCK(sc);
1347 if (startall)
1348 ieee80211_start_all(ic);
1349 break;
1350 case SIOCGIFMEDIA:
1351 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
1352 break;

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

1367 usb2_error_t error;
1368
1369 req.bmRequestType = UT_READ_VENDOR_DEVICE;
1370 req.bRequest = RT2573_READ_EEPROM;
1371 USETW(req.wValue, 0);
1372 USETW(req.wIndex, addr);
1373 USETW(req.wLength, len);
1374
1354 }
1355 RUM_UNLOCK(sc);
1356 if (startall)
1357 ieee80211_start_all(ic);
1358 break;
1359 case SIOCGIFMEDIA:
1360 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
1361 break;

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

1376 usb2_error_t error;
1377
1378 req.bmRequestType = UT_READ_VENDOR_DEVICE;
1379 req.bRequest = RT2573_READ_EEPROM;
1380 USETW(req.wValue, 0);
1381 USETW(req.wIndex, addr);
1382 USETW(req.wLength, len);
1383
1375 error = usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, buf);
1384 error = rum_do_request(sc, &req, buf);
1376 if (error != 0) {
1377 device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1378 usb2_errstr(error));
1379 }
1380}
1381
1382static uint32_t
1383rum_read(struct rum_softc *sc, uint16_t reg)

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

1396 usb2_error_t error;
1397
1398 req.bmRequestType = UT_READ_VENDOR_DEVICE;
1399 req.bRequest = RT2573_READ_MULTI_MAC;
1400 USETW(req.wValue, 0);
1401 USETW(req.wIndex, reg);
1402 USETW(req.wLength, len);
1403
1385 if (error != 0) {
1386 device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1387 usb2_errstr(error));
1388 }
1389}
1390
1391static uint32_t
1392rum_read(struct rum_softc *sc, uint16_t reg)

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

1405 usb2_error_t error;
1406
1407 req.bmRequestType = UT_READ_VENDOR_DEVICE;
1408 req.bRequest = RT2573_READ_MULTI_MAC;
1409 USETW(req.wValue, 0);
1410 USETW(req.wIndex, reg);
1411 USETW(req.wLength, len);
1412
1404 error = usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, buf);
1413 error = rum_do_request(sc, &req, buf);
1405 if (error != 0) {
1406 device_printf(sc->sc_dev,
1407 "could not multi read MAC register: %s\n",
1408 usb2_errstr(error));
1409 }
1410}
1411
1412static void

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

1424 usb2_error_t error;
1425
1426 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
1427 req.bRequest = RT2573_WRITE_MULTI_MAC;
1428 USETW(req.wValue, 0);
1429 USETW(req.wIndex, reg);
1430 USETW(req.wLength, len);
1431
1414 if (error != 0) {
1415 device_printf(sc->sc_dev,
1416 "could not multi read MAC register: %s\n",
1417 usb2_errstr(error));
1418 }
1419}
1420
1421static void

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

1433 usb2_error_t error;
1434
1435 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
1436 req.bRequest = RT2573_WRITE_MULTI_MAC;
1437 USETW(req.wValue, 0);
1438 USETW(req.wIndex, reg);
1439 USETW(req.wLength, len);
1440
1432 error = usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, buf);
1441 error = rum_do_request(sc, &req, buf);
1433 if (error != 0) {
1434 device_printf(sc->sc_dev,
1435 "could not multi write MAC register: %s\n",
1436 usb2_errstr(error));
1437 }
1438}
1439
1440static void

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

1782static void
1783rum_promisctask(struct usb2_proc_msg *pm)
1784{
1785 struct rum_task *task = (struct rum_task *)pm;
1786 struct rum_softc *sc = task->sc;
1787 struct ifnet *ifp = sc->sc_ifp;
1788 uint32_t tmp;
1789
1442 if (error != 0) {
1443 device_printf(sc->sc_dev,
1444 "could not multi write MAC register: %s\n",
1445 usb2_errstr(error));
1446 }
1447}
1448
1449static void

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

1791static void
1792rum_promisctask(struct usb2_proc_msg *pm)
1793{
1794 struct rum_task *task = (struct rum_task *)pm;
1795 struct rum_softc *sc = task->sc;
1796 struct ifnet *ifp = sc->sc_ifp;
1797 uint32_t tmp;
1798
1790 if (sc->sc_flags & RUM_FLAG_DETACH)
1791 return;
1792
1793 tmp = rum_read(sc, RT2573_TXRX_CSR0);
1794
1795 tmp &= ~RT2573_DROP_NOT_TO_ME;
1796 if (!(ifp->if_flags & IFF_PROMISC))
1797 tmp |= RT2573_DROP_NOT_TO_ME;
1798
1799 rum_write(sc, RT2573_TXRX_CSR0, tmp);
1800

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

1812 case RT2573_RF_5226: return "RT5226";
1813 default: return "unknown";
1814 }
1815}
1816
1817static void
1818rum_read_eeprom(struct rum_softc *sc)
1819{
1799 tmp = rum_read(sc, RT2573_TXRX_CSR0);
1800
1801 tmp &= ~RT2573_DROP_NOT_TO_ME;
1802 if (!(ifp->if_flags & IFF_PROMISC))
1803 tmp |= RT2573_DROP_NOT_TO_ME;
1804
1805 rum_write(sc, RT2573_TXRX_CSR0, tmp);
1806

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

1818 case RT2573_RF_5226: return "RT5226";
1819 default: return "unknown";
1820 }
1821}
1822
1823static void
1824rum_read_eeprom(struct rum_softc *sc)
1825{
1820 struct ifnet *ifp = sc->sc_ifp;
1821 struct ieee80211com *ic = ifp->if_l2com;
1822 uint16_t val;
1823#ifdef RUM_DEBUG
1824 int i;
1825#endif
1826
1827 /* read MAC address */
1826 uint16_t val;
1827#ifdef RUM_DEBUG
1828 int i;
1829#endif
1830
1831 /* read MAC address */
1828 rum_eeprom_read(sc, RT2573_EEPROM_ADDRESS, ic->ic_myaddr, 6);
1832 rum_eeprom_read(sc, RT2573_EEPROM_ADDRESS, sc->sc_bssid, 6);
1829
1830 rum_eeprom_read(sc, RT2573_EEPROM_ANTENNA, &val, 2);
1831 val = le16toh(val);
1832 sc->rf_rev = (val >> 11) & 0x1f;
1833 sc->hw_radio = (val >> 10) & 0x1;
1834 sc->rx_ant = (val >> 4) & 0x3;
1835 sc->tx_ant = (val >> 2) & 0x3;
1836 sc->nb_ant = val & 0x3;

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

1928 rum_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
1929 }
1930
1931 return 0;
1932#undef N
1933}
1934
1935static void
1833
1834 rum_eeprom_read(sc, RT2573_EEPROM_ANTENNA, &val, 2);
1835 val = le16toh(val);
1836 sc->rf_rev = (val >> 11) & 0x1f;
1837 sc->hw_radio = (val >> 10) & 0x1;
1838 sc->rx_ant = (val >> 4) & 0x3;
1839 sc->tx_ant = (val >> 2) & 0x3;
1840 sc->nb_ant = val & 0x3;

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

1932 rum_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
1933 }
1934
1935 return 0;
1936#undef N
1937}
1938
1939static void
1936rum_init_locked(struct rum_softc *sc)
1940rum_init_task(struct usb2_proc_msg *pm)
1937{
1938#define N(a) (sizeof (a) / sizeof ((a)[0]))
1941{
1942#define N(a) (sizeof (a) / sizeof ((a)[0]))
1943 struct rum_task *task = (struct rum_task *)pm;
1944 struct rum_softc *sc = task->sc;
1939 struct ifnet *ifp = sc->sc_ifp;
1940 struct ieee80211com *ic = ifp->if_l2com;
1941 uint32_t tmp;
1942 usb2_error_t error;
1943 int i, ntries;
1944
1945 RUM_LOCK_ASSERT(sc, MA_OWNED);
1946
1945 struct ifnet *ifp = sc->sc_ifp;
1946 struct ieee80211com *ic = ifp->if_l2com;
1947 uint32_t tmp;
1948 usb2_error_t error;
1949 int i, ntries;
1950
1951 RUM_LOCK_ASSERT(sc, MA_OWNED);
1952
1947 if (sc->sc_flags & RUM_FLAG_DETACH)
1948 return;
1953 rum_stop_task(pm);
1949
1954
1950 rum_stop(sc);
1951
1952 /* initialize MAC registers to default values */
1953 for (i = 0; i < N(rum_def_mac); i++)
1954 rum_write(sc, rum_def_mac[i].reg, rum_def_mac[i].val);
1955
1956 /* set host ready */
1957 rum_write(sc, RT2573_MAC_CSR1, 3);
1958 rum_write(sc, RT2573_MAC_CSR1, 0);
1959

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

1985 rum_set_macaddr(sc, ic->ic_myaddr);
1986
1987 /* initialize ASIC */
1988 rum_write(sc, RT2573_MAC_CSR1, 4);
1989
1990 /*
1991 * Allocate Tx and Rx xfer queues.
1992 */
1955 /* initialize MAC registers to default values */
1956 for (i = 0; i < N(rum_def_mac); i++)
1957 rum_write(sc, rum_def_mac[i].reg, rum_def_mac[i].val);
1958
1959 /* set host ready */
1960 rum_write(sc, RT2573_MAC_CSR1, 3);
1961 rum_write(sc, RT2573_MAC_CSR1, 0);
1962

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

1988 rum_set_macaddr(sc, ic->ic_myaddr);
1989
1990 /* initialize ASIC */
1991 rum_write(sc, RT2573_MAC_CSR1, 4);
1992
1993 /*
1994 * Allocate Tx and Rx xfer queues.
1995 */
1993 error = rum_alloc_tx_list(sc);
1994 if (error != 0) {
1995 device_printf(sc->sc_dev, "could not allocate Tx list\n");
1996 goto fail;
1997 }
1996 rum_setup_tx_list(sc);
1998
1999 /* update Rx filter */
2000 tmp = rum_read(sc, RT2573_TXRX_CSR0) & 0xffff;
2001
2002 tmp |= RT2573_DROP_PHY_ERROR | RT2573_DROP_CRC_ERROR;
2003 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2004 tmp |= RT2573_DROP_CTL | RT2573_DROP_VER_ERROR |
2005 RT2573_DROP_ACKCTS;

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

2010 }
2011 rum_write(sc, RT2573_TXRX_CSR0, tmp);
2012
2013 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
2014 ifp->if_drv_flags |= IFF_DRV_RUNNING;
2015 usb2_transfer_start(sc->sc_xfer[RUM_BULK_RD]);
2016 return;
2017
1997
1998 /* update Rx filter */
1999 tmp = rum_read(sc, RT2573_TXRX_CSR0) & 0xffff;
2000
2001 tmp |= RT2573_DROP_PHY_ERROR | RT2573_DROP_CRC_ERROR;
2002 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2003 tmp |= RT2573_DROP_CTL | RT2573_DROP_VER_ERROR |
2004 RT2573_DROP_ACKCTS;

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

2009 }
2010 rum_write(sc, RT2573_TXRX_CSR0, tmp);
2011
2012 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
2013 ifp->if_drv_flags |= IFF_DRV_RUNNING;
2014 usb2_transfer_start(sc->sc_xfer[RUM_BULK_RD]);
2015 return;
2016
2018fail: rum_stop(sc);
2017fail: rum_stop_task(pm);
2019#undef N
2020}
2021
2022static void
2023rum_init(void *priv)
2024{
2025 struct rum_softc *sc = priv;
2026 struct ifnet *ifp = sc->sc_ifp;
2027 struct ieee80211com *ic = ifp->if_l2com;
2028
2029 RUM_LOCK(sc);
2018#undef N
2019}
2020
2021static void
2022rum_init(void *priv)
2023{
2024 struct rum_softc *sc = priv;
2025 struct ifnet *ifp = sc->sc_ifp;
2026 struct ieee80211com *ic = ifp->if_l2com;
2027
2028 RUM_LOCK(sc);
2030 rum_init_locked(sc);
2029 rum_queue_command(sc, rum_init_task,
2030 &sc->sc_synctask[0].hdr,
2031 &sc->sc_synctask[1].hdr);
2031 RUM_UNLOCK(sc);
2032
2033 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2034 ieee80211_start_all(ic); /* start all vap's */
2035}
2036
2037static void
2032 RUM_UNLOCK(sc);
2033
2034 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2035 ieee80211_start_all(ic); /* start all vap's */
2036}
2037
2038static void
2038rum_stop(void *priv)
2039rum_stop_task(struct usb2_proc_msg *pm)
2039{
2040{
2040 struct rum_softc *sc = priv;
2041 struct rum_task *task = (struct rum_task *)pm;
2042 struct rum_softc *sc = task->sc;
2041 struct ifnet *ifp = sc->sc_ifp;
2042 uint32_t tmp;
2043
2044 RUM_LOCK_ASSERT(sc, MA_OWNED);
2045
2046 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
2047
2043 struct ifnet *ifp = sc->sc_ifp;
2044 uint32_t tmp;
2045
2046 RUM_LOCK_ASSERT(sc, MA_OWNED);
2047
2048 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
2049
2050 RUM_UNLOCK(sc);
2051
2048 /*
2052 /*
2049 * stop all the transfers, if not already stopped:
2053 * Drain the USB transfers, if not already drained:
2050 */
2054 */
2051 usb2_transfer_stop(sc->sc_xfer[RUM_BULK_WR]);
2052 usb2_transfer_stop(sc->sc_xfer[RUM_BULK_RD]);
2055 usb2_transfer_drain(sc->sc_xfer[RUM_BULK_WR]);
2056 usb2_transfer_drain(sc->sc_xfer[RUM_BULK_RD]);
2053
2057
2054 rum_free_tx_list(sc);
2058 RUM_LOCK(sc);
2055
2059
2056 /* Stop now if the device has vanished */
2057 if (sc->sc_flags & RUM_FLAG_DETACH)
2058 return;
2060 rum_unsetup_tx_list(sc);
2059
2060 /* disable Rx */
2061 tmp = rum_read(sc, RT2573_TXRX_CSR0);
2062 rum_write(sc, RT2573_TXRX_CSR0, tmp | RT2573_DISABLE_RX);
2063
2064 /* reset ASIC */
2065 rum_write(sc, RT2573_MAC_CSR1, 3);
2066 rum_write(sc, RT2573_MAC_CSR1, 0);

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

2078 rum_write(sc, reg, UGETDW(ucode));
2079
2080 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
2081 req.bRequest = RT2573_MCU_CNTL;
2082 USETW(req.wValue, RT2573_MCU_RUN);
2083 USETW(req.wIndex, 0);
2084 USETW(req.wLength, 0);
2085
2061
2062 /* disable Rx */
2063 tmp = rum_read(sc, RT2573_TXRX_CSR0);
2064 rum_write(sc, RT2573_TXRX_CSR0, tmp | RT2573_DISABLE_RX);
2065
2066 /* reset ASIC */
2067 rum_write(sc, RT2573_MAC_CSR1, 3);
2068 rum_write(sc, RT2573_MAC_CSR1, 0);

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

2080 rum_write(sc, reg, UGETDW(ucode));
2081
2082 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
2083 req.bRequest = RT2573_MCU_CNTL;
2084 USETW(req.wValue, RT2573_MCU_RUN);
2085 USETW(req.wIndex, 0);
2086 USETW(req.wLength, 0);
2087
2086 error = usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, NULL);
2088 error = rum_do_request(sc, &req, NULL);
2087 if (error != 0) {
2088 device_printf(sc->sc_dev, "could not run firmware: %s\n",
2089 usb2_errstr(error));
2090 }
2091 return error;
2092}
2093
2094static int

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

2286
2287static void
2288rum_scantask(struct usb2_proc_msg *pm)
2289{
2290 struct rum_task *task = (struct rum_task *)pm;
2291 struct rum_softc *sc = task->sc;
2292 struct ifnet *ifp = sc->sc_ifp;
2293 struct ieee80211com *ic = ifp->if_l2com;
2089 if (error != 0) {
2090 device_printf(sc->sc_dev, "could not run firmware: %s\n",
2091 usb2_errstr(error));
2092 }
2093 return error;
2094}
2095
2096static int

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

2288
2289static void
2290rum_scantask(struct usb2_proc_msg *pm)
2291{
2292 struct rum_task *task = (struct rum_task *)pm;
2293 struct rum_softc *sc = task->sc;
2294 struct ifnet *ifp = sc->sc_ifp;
2295 struct ieee80211com *ic = ifp->if_l2com;
2294 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2295 uint32_t tmp;
2296
2297 RUM_LOCK_ASSERT(sc, MA_OWNED);
2298
2296 uint32_t tmp;
2297
2298 RUM_LOCK_ASSERT(sc, MA_OWNED);
2299
2299 if (sc->sc_flags & RUM_FLAG_DETACH)
2300 return;
2301
2302 switch (sc->sc_scan_action) {
2303 case RUM_SCAN_START:
2304 /* abort TSF synchronization */
2305 tmp = rum_read(sc, RT2573_TXRX_CSR9);
2306 rum_write(sc, RT2573_TXRX_CSR9, tmp & ~0x00ffffff);
2307 rum_set_bssid(sc, ifp->if_broadcastaddr);
2308 break;
2309
2300 switch (sc->sc_scan_action) {
2301 case RUM_SCAN_START:
2302 /* abort TSF synchronization */
2303 tmp = rum_read(sc, RT2573_TXRX_CSR9);
2304 rum_write(sc, RT2573_TXRX_CSR9, tmp & ~0x00ffffff);
2305 rum_set_bssid(sc, ifp->if_broadcastaddr);
2306 break;
2307
2310 case RUM_SCAN_END:
2311 rum_enable_tsf_sync(sc);
2312 /* XXX keep local copy */
2313 rum_set_bssid(sc, vap->iv_bss->ni_bssid);
2314 break;
2315
2316 case RUM_SET_CHANNEL:
2317 rum_set_chan(sc, ic->ic_curchan);
2318 break;
2319
2308 case RUM_SET_CHANNEL:
2309 rum_set_chan(sc, ic->ic_curchan);
2310 break;
2311
2320 default:
2321 panic("unknown scan action %d\n", sc->sc_scan_action);
2322 /* NEVER REACHED */
2312 default: /* RUM_SCAN_END */
2313 rum_enable_tsf_sync(sc);
2314 rum_set_bssid(sc, sc->sc_bssid);
2323 break;
2324 }
2325}
2326
2327static int
2328rum_get_rssi(struct rum_softc *sc, uint8_t raw)
2329{
2330 struct ifnet *ifp = sc->sc_ifp;

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

2390 */
2391 task = (struct rum_task *)
2392 usb2_proc_msignal(&sc->sc_tq, t0, t1);
2393
2394 /* Setup callback and softc pointers */
2395 task->hdr.pm_callback = fn;
2396 task->sc = sc;
2397
2315 break;
2316 }
2317}
2318
2319static int
2320rum_get_rssi(struct rum_softc *sc, uint8_t raw)
2321{
2322 struct ifnet *ifp = sc->sc_ifp;

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

2382 */
2383 task = (struct rum_task *)
2384 usb2_proc_msignal(&sc->sc_tq, t0, t1);
2385
2386 /* Setup callback and softc pointers */
2387 task->hdr.pm_callback = fn;
2388 task->sc = sc;
2389
2390 /*
2391 * Init and stop must be synchronous!
2392 */
2393 if ((fn == rum_init_task) || (fn == rum_stop_task))
2394 usb2_proc_mwait(&sc->sc_tq, t0, t1);
2398}
2399
2400static device_method_t rum_methods[] = {
2401 /* Device interface */
2402 DEVMETHOD(device_probe, rum_match),
2403 DEVMETHOD(device_attach, rum_attach),
2404 DEVMETHOD(device_detach, rum_detach),
2405

--- 12 unchanged lines hidden --- 		2395}
2396
2397static device_method_t rum_methods[] = {
2398 /* Device interface */
2399 DEVMETHOD(device_probe, rum_match),
2400 DEVMETHOD(device_attach, rum_attach),
2401 DEVMETHOD(device_detach, rum_detach),
2402

--- 12 unchanged lines hidden ---