sys/dev/netif/ural/if_ural.c

   1 /*      $FreeBSD: src/sys/dev/usb/if_ural.c,v 1.10.2.8 2006/07/08 07:48:43 maxim Exp $  */
   2 /*      $DragonFly: src/sys/dev/netif/ural/if_ural.c,v 1.15 2007/06/28 13:55:12 hasso Exp $     */
   3
   4 /*-
   5  * Copyright (c) 2005, 2006
   6  *      Damien Bergamini <damien.bergamini@free.fr>
   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
  10  * copyright notice and this permission notice appear in all copies.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  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 /*-
  22  * Ralink Technology RT2500USB chipset driver
  23  * http://www.ralinktech.com/
  24  */
  25
  26 #include <sys/param.h>
  27 #include <sys/bus.h>
  28 #include <sys/endian.h>
  29 #include <sys/kernel.h>
  30 #include <sys/malloc.h>
  31 #include <sys/mbuf.h>
  32 #include <sys/rman.h>
  33 #include <sys/socket.h>
  34 #include <sys/sockio.h>
  35 #include <sys/sysctl.h>
  36
  37 #include <net/bpf.h>
  38 #include <net/ethernet.h>
  39 #include <net/if.h>
  40 #include <net/if_arp.h>
  41 #include <net/if_dl.h>
  42 #include <net/if_media.h>
  43 #include <net/ifq_var.h>
  44
  45 #include <netproto/802_11/ieee80211_var.h>
  46 #include <netproto/802_11/ieee80211_radiotap.h>
  47 #include <netproto/802_11/wlan_ratectl/onoe/ieee80211_onoe_param.h>
  48
  49 #include <bus/usb/usb.h>
  50 #include <bus/usb/usbdi.h>
  51 #include <bus/usb/usbdi_util.h>
  52 #include <bus/usb/usbdevs.h>
  53
  54 #include <dev/netif/ural/if_uralreg.h>
  55 #include <dev/netif/ural/if_uralvar.h>
  56
  57 #ifdef USB_DEBUG
  58 #define DPRINTF(x)      do { if (uraldebug > 0) kprintf x; } while (0)
  59 #define DPRINTFN(n, x)  do { if (uraldebug >= (n)) kprintf x; } while (0)
  60 int uraldebug = 0;
  61 SYSCTL_NODE(_hw_usb, OID_AUTO, ural, CTLFLAG_RW, 0, "USB ural");
  62 SYSCTL_INT(_hw_usb_ural, OID_AUTO, debug, CTLFLAG_RW, &uraldebug, 0,
  63     "ural debug level");
  64 #else
  65 #define DPRINTF(x)
  66 #define DPRINTFN(n, x)
  67 #endif
  68
  69 #define URAL_RSSI(rssi)                                 \
  70         ((rssi) > (RAL_NOISE_FLOOR + RAL_RSSI_CORR) ?   \
  71          ((rssi) - RAL_NOISE_FLOOR + RAL_RSSI_CORR) : 0)
  72
  73 /* various supported device vendors/products */
  74 static const struct usb_devno ural_devs[] = {
  75         { USB_VENDOR_ASUS,              USB_PRODUCT_ASUS_WL167G },
  76         { USB_VENDOR_ASUS,              USB_PRODUCT_RALINK_RT2570 },
  77         { USB_VENDOR_BELKIN,            USB_PRODUCT_BELKIN_F5D7050 },
  78         { USB_VENDOR_CONCEPTRONIC,      USB_PRODUCT_CONCEPTRONIC_C54U },
  79         { USB_VENDOR_DLINK,             USB_PRODUCT_DLINK_DWLG122 },
  80         { USB_VENDOR_GIGABYTE,          USB_PRODUCT_GIGABYTE_GNWBKG },
  81         { USB_VENDOR_GUILLEMOT,         USB_PRODUCT_GUILLEMOT_HWGUSB254 },
  82         { USB_VENDOR_LINKSYS4,          USB_PRODUCT_LINKSYS4_WUSB54G },
  83         { USB_VENDOR_LINKSYS4,          USB_PRODUCT_LINKSYS4_WUSB54GP },
  84         { USB_VENDOR_LINKSYS4,          USB_PRODUCT_LINKSYS4_HU200TS },
  85         { USB_VENDOR_MELCO,             USB_PRODUCT_MELCO_KG54 },
  86         { USB_VENDOR_MELCO,             USB_PRODUCT_MELCO_KG54AI },
  87         { USB_VENDOR_MELCO,             USB_PRODUCT_MELCO_KG54YB },
  88         { USB_VENDOR_MELCO,             USB_PRODUCT_MELCO_NINWIFI },
  89         { USB_VENDOR_MSI,               USB_PRODUCT_MSI_RT2570 },
  90         { USB_VENDOR_MSI,               USB_PRODUCT_MSI_RT2570_2 },
  91         { USB_VENDOR_MSI,               USB_PRODUCT_MSI_RT2570_3 },
  92         { USB_VENDOR_NOVATECH,          USB_PRODUCT_NOVATECH_NV902W },
  93         { USB_VENDOR_RALINK,            USB_PRODUCT_RALINK_RT2570 },
  94         { USB_VENDOR_RALINK,            USB_PRODUCT_RALINK_RT2570_2 },
  95         { USB_VENDOR_RALINK,            USB_PRODUCT_RALINK_RT2570_3 },
  96         { USB_VENDOR_SPHAIRON,          USB_PRODUCT_SPHAIRON_UB801R },
  97         { USB_VENDOR_SURECOM,           USB_PRODUCT_SURECOM_RT2570 },
  98         { USB_VENDOR_VTECH,             USB_PRODUCT_VTECH_RT2570 },
  99         { USB_VENDOR_ZINWELL,           USB_PRODUCT_ZINWELL_RT2570 }
 100 };
 101
 102 MODULE_DEPEND(ural, wlan, 1, 1, 1);
 103
 104 static int              ural_alloc_tx_list(struct ural_softc *);
 105 static void             ural_free_tx_list(struct ural_softc *);
 106 static int              ural_alloc_rx_list(struct ural_softc *);
 107 static void             ural_free_rx_list(struct ural_softc *);
 108 static int              ural_media_change(struct ifnet *);
 109 static void             ural_next_scan(void *);
 110 static void             ural_task(void *);
 111 static int              ural_newstate(struct ieee80211com *,
 112                             enum ieee80211_state, int);
 113 static int              ural_rxrate(struct ural_rx_desc *);
 114 static void             ural_txeof(usbd_xfer_handle, usbd_private_handle,
 115                             usbd_status);
 116 static void             ural_rxeof(usbd_xfer_handle, usbd_private_handle,
 117                             usbd_status);
 118 static uint8_t          ural_plcp_signal(int);
 119 static void             ural_setup_tx_desc(struct ural_softc *,
 120                             struct ural_tx_desc *, uint32_t, int, int);
 121 static int              ural_tx_bcn(struct ural_softc *, struct mbuf *,
 122                             struct ieee80211_node *);
 123 static int              ural_tx_mgt(struct ural_softc *, struct mbuf *,
 124                             struct ieee80211_node *);
 125 static int              ural_tx_data(struct ural_softc *, struct mbuf *,
 126                             struct ieee80211_node *);
 127 static void             ural_start(struct ifnet *);
 128 static void             ural_watchdog(struct ifnet *);
 129 static int              ural_reset(struct ifnet *);
 130 static int              ural_ioctl(struct ifnet *, u_long, caddr_t,
 131                             struct ucred *);
 132 static void             ural_set_testmode(struct ural_softc *);
 133 static void             ural_eeprom_read(struct ural_softc *, uint16_t, void *,
 134                             int);
 135 static uint16_t         ural_read(struct ural_softc *, uint16_t);
 136 static void             ural_read_multi(struct ural_softc *, uint16_t, void *,
 137                             int);
 138 static void             ural_write(struct ural_softc *, uint16_t, uint16_t);
 139 static void             ural_write_multi(struct ural_softc *, uint16_t, void *,
 140                             int) __unused;
 141 static void             ural_bbp_write(struct ural_softc *, uint8_t, uint8_t);
 142 static uint8_t          ural_bbp_read(struct ural_softc *, uint8_t);
 143 static void             ural_rf_write(struct ural_softc *, uint8_t, uint32_t);
 144 static void             ural_set_chan(struct ural_softc *,
 145                             struct ieee80211_channel *);
 146 static void             ural_disable_rf_tune(struct ural_softc *);
 147 static void             ural_enable_tsf_sync(struct ural_softc *);
 148 static void             ural_update_slot(struct ifnet *);
 149 static void             ural_set_txpreamble(struct ural_softc *);
 150 static void             ural_set_basicrates(struct ural_softc *);
 151 static void             ural_set_bssid(struct ural_softc *, uint8_t *);
 152 static void             ural_set_macaddr(struct ural_softc *, uint8_t *);
 153 static void             ural_update_promisc(struct ural_softc *);
 154 static const char       *ural_get_rf(int);
 155 static void             ural_read_eeprom(struct ural_softc *);
 156 static int              ural_bbp_init(struct ural_softc *);
 157 static void             ural_set_txantenna(struct ural_softc *, int);
 158 static void             ural_set_rxantenna(struct ural_softc *, int);
 159 static void             ural_init(void *);
 160 static void             ural_stop(struct ural_softc *);
 161 static void             ural_stats(struct ieee80211com *,
 162                                    struct ieee80211_node *,
 163                                    struct ieee80211_ratectl_stats *);
 164 static void             ural_stats_update(usbd_xfer_handle,
 165                                           usbd_private_handle, usbd_status);
 166 static void             ural_stats_timeout(void *);
 167 static void             ural_ratectl_change(struct ieee80211com *ic, u_int,
 168                                             u_int);
 169
 170 /*
 171  * Supported rates for 802.11a/b/g modes (in 500Kbps unit).
 172  */
 173 static const struct ieee80211_rateset ural_rateset_11a =
 174         { 8, { 12, 18, 24, 36, 48, 72, 96, 108 } };
 175
 176 static const struct ieee80211_rateset ural_rateset_11b =
 177         { 4, { 2, 4, 11, 22 } };
 178
 179 static const struct ieee80211_rateset ural_rateset_11g =
 180         { 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } };
 181
 182 /*
 183  * Default values for MAC registers; values taken from the reference driver.
 184  */
 185 static const struct {
 186         uint16_t        reg;
 187         uint16_t        val;
 188 } ural_def_mac[] = {
 189         { RAL_TXRX_CSR5,  0x8c8d },
 190         { RAL_TXRX_CSR6,  0x8b8a },
 191         { RAL_TXRX_CSR7,  0x8687 },
 192         { RAL_TXRX_CSR8,  0x0085 },
 193         { RAL_MAC_CSR13,  0x1111 },
 194         { RAL_MAC_CSR14,  0x1e11 },
 195         { RAL_TXRX_CSR21, 0xe78f },
 196         { RAL_MAC_CSR9,   0xff1d },
 197         { RAL_MAC_CSR11,  0x0002 },
 198         { RAL_MAC_CSR22,  0x0053 },
 199         { RAL_MAC_CSR15,  0x0000 },
 200         { RAL_MAC_CSR8,   0x0780 },
 201         { RAL_TXRX_CSR19, 0x0000 },
 202         { RAL_TXRX_CSR18, 0x005a },
 203         { RAL_PHY_CSR2,   0x0000 },
 204         { RAL_TXRX_CSR0,  0x1ec0 },
 205         { RAL_PHY_CSR4,   0x000f }
 206 };
 207
 208 /*
 209  * Default values for BBP registers; values taken from the reference driver.
 210  */
 211 static const struct {
 212         uint8_t reg;
 213         uint8_t val;
 214 } ural_def_bbp[] = {
 215         {  3, 0x02 },
 216         {  4, 0x19 },
 217         { 14, 0x1c },
 218         { 15, 0x30 },
 219         { 16, 0xac },
 220         { 17, 0x48 },
 221         { 18, 0x18 },
 222         { 19, 0xff },
 223         { 20, 0x1e },
 224         { 21, 0x08 },
 225         { 22, 0x08 },
 226         { 23, 0x08 },
 227         { 24, 0x80 },
 228         { 25, 0x50 },
 229         { 26, 0x08 },
 230         { 27, 0x23 },
 231         { 30, 0x10 },
 232         { 31, 0x2b },
 233         { 32, 0xb9 },
 234         { 34, 0x12 },
 235         { 35, 0x50 },
 236         { 39, 0xc4 },
 237         { 40, 0x02 },
 238         { 41, 0x60 },
 239         { 53, 0x10 },
 240         { 54, 0x18 },
 241         { 56, 0x08 },
 242         { 57, 0x10 },
 243         { 58, 0x08 },
 244         { 61, 0x60 },
 245         { 62, 0x10 },
 246         { 75, 0xff }
 247 };
 248
 249 /*
 250  * Default values for RF register R2 indexed by channel numbers.
 251  */
 252 static const uint32_t ural_rf2522_r2[] = {
 253         0x307f6, 0x307fb, 0x30800, 0x30805, 0x3080a, 0x3080f, 0x30814,
 254         0x30819, 0x3081e, 0x30823, 0x30828, 0x3082d, 0x30832, 0x3083e
 255 };
 256
 257 static const uint32_t ural_rf2523_r2[] = {
 258         0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
 259         0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
 260 };
 261
 262 static const uint32_t ural_rf2524_r2[] = {
 263         0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
 264         0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
 265 };
 266
 267 static const uint32_t ural_rf2525_r2[] = {
 268         0x20327, 0x20328, 0x20329, 0x2032a, 0x2032b, 0x2032c, 0x2032d,
 269         0x2032e, 0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20346
 270 };
 271
 272 static const uint32_t ural_rf2525_hi_r2[] = {
 273         0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20344, 0x20345,
 274         0x20346, 0x20347, 0x20348, 0x20349, 0x2034a, 0x2034b, 0x2034e
 275 };
 276
 277 static const uint32_t ural_rf2525e_r2[] = {
 278         0x2044d, 0x2044e, 0x2044f, 0x20460, 0x20461, 0x20462, 0x20463,
 279         0x20464, 0x20465, 0x20466, 0x20467, 0x20468, 0x20469, 0x2046b
 280 };
 281
 282 static const uint32_t ural_rf2526_hi_r2[] = {
 283         0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d, 0x0022d,
 284         0x0022e, 0x0022e, 0x0022f, 0x0022d, 0x00240, 0x00240, 0x00241
 285 };
 286
 287 static const uint32_t ural_rf2526_r2[] = {
 288         0x00226, 0x00227, 0x00227, 0x00228, 0x00228, 0x00229, 0x00229,
 289         0x0022a, 0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d
 290 };
 291
 292 /*
 293  * For dual-band RF, RF registers R1 and R4 also depend on channel number;
 294  * values taken from the reference driver.
 295  */
 296 static const struct {
 297         uint8_t         chan;
 298         uint32_t        r1;
 299         uint32_t        r2;
 300         uint32_t        r4;
 301 } ural_rf5222[] = {
 302         {   1, 0x08808, 0x0044d, 0x00282 },
 303         {   2, 0x08808, 0x0044e, 0x00282 },
 304         {   3, 0x08808, 0x0044f, 0x00282 },
 305         {   4, 0x08808, 0x00460, 0x00282 },
 306         {   5, 0x08808, 0x00461, 0x00282 },
 307         {   6, 0x08808, 0x00462, 0x00282 },
 308         {   7, 0x08808, 0x00463, 0x00282 },
 309         {   8, 0x08808, 0x00464, 0x00282 },
 310         {   9, 0x08808, 0x00465, 0x00282 },
 311         {  10, 0x08808, 0x00466, 0x00282 },
 312         {  11, 0x08808, 0x00467, 0x00282 },
 313         {  12, 0x08808, 0x00468, 0x00282 },
 314         {  13, 0x08808, 0x00469, 0x00282 },
 315         {  14, 0x08808, 0x0046b, 0x00286 },
 316
 317         {  36, 0x08804, 0x06225, 0x00287 },
 318         {  40, 0x08804, 0x06226, 0x00287 },
 319         {  44, 0x08804, 0x06227, 0x00287 },
 320         {  48, 0x08804, 0x06228, 0x00287 },
 321         {  52, 0x08804, 0x06229, 0x00287 },
 322         {  56, 0x08804, 0x0622a, 0x00287 },
 323         {  60, 0x08804, 0x0622b, 0x00287 },
 324         {  64, 0x08804, 0x0622c, 0x00287 },
 325
 326         { 100, 0x08804, 0x02200, 0x00283 },
 327         { 104, 0x08804, 0x02201, 0x00283 },
 328         { 108, 0x08804, 0x02202, 0x00283 },
 329         { 112, 0x08804, 0x02203, 0x00283 },
 330         { 116, 0x08804, 0x02204, 0x00283 },
 331         { 120, 0x08804, 0x02205, 0x00283 },
 332         { 124, 0x08804, 0x02206, 0x00283 },
 333         { 128, 0x08804, 0x02207, 0x00283 },
 334         { 132, 0x08804, 0x02208, 0x00283 },
 335         { 136, 0x08804, 0x02209, 0x00283 },
 336         { 140, 0x08804, 0x0220a, 0x00283 },
 337
 338         { 149, 0x08808, 0x02429, 0x00281 },
 339         { 153, 0x08808, 0x0242b, 0x00281 },
 340         { 157, 0x08808, 0x0242d, 0x00281 },
 341         { 161, 0x08808, 0x0242f, 0x00281 }
 342 };
 343
 344 USB_DECLARE_DRIVER(ural);
 345
 346 USB_MATCH(ural)
 347 {
 348         USB_MATCH_START(ural, uaa);
 349
 350         if (uaa->iface != NULL)
 351                 return UMATCH_NONE;
 352
 353         return (usb_lookup(ural_devs, uaa->vendor, uaa->product) != NULL) ?
 354             UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
 355 }
 356
 357 USB_ATTACH(ural)
 358 {
 359         USB_ATTACH_START(ural, sc, uaa);
 360         struct ifnet *ifp;
 361         struct ieee80211com *ic = &sc->sc_ic;
 362         usb_interface_descriptor_t *id;
 363         usb_endpoint_descriptor_t *ed;
 364         usbd_status error;
 365         char devinfo[1024];
 366         int i;
 367
 368         sc->sc_udev = uaa->device;
 369         sc->sc_tx_retries = 7;  /* TODO tunable/sysctl */
 370
 371         usbd_devinfo(sc->sc_udev, 0, devinfo);
 372         USB_ATTACH_SETUP;
 373
 374         if (usbd_set_config_no(sc->sc_udev, RAL_CONFIG_NO, 0) != 0) {
 375                 kprintf("%s: could not set configuration no\n",
 376                     device_get_nameunit(sc->sc_dev));
 377                 USB_ATTACH_ERROR_RETURN;
 378         }
 379
 380         /* get the first interface handle */
 381         error = usbd_device2interface_handle(sc->sc_udev, RAL_IFACE_INDEX,
 382             &sc->sc_iface);
 383         if (error != 0) {
 384                 kprintf("%s: could not get interface handle\n",
 385                     device_get_nameunit(sc->sc_dev));
 386                 USB_ATTACH_ERROR_RETURN;
 387         }
 388
 389         /*
 390          * Find endpoints.
 391          */
 392         id = usbd_get_interface_descriptor(sc->sc_iface);
 393
 394         sc->sc_rx_no = sc->sc_tx_no = -1;
 395         for (i = 0; i < id->bNumEndpoints; i++) {
 396                 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
 397                 if (ed == NULL) {
 398                         kprintf("%s: no endpoint descriptor for %d\n",
 399                             device_get_nameunit(sc->sc_dev), i);
 400                         USB_ATTACH_ERROR_RETURN;
 401                 }
 402
 403                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 404                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 405                         sc->sc_rx_no = ed->bEndpointAddress;
 406                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 407                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 408                         sc->sc_tx_no = ed->bEndpointAddress;
 409         }
 410         if (sc->sc_rx_no == -1 || sc->sc_tx_no == -1) {
 411                 kprintf("%s: missing endpoint\n", device_get_nameunit(sc->sc_dev));
 412                 USB_ATTACH_ERROR_RETURN;
 413         }
 414
 415         usb_init_task(&sc->sc_task, ural_task, sc);
 416         callout_init(&sc->scan_ch);
 417         callout_init(&sc->stats_ch);
 418
 419         /* retrieve RT2570 rev. no */
 420         sc->asic_rev = ural_read(sc, RAL_MAC_CSR0);
 421
 422         /* retrieve MAC address and various other things from EEPROM */
 423         ural_read_eeprom(sc);
 424
 425         kprintf("%s: MAC/BBP RT2570 (rev 0x%02x), RF %s\n",
 426             device_get_nameunit(sc->sc_dev), sc->asic_rev, ural_get_rf(sc->rf_rev));
 427
 428         ifp = &ic->ic_if;
 429         ifp->if_softc = sc;
 430         if_initname(ifp, "ural", device_get_unit(sc->sc_dev));
 431         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 432         ifp->if_init = ural_init;
 433         ifp->if_ioctl = ural_ioctl;
 434         ifp->if_start = ural_start;
 435         ifp->if_watchdog = ural_watchdog;
 436         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 437         ifq_set_ready(&ifp->if_snd);
 438
 439         ic->ic_ratectl.rc_st_ratectl_cap = IEEE80211_RATECTL_CAP_ONOE;
 440         ic->ic_ratectl.rc_st_ratectl = IEEE80211_RATECTL_ONOE;
 441         ic->ic_ratectl.rc_st_valid_stats =
 442                 IEEE80211_RATECTL_STATS_PKT_NORETRY |
 443                 IEEE80211_RATECTL_STATS_PKT_OK |
 444                 IEEE80211_RATECTL_STATS_PKT_ERR |
 445                 IEEE80211_RATECTL_STATS_RETRIES;
 446         ic->ic_ratectl.rc_st_stats = ural_stats;
 447         ic->ic_ratectl.rc_st_change = ural_ratectl_change;
 448
 449         ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
 450         ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
 451         ic->ic_state = IEEE80211_S_INIT;
 452
 453         /* set device capabilities */
 454         ic->ic_caps =
 455             IEEE80211_C_IBSS |          /* IBSS mode supported */
 456             IEEE80211_C_MONITOR |       /* monitor mode supported */
 457             IEEE80211_C_HOSTAP |        /* HostAp mode supported */
 458             IEEE80211_C_TXPMGT |        /* tx power management */
 459             IEEE80211_C_SHPREAMBLE |    /* short preamble supported */
 460             IEEE80211_C_SHSLOT |        /* short slot time supported */
 461             IEEE80211_C_WPA;            /* 802.11i */
 462
 463         if (sc->rf_rev == RAL_RF_5222) {
 464                 /* set supported .11a rates */
 465                 ic->ic_sup_rates[IEEE80211_MODE_11A] = ural_rateset_11a;
 466
 467                 /* set supported .11a channels */
 468                 for (i = 36; i <= 64; i += 4) {
 469                         ic->ic_channels[i].ic_freq =
 470                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
 471                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
 472                 }
 473                 for (i = 100; i <= 140; i += 4) {
 474                         ic->ic_channels[i].ic_freq =
 475                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
 476                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
 477                 }
 478                 for (i = 149; i <= 161; i += 4) {
 479                         ic->ic_channels[i].ic_freq =
 480                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
 481                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
 482                 }
 483         }
 484
 485         /* set supported .11b and .11g rates */
 486         ic->ic_sup_rates[IEEE80211_MODE_11B] = ural_rateset_11b;
 487         ic->ic_sup_rates[IEEE80211_MODE_11G] = ural_rateset_11g;
 488
 489         /* set supported .11b and .11g channels (1 through 14) */
 490         for (i = 1; i <= 14; i++) {
 491                 ic->ic_channels[i].ic_freq =
 492                     ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
 493                 ic->ic_channels[i].ic_flags =
 494                     IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
 495                     IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
 496         }
 497
 498         sc->sc_sifs = IEEE80211_DUR_SIFS;       /* Default SIFS */
 499
 500         ieee80211_ifattach(ic);
 501         ic->ic_reset = ural_reset;
 502         /* enable s/w bmiss handling in sta mode */
 503         ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS;
 504
 505         /* override state transition machine */
 506         sc->sc_newstate = ic->ic_newstate;
 507         ic->ic_newstate = ural_newstate;
 508         ieee80211_media_init(ic, ural_media_change, ieee80211_media_status);
 509
 510         bpfattach_dlt(ifp, DLT_IEEE802_11_RADIO,
 511             sizeof(struct ieee80211_frame) + 64, &sc->sc_drvbpf);
 512
 513         sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
 514         sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
 515         sc->sc_rxtap.wr_ihdr.it_present = htole32(RAL_RX_RADIOTAP_PRESENT);
 516
 517         sc->sc_txtap_len = sizeof sc->sc_txtapu;
 518         sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
 519         sc->sc_txtap.wt_ihdr.it_present = htole32(RAL_TX_RADIOTAP_PRESENT);
 520
 521         if (bootverbose)
 522                 ieee80211_announce(ic);
 523
 524         USB_ATTACH_SUCCESS_RETURN;
 525 }
 526
 527 USB_DETACH(ural)
 528 {
 529         USB_DETACH_START(ural, sc);
 530         struct ieee80211com *ic = &sc->sc_ic;
 531         struct ifnet *ifp = &ic->ic_if;
 532 #ifdef INVARIANTS
 533         int i;
 534 #endif
 535
 536         crit_enter();
 537
 538         callout_stop(&sc->scan_ch);
 539         callout_stop(&sc->stats_ch);
 540
 541         lwkt_serialize_enter(ifp->if_serializer);
 542         ural_stop(sc);
 543         lwkt_serialize_exit(ifp->if_serializer);
 544
 545         usb_rem_task(sc->sc_udev, &sc->sc_task);
 546
 547         bpfdetach(ifp);
 548         ieee80211_ifdetach(ic);
 549
 550         crit_exit();
 551
 552         KKASSERT(sc->stats_xfer == NULL);
 553         KKASSERT(sc->sc_rx_pipeh == NULL);
 554         KKASSERT(sc->sc_tx_pipeh == NULL);
 555
 556 #ifdef INVARIANTS
 557         /*
 558          * Make sure TX/RX list is empty
 559          */
 560         for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
 561                 struct ural_tx_data *data = &sc->tx_data[i];
 562
 563                 KKASSERT(data->xfer == NULL);
 564                 KKASSERT(data->ni == NULL);
 565                 KKASSERT(data->m == NULL);
 566         }
 567         for (i = 0; i < RAL_RX_LIST_COUNT; i++) {
 568                 struct ural_rx_data *data = &sc->rx_data[i];
 569
 570                 KKASSERT(data->xfer == NULL);
 571                 KKASSERT(data->m == NULL);
 572         }
 573 #endif
 574
 575         return 0;
 576 }
 577
 578 static int
 579 ural_alloc_tx_list(struct ural_softc *sc)
 580 {
 581         int i;
 582
 583         sc->tx_queued = 0;
 584
 585         for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
 586                 struct ural_tx_data *data = &sc->tx_data[i];
 587
 588                 data->sc = sc;
 589
 590                 data->xfer = usbd_alloc_xfer(sc->sc_udev);
 591                 if (data->xfer == NULL) {
 592                         kprintf("%s: could not allocate tx xfer\n",
 593                             device_get_nameunit(sc->sc_dev));
 594                         return ENOMEM;
 595                 }
 596
 597                 data->buf = usbd_alloc_buffer(data->xfer,
 598                     RAL_TX_DESC_SIZE + MCLBYTES);
 599                 if (data->buf == NULL) {
 600                         kprintf("%s: could not allocate tx buffer\n",
 601                             device_get_nameunit(sc->sc_dev));
 602                         return ENOMEM;
 603                 }
 604         }
 605         return 0;
 606 }
 607
 608 static void
 609 ural_free_tx_list(struct ural_softc *sc)
 610 {
 611         int i;
 612
 613         for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
 614                 struct ural_tx_data *data = &sc->tx_data[i];
 615
 616                 if (data->xfer != NULL) {
 617                         usbd_free_xfer(data->xfer);
 618                         data->xfer = NULL;
 619                 }
 620
 621                 if (data->ni != NULL) {
 622                         ieee80211_free_node(data->ni);
 623                         data->ni = NULL;
 624                 }
 625                 if (data->m != NULL) {
 626                         m_freem(data->m);
 627                         data->m = NULL;
 628                 }
 629         }
 630         sc->tx_queued = 0;
 631 }
 632
 633 static int
 634 ural_alloc_rx_list(struct ural_softc *sc)
 635 {
 636         int i;
 637
 638         for (i = 0; i < RAL_RX_LIST_COUNT; i++) {
 639                 struct ural_rx_data *data = &sc->rx_data[i];
 640
 641                 data->sc = sc;
 642
 643                 data->xfer = usbd_alloc_xfer(sc->sc_udev);
 644                 if (data->xfer == NULL) {
 645                         kprintf("%s: could not allocate rx xfer\n",
 646                             device_get_nameunit(sc->sc_dev));
 647                         return ENOMEM;
 648                 }
 649
 650                 if (usbd_alloc_buffer(data->xfer, MCLBYTES) == NULL) {
 651                         kprintf("%s: could not allocate rx buffer\n",
 652                             device_get_nameunit(sc->sc_dev));
 653                         return ENOMEM;
 654                 }
 655
 656                 data->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 657                 if (data->m == NULL) {
 658                         kprintf("%s: could not allocate rx mbuf\n",
 659                             device_get_nameunit(sc->sc_dev));
 660                         return ENOMEM;
 661                 }
 662
 663                 data->buf = mtod(data->m, uint8_t *);
 664         }
 665         return 0;
 666 }
 667
 668 static void
 669 ural_free_rx_list(struct ural_softc *sc)
 670 {
 671         int i;
 672
 673         for (i = 0; i < RAL_RX_LIST_COUNT; i++) {
 674                 struct ural_rx_data *data = &sc->rx_data[i];
 675
 676                 if (data->xfer != NULL) {
 677                         usbd_free_xfer(data->xfer);
 678                         data->xfer = NULL;
 679                 }
 680
 681                 if (data->m != NULL) {
 682                         m_freem(data->m);
 683                         data->m = NULL;
 684                 }
 685         }
 686 }
 687
 688 static int
 689 ural_media_change(struct ifnet *ifp)
 690 {
 691         struct ural_softc *sc = ifp->if_softc;
 692         int error;
 693
 694         error = ieee80211_media_change(ifp);
 695         if (error != ENETRESET)
 696                 return error;
 697
 698         if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
 699                 ural_init(sc);
 700
 701         return 0;
 702 }
 703
 704 /*
 705  * This function is called periodically (every 200ms) during scanning to
 706  * switch from one channel to another.
 707  */
 708 static void
 709 ural_next_scan(void *arg)
 710 {
 711         struct ural_softc *sc = arg;
 712         struct ieee80211com *ic = &sc->sc_ic;
 713         struct ifnet *ifp = &ic->ic_if;
 714
 715         if (sc->sc_stopped)
 716                 return;
 717
 718         crit_enter();
 719
 720         if (ic->ic_state == IEEE80211_S_SCAN) {
 721                 lwkt_serialize_enter(ifp->if_serializer);
 722                 ieee80211_next_scan(ic);
 723                 lwkt_serialize_exit(ifp->if_serializer);
 724         }
 725
 726         crit_exit();
 727 }
 728
 729 static void
 730 ural_task(void *xarg)
 731 {
 732         struct ural_softc *sc = xarg;
 733         struct ieee80211com *ic = &sc->sc_ic;
 734         struct ifnet *ifp = &ic->ic_if;
 735         enum ieee80211_state nstate;
 736         struct ieee80211_node *ni;
 737         struct mbuf *m;
 738         int arg;
 739
 740         if (sc->sc_stopped)
 741                 return;
 742
 743         crit_enter();
 744
 745         nstate = sc->sc_state;
 746         arg = sc->sc_arg;
 747
 748         KASSERT(nstate != IEEE80211_S_INIT,
 749                 ("->INIT state transition should not be defered\n"));
 750         ural_set_chan(sc, ic->ic_curchan);
 751
 752         switch (sc->sc_state) {
 753         case IEEE80211_S_RUN:
 754                 ni = ic->ic_bss;
 755
 756                 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
 757                         ural_update_slot(&ic->ic_if);
 758                         ural_set_txpreamble(sc);
 759                         ural_set_basicrates(sc);
 760                         ural_set_bssid(sc, ni->ni_bssid);
 761                 }
 762
 763                 if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
 764                     ic->ic_opmode == IEEE80211_M_IBSS) {
 765                         lwkt_serialize_enter(ifp->if_serializer);
 766                         m = ieee80211_beacon_alloc(ic, ni, &sc->sc_bo);
 767                         lwkt_serialize_exit(ifp->if_serializer);
 768
 769                         if (m == NULL) {
 770                                 kprintf("%s: could not allocate beacon\n",
 771                                     device_get_nameunit(sc->sc_dev));
 772                                 crit_exit();
 773                                 return;
 774                         }
 775
 776                         if (ural_tx_bcn(sc, m, ni) != 0) {
 777                                 kprintf("%s: could not send beacon\n",
 778                                     device_get_nameunit(sc->sc_dev));
 779                                 crit_exit();
 780                                 return;
 781                         }
 782                 }
 783
 784                 /* make tx led blink on tx (controlled by ASIC) */
 785                 ural_write(sc, RAL_MAC_CSR20, 1);
 786
 787                 if (ic->ic_opmode != IEEE80211_M_MONITOR)
 788                         ural_enable_tsf_sync(sc);
 789
 790                 /* clear statistic registers (STA_CSR0 to STA_CSR10) */
 791                 ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof(sc->sta));
 792
 793                 callout_reset(&sc->stats_ch, 4 * hz / 5,
 794                               ural_stats_timeout, sc);
 795                 break;
 796
 797         case IEEE80211_S_SCAN:
 798                 callout_reset(&sc->scan_ch, hz / 5, ural_next_scan, sc);
 799                 break;
 800
 801         default:
 802                 break;
 803         }
 804
 805         lwkt_serialize_enter(ifp->if_serializer);
 806         ieee80211_ratectl_newstate(ic, sc->sc_state);
 807         sc->sc_newstate(ic, sc->sc_state, arg);
 808         lwkt_serialize_exit(ifp->if_serializer);
 809
 810         crit_exit();
 811 }
 812
 813 static int
 814 ural_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
 815 {
 816         struct ifnet *ifp = &ic->ic_if;
 817         struct ural_softc *sc = ifp->if_softc;
 818
 819         ASSERT_SERIALIZED(ifp->if_serializer);
 820
 821         crit_enter();
 822
 823         callout_stop(&sc->scan_ch);
 824         callout_stop(&sc->stats_ch);
 825
 826         /* do it in a process context */
 827         sc->sc_state = nstate;
 828         sc->sc_arg = arg;
 829
 830         lwkt_serialize_exit(ifp->if_serializer);
 831         usb_rem_task(sc->sc_udev, &sc->sc_task);
 832
 833         if (nstate == IEEE80211_S_INIT) {
 834                 lwkt_serialize_enter(ifp->if_serializer);
 835                 ieee80211_ratectl_newstate(ic, nstate);
 836                 sc->sc_newstate(ic, nstate, arg);
 837         } else {
 838                 usb_add_task(sc->sc_udev, &sc->sc_task, USB_TASKQ_DRIVER);
 839                 lwkt_serialize_enter(ifp->if_serializer);
 840         }
 841
 842         crit_exit();
 843         return 0;
 844 }
 845
 846 /* quickly determine if a given rate is CCK or OFDM */
 847 #define RAL_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
 848
 849 #define RAL_ACK_SIZE    (sizeof(struct ieee80211_frame_ack) + IEEE80211_FCS_LEN)
 850
 851 #define RAL_RXTX_TURNAROUND     5       /* us */
 852
 853 /*
 854  * This function is only used by the Rx radiotap code.
 855  */
 856 static int
 857 ural_rxrate(struct ural_rx_desc *desc)
 858 {
 859         if (le32toh(desc->flags) & RAL_RX_OFDM) {
 860                 /* reverse function of ural_plcp_signal */
 861                 switch (desc->rate) {
 862                 case 0xb:       return 12;
 863                 case 0xf:       return 18;
 864                 case 0xa:       return 24;
 865                 case 0xe:       return 36;
 866                 case 0x9:       return 48;
 867                 case 0xd:       return 72;
 868                 case 0x8:       return 96;
 869                 case 0xc:       return 108;
 870                 }
 871         } else {
 872                 if (desc->rate == 10)
 873                         return 2;
 874                 if (desc->rate == 20)
 875                         return 4;
 876                 if (desc->rate == 55)
 877                         return 11;
 878                 if (desc->rate == 110)
 879                         return 22;
 880         }
 881         return 2;       /* should not get there */
 882 }
 883
 884 static void
 885 ural_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 886 {
 887         struct ural_tx_data *data = priv;
 888         struct ural_softc *sc = data->sc;
 889         struct ieee80211_node *ni;
 890         struct ifnet *ifp = &sc->sc_ic.ic_if;
 891
 892         if (sc->sc_stopped)
 893                 return;
 894
 895         crit_enter();
 896
 897         if (status != USBD_NORMAL_COMPLETION) {
 898                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 899                         crit_exit();
 900                         return;
 901                 }
 902
 903                 kprintf("%s: could not transmit buffer: %s\n",
 904                     device_get_nameunit(sc->sc_dev), usbd_errstr(status));
 905
 906                 if (status == USBD_STALLED)
 907                         usbd_clear_endpoint_stall_async(sc->sc_rx_pipeh);
 908
 909                 ifp->if_oerrors++;
 910                 crit_exit();
 911                 return;
 912         }
 913
 914         m_freem(data->m);
 915         data->m = NULL;
 916         ni = data->ni;
 917         data->ni = NULL;
 918
 919         sc->tx_queued--;
 920         ifp->if_opackets++;
 921
 922         DPRINTFN(10, ("tx done\n"));
 923
 924         sc->sc_tx_timer = 0;
 925         ifp->if_flags &= ~IFF_OACTIVE;
 926
 927         lwkt_serialize_enter(ifp->if_serializer);
 928         ieee80211_free_node(ni);
 929         ifp->if_start(ifp);
 930         lwkt_serialize_exit(ifp->if_serializer);
 931
 932         crit_exit();
 933 }
 934
 935 static void
 936 ural_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 937 {
 938         struct ural_rx_data *data = priv;
 939         struct ural_softc *sc = data->sc;
 940         struct ieee80211com *ic = &sc->sc_ic;
 941         struct ifnet *ifp = &ic->ic_if;
 942         struct ural_rx_desc *desc;
 943         struct ieee80211_frame *wh;
 944         struct ieee80211_node *ni;
 945         struct mbuf *mnew, *m;
 946         int len;
 947
 948         if (sc->sc_stopped)
 949                 return;
 950
 951         crit_enter();
 952
 953         if (status != USBD_NORMAL_COMPLETION) {
 954                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 955                         crit_exit();
 956                         return;
 957                 }
 958
 959                 if (status == USBD_STALLED)
 960                         usbd_clear_endpoint_stall_async(sc->sc_rx_pipeh);
 961                 goto skip;
 962         }
 963
 964         usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
 965
 966         if (len < RAL_RX_DESC_SIZE + IEEE80211_MIN_LEN) {
 967                 DPRINTF(("%s: xfer too short %d\n", device_get_nameunit(sc->sc_dev),
 968                     len));
 969                 ifp->if_ierrors++;
 970                 goto skip;
 971         }
 972
 973         /* rx descriptor is located at the end */
 974         desc = (struct ural_rx_desc *)(data->buf + len - RAL_RX_DESC_SIZE);
 975
 976         if ((le32toh(desc->flags) & RAL_RX_PHY_ERROR) ||
 977             (le32toh(desc->flags) & RAL_RX_CRC_ERROR)) {
 978                 /*
 979                  * This should not happen since we did not request to receive
 980                  * those frames when we filled RAL_TXRX_CSR2.
 981                  */
 982                 DPRINTFN(5, ("PHY or CRC error\n"));
 983                 ifp->if_ierrors++;
 984                 goto skip;
 985         }
 986
 987         mnew = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 988         if (mnew == NULL) {
 989                 ifp->if_ierrors++;
 990                 goto skip;
 991         }
 992
 993         m = data->m;
 994         data->m = NULL;
 995         data->buf = NULL;
 996
 997         lwkt_serialize_enter(ifp->if_serializer);
 998
 999         /* finalize mbuf */
1000         m->m_pkthdr.rcvif = ifp;
1001         m->m_pkthdr.len = m->m_len = (le32toh(desc->flags) >> 16) & 0xfff;
1002
1003         if (sc->sc_drvbpf != NULL) {
1004                 struct ural_rx_radiotap_header *tap = &sc->sc_rxtap;
1005
1006                 tap->wr_flags = IEEE80211_RADIOTAP_F_FCS; /* h/w leaves FCS */
1007                 tap->wr_rate = ural_rxrate(desc);
1008                 tap->wr_chan_freq = htole16(ic->ic_curchan->ic_freq);
1009                 tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags);
1010                 tap->wr_antenna = sc->rx_ant;
1011                 tap->wr_antsignal = URAL_RSSI(desc->rssi);
1012
1013                 bpf_ptap(sc->sc_drvbpf, m, tap, sc->sc_rxtap_len);
1014         }
1015
1016         /* trim CRC here so WEP can find its own CRC at the end of packet. */
1017         m_adj(m, -IEEE80211_CRC_LEN);
1018
1019         wh = mtod(m, struct ieee80211_frame *);
1020         ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);
1021
1022         /* send the frame to the 802.11 layer */
1023         ieee80211_input(ic, m, ni, URAL_RSSI(desc->rssi), 0);
1024
1025         /* node is no longer needed */
1026         ieee80211_free_node(ni);
1027
1028         lwkt_serialize_exit(ifp->if_serializer);
1029
1030         data->m = mnew;
1031         data->buf = mtod(data->m, uint8_t *);
1032
1033         DPRINTFN(15, ("rx done\n"));
1034
1035 skip:   /* setup a new transfer */
1036         usbd_setup_xfer(xfer, sc->sc_rx_pipeh, data, data->buf, MCLBYTES,
1037             USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, ural_rxeof);
1038         usbd_transfer(xfer);
1039
1040         crit_exit();
1041 }
1042
1043 static uint8_t
1044 ural_plcp_signal(int rate)
1045 {
1046         switch (rate) {
1047         /* CCK rates (returned values are device-dependent) */
1048         case 2:         return 0x0;
1049         case 4:         return 0x1;
1050         case 11:        return 0x2;
1051         case 22:        return 0x3;
1052
1053         /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
1054         case 12:        return 0xb;
1055         case 18:        return 0xf;
1056         case 24:        return 0xa;
1057         case 36:        return 0xe;
1058         case 48:        return 0x9;
1059         case 72:        return 0xd;
1060         case 96:        return 0x8;
1061         case 108:       return 0xc;
1062
1063         /* unsupported rates (should not get there) */
1064         default:        return 0xff;
1065         }
1066 }
1067
1068 static void
1069 ural_setup_tx_desc(struct ural_softc *sc, struct ural_tx_desc *desc,
1070     uint32_t flags, int len, int rate)
1071 {
1072         struct ieee80211com *ic = &sc->sc_ic;
1073         uint16_t plcp_length;
1074         int remainder;
1075
1076         desc->flags = htole32(flags);
1077         desc->flags |= htole32(RAL_TX_NEWSEQ);
1078         desc->flags |= htole32(len << 16);
1079
1080         desc->wme = htole16(RAL_AIFSN(2) | RAL_LOGCWMIN(3) | RAL_LOGCWMAX(5));
1081         desc->wme |= htole16(RAL_IVOFFSET(sizeof (struct ieee80211_frame)));
1082
1083         /* setup PLCP fields */
1084         desc->plcp_signal  = ural_plcp_signal(rate);
1085         desc->plcp_service = 4;
1086
1087         len += IEEE80211_CRC_LEN;
1088         if (RAL_RATE_IS_OFDM(rate)) {
1089                 desc->flags |= htole32(RAL_TX_OFDM);
1090
1091                 plcp_length = len & 0xfff;
1092                 desc->plcp_length_hi = plcp_length >> 6;
1093                 desc->plcp_length_lo = plcp_length & 0x3f;
1094         } else {
1095                 plcp_length = (16 * len + rate - 1) / rate;
1096                 if (rate == 22) {
1097                         remainder = (16 * len) % 22;
1098                         if (remainder != 0 && remainder < 7)
1099                                 desc->plcp_service |= RAL_PLCP_LENGEXT;
1100                 }
1101                 desc->plcp_length_hi = plcp_length >> 8;
1102                 desc->plcp_length_lo = plcp_length & 0xff;
1103
1104                 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
1105                         desc->plcp_signal |= 0x08;
1106         }
1107
1108         desc->iv = 0;
1109         desc->eiv = 0;
1110 }
1111
1112 #define RAL_TX_TIMEOUT  5000
1113
1114 static int
1115 ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
1116 {
1117         struct ural_tx_desc *desc;
1118         usbd_xfer_handle xfer;
1119         uint8_t cmd = 0;
1120         usbd_status error;
1121         uint8_t *buf;
1122         int xferlen, rate;
1123
1124         rate = IEEE80211_IS_CHAN_5GHZ(ni->ni_chan) ? 12 : 2;
1125
1126         xfer = usbd_alloc_xfer(sc->sc_udev);
1127         if (xfer == NULL)
1128                 return ENOMEM;
1129
1130         /* xfer length needs to be a multiple of two! */
1131         xferlen = (RAL_TX_DESC_SIZE + m0->m_pkthdr.len + 1) & ~1;
1132
1133         buf = usbd_alloc_buffer(xfer, xferlen);
1134         if (buf == NULL) {
1135                 usbd_free_xfer(xfer);
1136                 return ENOMEM;
1137         }
1138
1139         usbd_setup_xfer(xfer, sc->sc_tx_pipeh, NULL, &cmd, sizeof cmd,
1140             USBD_FORCE_SHORT_XFER, RAL_TX_TIMEOUT, NULL);
1141
1142         error = usbd_sync_transfer(xfer);
1143         if (error != 0) {
1144                 usbd_free_xfer(xfer);
1145                 return error;
1146         }
1147
1148         desc = (struct ural_tx_desc *)buf;
1149
1150         m_copydata(m0, 0, m0->m_pkthdr.len, buf + RAL_TX_DESC_SIZE);
1151         ural_setup_tx_desc(sc, desc, RAL_TX_IFS_NEWBACKOFF | RAL_TX_TIMESTAMP,
1152             m0->m_pkthdr.len, rate);
1153
1154         DPRINTFN(10, ("sending beacon frame len=%u rate=%u xfer len=%u\n",
1155             m0->m_pkthdr.len, rate, xferlen));
1156
1157         usbd_setup_xfer(xfer, sc->sc_tx_pipeh, NULL, buf, xferlen,
1158             USBD_FORCE_SHORT_XFER | USBD_NO_COPY, RAL_TX_TIMEOUT, NULL);
1159
1160         error = usbd_sync_transfer(xfer);
1161         usbd_free_xfer(xfer);
1162
1163         return error;
1164 }
1165
1166 static int
1167 ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
1168 {
1169         struct ieee80211com *ic = &sc->sc_ic;
1170         struct ifnet *ifp = &ic->ic_if;
1171         struct ural_tx_desc *desc;
1172         struct ural_tx_data *data;
1173         struct ieee80211_frame *wh;
1174         uint32_t flags = 0;
1175         uint16_t dur;
1176         usbd_status error;
1177         int xferlen, rate;
1178
1179         data = &sc->tx_data[0];
1180         desc = (struct ural_tx_desc *)data->buf;
1181
1182         rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
1183
1184         data->m = m0;
1185         data->ni = ni;
1186
1187         wh = mtod(m0, struct ieee80211_frame *);
1188
1189         if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1190                 flags |= RAL_TX_ACK;
1191
1192                 dur = ieee80211_txtime(ni, RAL_ACK_SIZE, rate, ic->ic_flags) +
1193                       sc->sc_sifs;
1194                 *(uint16_t *)wh->i_dur = htole16(dur);
1195
1196                 /* tell hardware to add timestamp for probe responses */
1197                 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
1198                     IEEE80211_FC0_TYPE_MGT &&
1199                     (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
1200                     IEEE80211_FC0_SUBTYPE_PROBE_RESP)
1201                         flags |= RAL_TX_TIMESTAMP;
1202         }
1203
1204         if (sc->sc_drvbpf != NULL) {
1205                 struct ural_tx_radiotap_header *tap = &sc->sc_txtap;
1206
1207                 tap->wt_flags = 0;
1208                 tap->wt_rate = rate;
1209                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
1210                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
1211                 tap->wt_antenna = sc->tx_ant;
1212
1213                 bpf_ptap(sc->sc_drvbpf, m0, tap, sc->sc_txtap_len);
1214         }
1215
1216         m_copydata(m0, 0, m0->m_pkthdr.len, data->buf + RAL_TX_DESC_SIZE);
1217         ural_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len, rate);
1218
1219         /* align end on a 2-bytes boundary */
1220         xferlen = (RAL_TX_DESC_SIZE + m0->m_pkthdr.len + 1) & ~1;
1221
1222         /*
1223          * No space left in the last URB to store the extra 2 bytes, force
1224          * sending of another URB.
1225          */
1226         if ((xferlen % 64) == 0)
1227                 xferlen += 2;
1228
1229         DPRINTFN(10, ("sending mgt frame len=%u rate=%u xfer len=%u\n",
1230             m0->m_pkthdr.len, rate, xferlen));
1231
1232         lwkt_serialize_exit(ifp->if_serializer);
1233
1234         usbd_setup_xfer(data->xfer, sc->sc_tx_pipeh, data, data->buf,
1235             xferlen, USBD_FORCE_SHORT_XFER | USBD_NO_COPY, RAL_TX_TIMEOUT,
1236             ural_txeof);
1237
1238         error = usbd_transfer(data->xfer);
1239         if (error != USBD_NORMAL_COMPLETION && error != USBD_IN_PROGRESS) {
1240                 m_freem(m0);
1241                 data->m = NULL;
1242                 data->ni = NULL;
1243         } else {
1244                 sc->tx_queued++;
1245                 error = 0;
1246         }
1247
1248         lwkt_serialize_enter(ifp->if_serializer);
1249         return error;
1250 }
1251
1252 static int
1253 ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
1254 {
1255         struct ieee80211com *ic = &sc->sc_ic;
1256         struct ifnet *ifp = &ic->ic_if;
1257         struct ural_tx_desc *desc;
1258         struct ural_tx_data *data;
1259         struct ieee80211_frame *wh;
1260         struct ieee80211_key *k;
1261         uint32_t flags = 0;
1262         uint16_t dur;
1263         usbd_status error;
1264         int xferlen, rate, rate_idx;
1265
1266         wh = mtod(m0, struct ieee80211_frame *);
1267
1268         ieee80211_ratectl_findrate(ni, m0->m_pkthdr.len, &rate_idx, 1);
1269         rate = IEEE80211_RS_RATE(&ni->ni_rates, rate_idx);
1270
1271         if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
1272                 k = ieee80211_crypto_encap(ic, ni, m0);
1273                 if (k == NULL) {
1274                         m_freem(m0);
1275                         return ENOBUFS;
1276                 }
1277
1278                 /* packet header may have moved, reset our local pointer */
1279                 wh = mtod(m0, struct ieee80211_frame *);
1280         }
1281
1282         data = &sc->tx_data[0];
1283         desc = (struct ural_tx_desc *)data->buf;
1284
1285         data->m = m0;
1286         data->ni = ni;
1287
1288         if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1289                 flags |= RAL_TX_ACK;
1290                 flags |= RAL_TX_RETRY(sc->sc_tx_retries);
1291
1292                 dur = ieee80211_txtime(ni, RAL_ACK_SIZE,
1293                         ieee80211_ack_rate(ni, rate), ic->ic_flags) +
1294                         sc->sc_sifs;
1295                 *(uint16_t *)wh->i_dur = htole16(dur);
1296         }
1297
1298         if (sc->sc_drvbpf != NULL) {
1299                 struct ural_tx_radiotap_header *tap = &sc->sc_txtap;
1300
1301                 tap->wt_flags = 0;
1302                 tap->wt_rate = rate;
1303                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
1304                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
1305                 tap->wt_antenna = sc->tx_ant;
1306
1307                 bpf_ptap(sc->sc_drvbpf, m0, tap, sc->sc_txtap_len);
1308         }
1309
1310         m_copydata(m0, 0, m0->m_pkthdr.len, data->buf + RAL_TX_DESC_SIZE);
1311         ural_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len, rate);
1312
1313         /* align end on a 2-bytes boundary */
1314         xferlen = (RAL_TX_DESC_SIZE + m0->m_pkthdr.len + 1) & ~1;
1315
1316         /*
1317          * No space left in the last URB to store the extra 2 bytes, force
1318          * sending of another URB.
1319          */
1320         if ((xferlen % 64) == 0)
1321                 xferlen += 2;
1322
1323         DPRINTFN(10, ("sending data frame len=%u rate=%u xfer len=%u\n",
1324             m0->m_pkthdr.len, rate, xferlen));
1325
1326         lwkt_serialize_exit(ifp->if_serializer);
1327
1328         usbd_setup_xfer(data->xfer, sc->sc_tx_pipeh, data, data->buf,
1329             xferlen, USBD_FORCE_SHORT_XFER | USBD_NO_COPY, RAL_TX_TIMEOUT,
1330             ural_txeof);
1331
1332         error = usbd_transfer(data->xfer);
1333         if (error != USBD_NORMAL_COMPLETION && error != USBD_IN_PROGRESS) {
1334                 m_freem(m0);
1335                 data->m = NULL;
1336                 data->ni = NULL;
1337         } else {
1338                 sc->tx_queued++;
1339                 error = 0;
1340         }
1341
1342         lwkt_serialize_enter(ifp->if_serializer);
1343         return error;
1344 }
1345
1346 static void
1347 ural_start(struct ifnet *ifp)
1348 {
1349         struct ural_softc *sc = ifp->if_softc;
1350         struct ieee80211com *ic = &sc->sc_ic;
1351
1352         ASSERT_SERIALIZED(ifp->if_serializer);
1353
1354         if (sc->sc_stopped)
1355                 return;
1356
1357         crit_enter();
1358
1359         if ((ifp->if_flags & (IFF_OACTIVE | IFF_RUNNING)) != IFF_RUNNING) {
1360                 crit_exit();
1361                 return;
1362         }
1363
1364         for (;;) {
1365                 struct ieee80211_node *ni;
1366                 struct mbuf *m0;
1367
1368                 if (!IF_QEMPTY(&ic->ic_mgtq)) {
1369                         if (sc->tx_queued >= RAL_TX_LIST_COUNT) {
1370                                 ifp->if_flags |= IFF_OACTIVE;
1371                                 break;
1372                         }
1373                         IF_DEQUEUE(&ic->ic_mgtq, m0);
1374
1375                         ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
1376                         m0->m_pkthdr.rcvif = NULL;
1377
1378                         if (ic->ic_rawbpf != NULL)
1379                                 bpf_mtap(ic->ic_rawbpf, m0);
1380
1381                         if (ural_tx_mgt(sc, m0, ni) != 0) {
1382                                 ieee80211_free_node(ni);
1383                                 break;
1384                         }
1385                 } else {
1386                         struct ether_header *eh;
1387
1388                         if (ic->ic_state != IEEE80211_S_RUN)
1389                                 break;
1390                         m0 = ifq_poll(&ifp->if_snd);
1391                         if (m0 == NULL)
1392                                 break;
1393                         if (sc->tx_queued >= RAL_TX_LIST_COUNT) {
1394                                 ifp->if_flags |= IFF_OACTIVE;
1395                                 break;
1396                         }
1397
1398                         ifq_dequeue(&ifp->if_snd, m0);
1399
1400                         if (m0->m_len < sizeof (struct ether_header)) {
1401                                 m0 = m_pullup(m0, sizeof (struct ether_header));
1402                                 if (m0 == NULL) {
1403                                         ifp->if_oerrors++;
1404                                         continue;
1405                                 }
1406                         }
1407
1408                         eh = mtod(m0, struct ether_header *);
1409                         ni = ieee80211_find_txnode(ic, eh->ether_dhost);
1410                         if (ni == NULL) {
1411                                 m_freem(m0);
1412                                 continue;
1413                         }
1414                         BPF_MTAP(ifp, m0);
1415
1416                         m0 = ieee80211_encap(ic, m0, ni);
1417                         if (m0 == NULL) {
1418                                 ieee80211_free_node(ni);
1419                                 continue;
1420                         }
1421
1422                         if (ic->ic_rawbpf != NULL)
1423                                 bpf_mtap(ic->ic_rawbpf, m0);
1424
1425                         if (ural_tx_data(sc, m0, ni) != 0) {
1426                                 ieee80211_free_node(ni);
1427                                 ifp->if_oerrors++;
1428                                 break;
1429                         }
1430                 }
1431
1432                 sc->sc_tx_timer = 5;
1433                 ifp->if_timer = 1;
1434         }
1435
1436         crit_exit();
1437 }
1438
1439 static void
1440 ural_watchdog(struct ifnet *ifp)
1441 {
1442         struct ural_softc *sc = ifp->if_softc;
1443         struct ieee80211com *ic = &sc->sc_ic;
1444
1445         ASSERT_SERIALIZED(ifp->if_serializer);
1446
1447         crit_enter();
1448
1449         ifp->if_timer = 0;
1450
1451         if (sc->sc_tx_timer > 0) {
1452                 if (--sc->sc_tx_timer == 0) {
1453                         device_printf(sc->sc_dev, "device timeout\n");
1454                         /*ural_init(sc); XXX needs a process context! */
1455                         ifp->if_oerrors++;
1456
1457                         crit_exit();
1458                         return;
1459                 }
1460                 ifp->if_timer = 1;
1461         }
1462         ieee80211_watchdog(ic);
1463
1464         crit_exit();
1465 }
1466
1467 /*
1468  * This function allows for fast channel switching in monitor mode (used by
1469  * net-mgmt/kismet). In IBSS mode, we must explicitly reset the interface to
1470  * generate a new beacon frame.
1471  */
1472 static int
1473 ural_reset(struct ifnet *ifp)
1474 {
1475         struct ural_softc *sc = ifp->if_softc;
1476         struct ieee80211com *ic = &sc->sc_ic;
1477
1478         ASSERT_SERIALIZED(ifp->if_serializer);
1479
1480         if (ic->ic_opmode != IEEE80211_M_MONITOR)
1481                 return ENETRESET;
1482
1483         crit_enter();
1484
1485         lwkt_serialize_exit(ifp->if_serializer);
1486         ural_set_chan(sc, ic->ic_curchan);
1487         lwkt_serialize_enter(ifp->if_serializer);
1488
1489         crit_exit();
1490
1491         return 0;
1492 }
1493
1494 static int
1495 ural_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
1496 {
1497         struct ural_softc *sc = ifp->if_softc;
1498         struct ieee80211com *ic = &sc->sc_ic;
1499         int error = 0;
1500
1501         ASSERT_SERIALIZED(ifp->if_serializer);
1502
1503         crit_enter();
1504
1505         switch (cmd) {
1506         case SIOCSIFFLAGS:
1507                 if (ifp->if_flags & IFF_UP) {
1508                         if (ifp->if_flags & IFF_RUNNING) {
1509                                 lwkt_serialize_exit(ifp->if_serializer);
1510                                 ural_update_promisc(sc);
1511                                 lwkt_serialize_enter(ifp->if_serializer);
1512                         } else {
1513                                 ural_init(sc);
1514                         }
1515                 } else {
1516                         if (ifp->if_flags & IFF_RUNNING)
1517                                 ural_stop(sc);
1518                 }
1519                 break;
1520
1521         default:
1522                 error = ieee80211_ioctl(ic, cmd, data, cr);
1523         }
1524
1525         if (error == ENETRESET) {
1526                 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
1527                     (IFF_UP | IFF_RUNNING) &&
1528                     ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
1529                         ural_init(sc);
1530                 error = 0;
1531         }
1532
1533         crit_exit();
1534         return error;
1535 }
1536
1537 static void
1538 ural_set_testmode(struct ural_softc *sc)
1539 {
1540         usb_device_request_t req;
1541         usbd_status error;
1542
1543         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
1544         req.bRequest = RAL_VENDOR_REQUEST;
1545         USETW(req.wValue, 4);
1546         USETW(req.wIndex, 1);
1547         USETW(req.wLength, 0);
1548
1549         error = usbd_do_request(sc->sc_udev, &req, NULL);
1550         if (error != 0) {
1551                 kprintf("%s: could not set test mode: %s\n",
1552                     device_get_nameunit(sc->sc_dev), usbd_errstr(error));
1553         }
1554 }
1555
1556 static void
1557 ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)
1558 {
1559         usb_device_request_t req;
1560         usbd_status error;
1561
1562         req.bmRequestType = UT_READ_VENDOR_DEVICE;
1563         req.bRequest = RAL_READ_EEPROM;
1564         USETW(req.wValue, 0);
1565         USETW(req.wIndex, addr);
1566         USETW(req.wLength, len);
1567
1568         error = usbd_do_request(sc->sc_udev, &req, buf);
1569         if (error != 0) {
1570                 kprintf("%s: could not read EEPROM: %s\n",
1571                     device_get_nameunit(sc->sc_dev), usbd_errstr(error));
1572         }
1573 }
1574
1575 static uint16_t
1576 ural_read(struct ural_softc *sc, uint16_t reg)
1577 {
1578         usb_device_request_t req;
1579         usbd_status error;
1580         uint16_t val;
1581
1582         req.bmRequestType = UT_READ_VENDOR_DEVICE;
1583         req.bRequest = RAL_READ_MAC;
1584         USETW(req.wValue, 0);
1585         USETW(req.wIndex, reg);
1586         USETW(req.wLength, sizeof (uint16_t));
1587
1588         error = usbd_do_request(sc->sc_udev, &req, &val);
1589         if (error != 0) {
1590                 kprintf("%s: could not read MAC register: %s\n",
1591                     device_get_nameunit(sc->sc_dev), usbd_errstr(error));
1592                 return 0;
1593         }
1594
1595         return le16toh(val);
1596 }
1597
1598 static void
1599 ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
1600 {
1601         usb_device_request_t req;
1602         usbd_status error;
1603
1604         req.bmRequestType = UT_READ_VENDOR_DEVICE;
1605         req.bRequest = RAL_READ_MULTI_MAC;
1606         USETW(req.wValue, 0);
1607         USETW(req.wIndex, reg);
1608         USETW(req.wLength, len);
1609
1610         error = usbd_do_request(sc->sc_udev, &req, buf);
1611         if (error != 0) {
1612                 kprintf("%s: could not read MAC register: %s\n",
1613                     device_get_nameunit(sc->sc_dev), usbd_errstr(error));
1614         }
1615 }
1616
1617 static void
1618 ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)
1619 {
1620         usb_device_request_t req;
1621         usbd_status error;
1622
1623         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
1624         req.bRequest = RAL_WRITE_MAC;
1625         USETW(req.wValue, val);
1626         USETW(req.wIndex, reg);
1627         USETW(req.wLength, 0);
1628
1629         error = usbd_do_request(sc->sc_udev, &req, NULL);
1630         if (error != 0) {
1631                 kprintf("%s: could not write MAC register: %s\n",
1632                     device_get_nameunit(sc->sc_dev), usbd_errstr(error));
1633         }
1634 }
1635
1636 static void
1637 ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
1638 {
1639         usb_device_request_t req;
1640         usbd_status error;
1641
1642         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
1643         req.bRequest = RAL_WRITE_MULTI_MAC;
1644         USETW(req.wValue, 0);
1645         USETW(req.wIndex, reg);
1646         USETW(req.wLength, len);
1647
1648         error = usbd_do_request(sc->sc_udev, &req, buf);
1649         if (error != 0) {
1650                 kprintf("%s: could not write MAC register: %s\n",
1651                     device_get_nameunit(sc->sc_dev), usbd_errstr(error));
1652         }
1653 }
1654
1655 static void
1656 ural_bbp_write(struct ural_softc *sc, uint8_t reg, uint8_t val)
1657 {
1658         uint16_t tmp;
1659         int ntries;
1660
1661         for (ntries = 0; ntries < 5; ntries++) {
1662                 if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
1663                         break;
1664         }
1665         if (ntries == 5) {
1666                 kprintf("%s: could not write to BBP\n", device_get_nameunit(sc->sc_dev));
1667                 return;
1668         }
1669
1670         tmp = reg << 8 | val;
1671         ural_write(sc, RAL_PHY_CSR7, tmp);
1672 }
1673
1674 static uint8_t
1675 ural_bbp_read(struct ural_softc *sc, uint8_t reg)
1676 {
1677         uint16_t val;
1678         int ntries;
1679
1680         val = RAL_BBP_WRITE | reg << 8;
1681         ural_write(sc, RAL_PHY_CSR7, val);
1682
1683         for (ntries = 0; ntries < 5; ntries++) {
1684                 if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
1685                         break;
1686         }
1687         if (ntries == 5) {
1688                 kprintf("%s: could not read BBP\n", device_get_nameunit(sc->sc_dev));
1689                 return 0;
1690         }
1691
1692         return ural_read(sc, RAL_PHY_CSR7) & 0xff;
1693 }
1694
1695 static void
1696 ural_rf_write(struct ural_softc *sc, uint8_t reg, uint32_t val)
1697 {
1698         uint32_t tmp;
1699         int ntries;
1700
1701         for (ntries = 0; ntries < 5; ntries++) {
1702                 if (!(ural_read(sc, RAL_PHY_CSR10) & RAL_RF_LOBUSY))
1703                         break;
1704         }
1705         if (ntries == 5) {
1706                 kprintf("%s: could not write to RF\n", device_get_nameunit(sc->sc_dev));
1707                 return;
1708         }
1709
1710         tmp = RAL_RF_BUSY | RAL_RF_20BIT | (val & 0xfffff) << 2 | (reg & 0x3);
1711         ural_write(sc, RAL_PHY_CSR9,  tmp & 0xffff);
1712         ural_write(sc, RAL_PHY_CSR10, tmp >> 16);
1713
1714         /* remember last written value in sc */
1715         sc->rf_regs[reg] = val;
1716
1717         DPRINTFN(15, ("RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff));
1718 }
1719
1720 static void
1721 ural_set_chan(struct ural_softc *sc, struct ieee80211_channel *c)
1722 {
1723         struct ieee80211com *ic = &sc->sc_ic;
1724         uint8_t power, tmp;
1725         u_int i, chan;
1726
1727         chan = ieee80211_chan2ieee(ic, c);
1728         if (chan == 0 || chan == IEEE80211_CHAN_ANY)
1729                 return;
1730
1731         if (IEEE80211_IS_CHAN_2GHZ(c))
1732                 power = min(sc->txpow[chan - 1], 31);
1733         else
1734                 power = 31;
1735
1736         /* adjust txpower using ifconfig settings */
1737         power -= (100 - ic->ic_txpowlimit) / 8;
1738
1739         DPRINTFN(2, ("setting channel to %u, txpower to %u\n", chan, power));
1740
1741         switch (sc->rf_rev) {
1742         case RAL_RF_2522:
1743                 ural_rf_write(sc, RAL_RF1, 0x00814);
1744                 ural_rf_write(sc, RAL_RF2, ural_rf2522_r2[chan - 1]);
1745                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
1746                 break;
1747
1748         case RAL_RF_2523:
1749                 ural_rf_write(sc, RAL_RF1, 0x08804);
1750                 ural_rf_write(sc, RAL_RF2, ural_rf2523_r2[chan - 1]);
1751                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
1752                 ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
1753                 break;
1754
1755         case RAL_RF_2524:
1756                 ural_rf_write(sc, RAL_RF1, 0x0c808);
1757                 ural_rf_write(sc, RAL_RF2, ural_rf2524_r2[chan - 1]);
1758                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
1759                 ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
1760                 break;
1761
1762         case RAL_RF_2525:
1763                 ural_rf_write(sc, RAL_RF1, 0x08808);
1764                 ural_rf_write(sc, RAL_RF2, ural_rf2525_hi_r2[chan - 1]);
1765                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
1766                 ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
1767
1768                 ural_rf_write(sc, RAL_RF1, 0x08808);
1769                 ural_rf_write(sc, RAL_RF2, ural_rf2525_r2[chan - 1]);
1770                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
1771                 ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
1772                 break;
1773
1774         case RAL_RF_2525E:
1775                 ural_rf_write(sc, RAL_RF1, 0x08808);
1776                 ural_rf_write(sc, RAL_RF2, ural_rf2525e_r2[chan - 1]);
1777                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
1778                 ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
1779                 break;
1780
1781         case RAL_RF_2526:
1782                 ural_rf_write(sc, RAL_RF2, ural_rf2526_hi_r2[chan - 1]);
1783                 ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
1784                 ural_rf_write(sc, RAL_RF1, 0x08804);
1785
1786                 ural_rf_write(sc, RAL_RF2, ural_rf2526_r2[chan - 1]);
1787                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
1788                 ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
1789                 break;
1790
1791         /* dual-band RF */
1792         case RAL_RF_5222:
1793                 for (i = 0; ural_rf5222[i].chan != chan; i++)
1794                         ; /* EMPTY */
1795
1796                 ural_rf_write(sc, RAL_RF1, ural_rf5222[i].r1);
1797                 ural_rf_write(sc, RAL_RF2, ural_rf5222[i].r2);
1798                 ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
1799                 ural_rf_write(sc, RAL_RF4, ural_rf5222[i].r4);
1800                 break;
1801         }
1802
1803         if (ic->ic_opmode != IEEE80211_M_MONITOR &&
1804             ic->ic_state != IEEE80211_S_SCAN) {
1805                 /* set Japan filter bit for channel 14 */
1806                 tmp = ural_bbp_read(sc, 70);
1807
1808                 tmp &= ~RAL_JAPAN_FILTER;
1809                 if (chan == 14)
1810                         tmp |= RAL_JAPAN_FILTER;
1811
1812                 ural_bbp_write(sc, 70, tmp);
1813
1814                 /* clear CRC errors */
1815                 ural_read(sc, RAL_STA_CSR0);
1816
1817                 DELAY(10000);
1818                 ural_disable_rf_tune(sc);
1819         }
1820
1821         sc->sc_sifs = IEEE80211_IS_CHAN_5GHZ(c) ? IEEE80211_DUR_OFDM_SIFS
1822                                                 : IEEE80211_DUR_SIFS;
1823 }
1824
1825 /*
1826  * Disable RF auto-tuning.
1827  */
1828 static void
1829 ural_disable_rf_tune(struct ural_softc *sc)
1830 {
1831         uint32_t tmp;
1832
1833         if (sc->rf_rev != RAL_RF_2523) {
1834                 tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
1835                 ural_rf_write(sc, RAL_RF1, tmp);
1836         }
1837
1838         tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
1839         ural_rf_write(sc, RAL_RF3, tmp);
1840
1841         DPRINTFN(2, ("disabling RF autotune\n"));
1842 }
1843
1844 /*
1845  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
1846  * synchronization.
1847  */
1848 static void
1849 ural_enable_tsf_sync(struct ural_softc *sc)
1850 {
1851         struct ieee80211com *ic = &sc->sc_ic;
1852         uint16_t logcwmin, preload, tmp;
1853
1854         /* first, disable TSF synchronization */
1855         ural_write(sc, RAL_TXRX_CSR19, 0);
1856
1857         tmp = (16 * ic->ic_bss->ni_intval) << 4;
1858         ural_write(sc, RAL_TXRX_CSR18, tmp);
1859
1860         logcwmin = (ic->ic_opmode == IEEE80211_M_IBSS) ? 2 : 0;
1861         preload = (ic->ic_opmode == IEEE80211_M_IBSS) ? 320 : 6;
1862         tmp = logcwmin << 12 | preload;
1863         ural_write(sc, RAL_TXRX_CSR20, tmp);
1864
1865         /* finally, enable TSF synchronization */
1866         tmp = RAL_ENABLE_TSF | RAL_ENABLE_TBCN;
1867         if (ic->ic_opmode == IEEE80211_M_STA)
1868                 tmp |= RAL_ENABLE_TSF_SYNC(1);
1869         else
1870                 tmp |= RAL_ENABLE_TSF_SYNC(2) | RAL_ENABLE_BEACON_GENERATOR;
1871         ural_write(sc, RAL_TXRX_CSR19, tmp);
1872
1873         DPRINTF(("enabling TSF synchronization\n"));
1874 }
1875
1876 static void
1877 ural_update_slot(struct ifnet *ifp)
1878 {
1879         struct ural_softc *sc = ifp->if_softc;
1880         struct ieee80211com *ic = &sc->sc_ic;
1881         uint16_t slottime, sifs, eifs;
1882
1883         slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
1884
1885         /*
1886          * These settings may sound a bit inconsistent but this is what the
1887          * reference driver does.
1888          */
1889         if (ic->ic_curmode == IEEE80211_MODE_11B) {
1890                 sifs = 16 - RAL_RXTX_TURNAROUND;
1891                 eifs = 364;
1892         } else {
1893                 sifs = 10 - RAL_RXTX_TURNAROUND;
1894                 eifs = 64;
1895         }
1896
1897         ural_write(sc, RAL_MAC_CSR10, slottime);
1898         ural_write(sc, RAL_MAC_CSR11, sifs);
1899         ural_write(sc, RAL_MAC_CSR12, eifs);
1900 }
1901
1902 static void
1903 ural_set_txpreamble(struct ural_softc *sc)
1904 {
1905         uint16_t tmp;
1906
1907         tmp = ural_read(sc, RAL_TXRX_CSR10);
1908
1909         tmp &= ~RAL_SHORT_PREAMBLE;
1910         if (sc->sc_ic.ic_flags & IEEE80211_F_SHPREAMBLE)
1911                 tmp |= RAL_SHORT_PREAMBLE;
1912
1913         ural_write(sc, RAL_TXRX_CSR10, tmp);
1914 }
1915
1916 static void
1917 ural_set_basicrates(struct ural_softc *sc)
1918 {
1919         struct ieee80211com *ic = &sc->sc_ic;
1920
1921         /* update basic rate set */
1922         if (ic->ic_curmode == IEEE80211_MODE_11B) {
1923                 /* 11b basic rates: 1, 2Mbps */
1924                 ural_write(sc, RAL_TXRX_CSR11, 0x3);
1925         } else if (IEEE80211_IS_CHAN_5GHZ(ic->ic_bss->ni_chan)) {
1926                 /* 11a basic rates: 6, 12, 24Mbps */
1927                 ural_write(sc, RAL_TXRX_CSR11, 0x150);
1928         } else {
1929                 /* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
1930                 ural_write(sc, RAL_TXRX_CSR11, 0x15f);
1931         }
1932 }
1933
1934 static void
1935 ural_set_bssid(struct ural_softc *sc, uint8_t *bssid)
1936 {
1937         uint16_t tmp;
1938
1939         tmp = bssid[0] | bssid[1] << 8;
1940         ural_write(sc, RAL_MAC_CSR5, tmp);
1941
1942         tmp = bssid[2] | bssid[3] << 8;
1943         ural_write(sc, RAL_MAC_CSR6, tmp);
1944
1945         tmp = bssid[4] | bssid[5] << 8;
1946         ural_write(sc, RAL_MAC_CSR7, tmp);
1947
1948         DPRINTF(("setting BSSID to %6D\n", bssid, ":"));
1949 }
1950
1951 static void
1952 ural_set_macaddr(struct ural_softc *sc, uint8_t *addr)
1953 {
1954         uint16_t tmp;
1955
1956         tmp = addr[0] | addr[1] << 8;
1957         ural_write(sc, RAL_MAC_CSR2, tmp);
1958
1959         tmp = addr[2] | addr[3] << 8;
1960         ural_write(sc, RAL_MAC_CSR3, tmp);
1961
1962         tmp = addr[4] | addr[5] << 8;
1963         ural_write(sc, RAL_MAC_CSR4, tmp);
1964
1965         DPRINTF(("setting MAC address to %6D\n", addr, ":"));
1966 }
1967
1968 static void
1969 ural_update_promisc(struct ural_softc *sc)
1970 {
1971         struct ifnet *ifp = &sc->sc_ic.ic_if;
1972         uint32_t tmp;
1973
1974         tmp = ural_read(sc, RAL_TXRX_CSR2);
1975
1976         tmp &= ~RAL_DROP_NOT_TO_ME;
1977         if (!(ifp->if_flags & IFF_PROMISC))
1978                 tmp |= RAL_DROP_NOT_TO_ME;
1979
1980         ural_write(sc, RAL_TXRX_CSR2, tmp);
1981
1982         DPRINTF(("%s promiscuous mode\n", (ifp->if_flags & IFF_PROMISC) ?
1983             "entering" : "leaving"));
1984 }
1985
1986 static const char *
1987 ural_get_rf(int rev)
1988 {
1989         switch (rev) {
1990         case RAL_RF_2522:       return "RT2522";
1991         case RAL_RF_2523:       return "RT2523";
1992         case RAL_RF_2524:       return "RT2524";
1993         case RAL_RF_2525:       return "RT2525";
1994         case RAL_RF_2525E:      return "RT2525e";
1995         case RAL_RF_2526:       return "RT2526";
1996         case RAL_RF_5222:       return "RT5222";
1997         default:                return "unknown";
1998         }
1999 }
2000
2001 static void
2002 ural_read_eeprom(struct ural_softc *sc)
2003 {
2004         struct ieee80211com *ic = &sc->sc_ic;
2005         uint16_t val;
2006
2007         ural_eeprom_read(sc, RAL_EEPROM_CONFIG0, &val, 2);
2008         val = le16toh(val);
2009         sc->rf_rev =   (val >> 11) & 0x7;
2010         sc->hw_radio = (val >> 10) & 0x1;
2011         sc->led_mode = (val >> 6)  & 0x7;
2012         sc->rx_ant =   (val >> 4)  & 0x3;
2013         sc->tx_ant =   (val >> 2)  & 0x3;
2014         sc->nb_ant =   val & 0x3;
2015
2016         /* read MAC address */
2017         ural_eeprom_read(sc, RAL_EEPROM_ADDRESS, ic->ic_myaddr, 6);
2018
2019         /* read default values for BBP registers */
2020         ural_eeprom_read(sc, RAL_EEPROM_BBP_BASE, sc->bbp_prom, 2 * 16);
2021
2022         /* read Tx power for all b/g channels */
2023         ural_eeprom_read(sc, RAL_EEPROM_TXPOWER, sc->txpow, 14);
2024 }
2025
2026 static int
2027 ural_bbp_init(struct ural_softc *sc)
2028 {
2029 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
2030         int i, ntries;
2031
2032         /* wait for BBP to be ready */
2033         for (ntries = 0; ntries < 100; ntries++) {
2034                 if (ural_bbp_read(sc, RAL_BBP_VERSION) != 0)
2035                         break;
2036                 DELAY(1000);
2037         }
2038         if (ntries == 100) {
2039                 device_printf(sc->sc_dev, "timeout waiting for BBP\n");
2040                 return EIO;
2041         }
2042
2043         /* initialize BBP registers to default values */
2044         for (i = 0; i < N(ural_def_bbp); i++)
2045                 ural_bbp_write(sc, ural_def_bbp[i].reg, ural_def_bbp[i].val);
2046
2047 #if 0
2048         /* initialize BBP registers to values stored in EEPROM */
2049         for (i = 0; i < 16; i++) {
2050                 if (sc->bbp_prom[i].reg == 0xff)
2051                         continue;
2052                 ural_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
2053         }
2054 #endif
2055
2056         return 0;
2057 #undef N
2058 }
2059
2060 static void
2061 ural_set_txantenna(struct ural_softc *sc, int antenna)
2062 {
2063         uint16_t tmp;
2064         uint8_t tx;
2065
2066         tx = ural_bbp_read(sc, RAL_BBP_TX) & ~RAL_BBP_ANTMASK;
2067         if (antenna == 1)
2068                 tx |= RAL_BBP_ANTA;
2069         else if (antenna == 2)
2070                 tx |= RAL_BBP_ANTB;
2071         else
2072                 tx |= RAL_BBP_DIVERSITY;
2073
2074         /* need to force I/Q flip for RF 2525e, 2526 and 5222 */
2075         if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526 ||
2076             sc->rf_rev == RAL_RF_5222)
2077                 tx |= RAL_BBP_FLIPIQ;
2078
2079         ural_bbp_write(sc, RAL_BBP_TX, tx);
2080
2081         /* update values in PHY_CSR5 and PHY_CSR6 */
2082         tmp = ural_read(sc, RAL_PHY_CSR5) & ~0x7;
2083         ural_write(sc, RAL_PHY_CSR5, tmp | (tx & 0x7));
2084
2085         tmp = ural_read(sc, RAL_PHY_CSR6) & ~0x7;
2086         ural_write(sc, RAL_PHY_CSR6, tmp | (tx & 0x7));
2087 }
2088
2089 static void
2090 ural_set_rxantenna(struct ural_softc *sc, int antenna)
2091 {
2092         uint8_t rx;
2093
2094         rx = ural_bbp_read(sc, RAL_BBP_RX) & ~RAL_BBP_ANTMASK;
2095         if (antenna == 1)
2096                 rx |= RAL_BBP_ANTA;
2097         else if (antenna == 2)
2098                 rx |= RAL_BBP_ANTB;
2099         else
2100                 rx |= RAL_BBP_DIVERSITY;
2101
2102         /* need to force no I/Q flip for RF 2525e and 2526 */
2103         if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526)
2104                 rx &= ~RAL_BBP_FLIPIQ;
2105
2106         ural_bbp_write(sc, RAL_BBP_RX, rx);
2107 }
2108
2109 static void
2110 ural_init(void *priv)
2111 {
2112 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
2113         struct ural_softc *sc = priv;
2114         struct ieee80211com *ic = &sc->sc_ic;
2115         struct ifnet *ifp = &ic->ic_if;
2116         struct ural_rx_data *data;
2117         uint16_t tmp;
2118         usbd_status usb_err;
2119         int i, ntries, error;
2120
2121         ASSERT_SERIALIZED(ifp->if_serializer);
2122
2123         crit_enter();
2124
2125         lwkt_serialize_exit(ifp->if_serializer);
2126         ural_set_testmode(sc);
2127         ural_write(sc, 0x308, 0x00f0);  /* XXX magic */
2128         lwkt_serialize_enter(ifp->if_serializer);
2129
2130         ural_stop(sc);
2131         sc->sc_stopped = 0;
2132
2133         lwkt_serialize_exit(ifp->if_serializer);
2134
2135         /* initialize MAC registers to default values */
2136         for (i = 0; i < N(ural_def_mac); i++)
2137                 ural_write(sc, ural_def_mac[i].reg, ural_def_mac[i].val);
2138
2139         /* wait for BBP and RF to wake up (this can take a long time!) */
2140         for (ntries = 0; ntries < 100; ntries++) {
2141                 tmp = ural_read(sc, RAL_MAC_CSR17);
2142                 if ((tmp & (RAL_BBP_AWAKE | RAL_RF_AWAKE)) ==
2143                     (RAL_BBP_AWAKE | RAL_RF_AWAKE))
2144                         break;
2145                 DELAY(1000);
2146         }
2147         if (ntries == 100) {
2148                 kprintf("%s: timeout waiting for BBP/RF to wakeup\n",
2149                     device_get_nameunit(sc->sc_dev));
2150                 error = ETIMEDOUT;
2151                 goto fail;
2152         }
2153
2154         /* we're ready! */
2155         ural_write(sc, RAL_MAC_CSR1, RAL_HOST_READY);
2156
2157         /* set basic rate set (will be updated later) */
2158         ural_write(sc, RAL_TXRX_CSR11, 0x15f);
2159
2160         error = ural_bbp_init(sc);
2161         if (error)
2162                 goto fail;
2163
2164         /* set default BSS channel */
2165         ural_set_chan(sc, ic->ic_curchan);
2166
2167         /* clear statistic registers (STA_CSR0 to STA_CSR10) */
2168         ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
2169
2170         ural_set_txantenna(sc, sc->tx_ant);
2171         ural_set_rxantenna(sc, sc->rx_ant);
2172
2173         IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
2174         ural_set_macaddr(sc, ic->ic_myaddr);
2175
2176         /*
2177          * Allocate xfer for AMRR statistics requests.
2178          */
2179         sc->stats_xfer = usbd_alloc_xfer(sc->sc_udev);
2180         if (sc->stats_xfer == NULL) {
2181                 kprintf("%s: could not allocate AMRR xfer\n",
2182                     device_get_nameunit(sc->sc_dev));
2183                 error = ENOMEM;
2184                 goto fail;
2185         }
2186
2187         /*
2188          * Open Tx and Rx USB bulk pipes.
2189          */
2190         usb_err = usbd_open_pipe(sc->sc_iface, sc->sc_tx_no, USBD_EXCLUSIVE_USE,
2191             &sc->sc_tx_pipeh);
2192         if (usb_err != 0) {
2193                 kprintf("%s: could not open Tx pipe: %s\n",
2194                     device_get_nameunit(sc->sc_dev), usbd_errstr(usb_err));
2195                 error = ENOMEM;
2196                 goto fail;
2197         }
2198
2199         usb_err = usbd_open_pipe(sc->sc_iface, sc->sc_rx_no, USBD_EXCLUSIVE_USE,
2200             &sc->sc_rx_pipeh);
2201         if (usb_err != 0) {
2202                 kprintf("%s: could not open Rx pipe: %s\n",
2203                     device_get_nameunit(sc->sc_dev), usbd_errstr(usb_err));
2204                 error = ENOMEM;
2205                 goto fail;
2206         }
2207
2208         /*
2209          * Allocate Tx and Rx xfer queues.
2210          */
2211         error = ural_alloc_tx_list(sc);
2212         if (error) {
2213                 kprintf("%s: could not allocate Tx list\n",
2214                     device_get_nameunit(sc->sc_dev));
2215                 goto fail;
2216         }
2217
2218         error = ural_alloc_rx_list(sc);
2219         if (error) {
2220                 kprintf("%s: could not allocate Rx list\n",
2221                     device_get_nameunit(sc->sc_dev));
2222                 goto fail;
2223         }
2224
2225         /*
2226          * Start up the receive pipe.
2227          */
2228         for (i = 0; i < RAL_RX_LIST_COUNT; i++) {
2229                 data = &sc->rx_data[i];
2230
2231                 usbd_setup_xfer(data->xfer, sc->sc_rx_pipeh, data, data->buf,
2232                     MCLBYTES, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, ural_rxeof);
2233                 usbd_transfer(data->xfer);
2234         }
2235
2236         /* kick Rx */
2237         tmp = RAL_DROP_PHY | RAL_DROP_CRC;
2238         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2239                 tmp |= RAL_DROP_CTL | RAL_DROP_BAD_VERSION;
2240                 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2241                         tmp |= RAL_DROP_TODS;
2242                 if (!(ifp->if_flags & IFF_PROMISC))
2243                         tmp |= RAL_DROP_NOT_TO_ME;
2244         }
2245         ural_write(sc, RAL_TXRX_CSR2, tmp);
2246
2247         /* clear statistic registers (STA_CSR0 to STA_CSR10) */
2248         ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof(sc->sta));
2249 fail:
2250         lwkt_serialize_enter(ifp->if_serializer);
2251         if (error) {
2252                 ural_stop(sc);
2253         } else {
2254                 ifp->if_flags &= ~IFF_OACTIVE;
2255                 ifp->if_flags |= IFF_RUNNING;
2256
2257                 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2258                         if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
2259                                 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
2260                 } else {
2261                         ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
2262                 }
2263         }
2264
2265         crit_exit();
2266 #undef N
2267 }
2268
2269 static void
2270 ural_stop(struct ural_softc *sc)
2271 {
2272         struct ieee80211com *ic = &sc->sc_ic;
2273         struct ifnet *ifp = &ic->ic_if;
2274
2275         ASSERT_SERIALIZED(ifp->if_serializer);
2276
2277         crit_enter();
2278
2279         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2280         sc->sc_stopped = 1;
2281
2282         ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
2283
2284         sc->sc_tx_timer = 0;
2285         ifp->if_timer = 0;
2286
2287         lwkt_serialize_exit(ifp->if_serializer);
2288
2289         /* disable Rx */
2290         ural_write(sc, RAL_TXRX_CSR2, RAL_DISABLE_RX);
2291
2292         /* reset ASIC and BBP (but won't reset MAC registers!) */
2293         ural_write(sc, RAL_MAC_CSR1, RAL_RESET_ASIC | RAL_RESET_BBP);
2294         ural_write(sc, RAL_MAC_CSR1, 0);
2295
2296         if (sc->stats_xfer != NULL) {
2297                 usbd_free_xfer(sc->stats_xfer);
2298                 sc->stats_xfer = NULL;
2299         }
2300
2301         if (sc->sc_rx_pipeh != NULL) {
2302                 usbd_abort_pipe(sc->sc_rx_pipeh);
2303                 usbd_close_pipe(sc->sc_rx_pipeh);
2304                 sc->sc_rx_pipeh = NULL;
2305         }
2306
2307         if (sc->sc_tx_pipeh != NULL) {
2308                 usbd_abort_pipe(sc->sc_tx_pipeh);
2309                 usbd_close_pipe(sc->sc_tx_pipeh);
2310                 sc->sc_tx_pipeh = NULL;
2311         }
2312
2313         lwkt_serialize_enter(ifp->if_serializer);
2314
2315         ural_free_rx_list(sc);
2316         ural_free_tx_list(sc);
2317
2318         crit_exit();
2319 }
2320
2321 static void
2322 ural_stats_timeout(void *arg)
2323 {
2324         struct ural_softc *sc = (struct ural_softc *)arg;
2325         usb_device_request_t req;
2326
2327         if (sc->sc_stopped)
2328                 return;
2329
2330         crit_enter();
2331
2332         /*
2333          * Asynchronously read statistic registers (cleared by read).
2334          */
2335         req.bmRequestType = UT_READ_VENDOR_DEVICE;
2336         req.bRequest = RAL_READ_MULTI_MAC;
2337         USETW(req.wValue, 0);
2338         USETW(req.wIndex, RAL_STA_CSR0);
2339         USETW(req.wLength, sizeof(sc->sta));
2340
2341         usbd_setup_default_xfer(sc->stats_xfer, sc->sc_udev, sc,
2342                                 USBD_DEFAULT_TIMEOUT, &req,
2343                                 sc->sta, sizeof(sc->sta), 0,
2344                                 ural_stats_update);
2345         usbd_transfer(sc->stats_xfer);
2346
2347         crit_exit();
2348 }
2349
2350 static void
2351 ural_stats_update(usbd_xfer_handle xfer, usbd_private_handle priv,
2352                   usbd_status status)
2353 {
2354         struct ural_softc *sc = (struct ural_softc *)priv;
2355         struct ifnet *ifp = &sc->sc_ic.ic_if;
2356         struct ieee80211_ratectl_stats *stats = &sc->sc_stats;
2357
2358         if (status != USBD_NORMAL_COMPLETION) {
2359                 device_printf(sc->sc_dev, "could not retrieve Tx statistics - "
2360                     "cancelling automatic rate control\n");
2361                 return;
2362         }
2363
2364         crit_enter();
2365
2366         /* count TX retry-fail as Tx errors */
2367         ifp->if_oerrors += sc->sta[RAL_TX_PKT_FAIL];
2368
2369         stats->stats_pkt_ok += sc->sta[RAL_TX_PKT_NO_RETRY] +
2370                                sc->sta[RAL_TX_PKT_ONE_RETRY] +
2371                                sc->sta[RAL_TX_PKT_MULTI_RETRY];
2372
2373         stats->stats_pkt_err += sc->sta[RAL_TX_PKT_FAIL];
2374
2375         stats->stats_pkt_noretry += sc->sta[RAL_TX_PKT_NO_RETRY];
2376
2377         stats->stats_retries += sc->sta[RAL_TX_PKT_ONE_RETRY];
2378 #if 1
2379         /*
2380          * XXX Estimated average:
2381          * Actual number of retries for each packet should belong to
2382          * [2, sc->sc_tx_retries]
2383          */
2384         stats->stats_retries += sc->sta[RAL_TX_PKT_MULTI_RETRY] *
2385                                 ((2 + sc->sc_tx_retries) / 2);
2386 #else
2387         stats->stats_retries += sc->sta[RAL_TX_PKT_MULTI_RETRY];
2388 #endif
2389         stats->stats_retries += sc->sta[RAL_TX_PKT_FAIL] * sc->sc_tx_retries;
2390
2391         callout_reset(&sc->stats_ch, 4 * hz / 5, ural_stats_timeout, sc);
2392
2393         crit_exit();
2394 }
2395
2396 static void
2397 ural_stats(struct ieee80211com *ic, struct ieee80211_node *ni __unused,
2398            struct ieee80211_ratectl_stats *stats)
2399 {
2400         struct ifnet *ifp = &ic->ic_if;
2401         struct ural_softc *sc = ifp->if_softc;
2402
2403         ASSERT_SERIALIZED(ifp->if_serializer);
2404
2405         bcopy(&sc->sc_stats, stats, sizeof(*stats));
2406         bzero(&sc->sc_stats, sizeof(sc->sc_stats));
2407 }
2408
2409 static void
2410 ural_ratectl_change(struct ieee80211com *ic, u_int orc __unused, u_int nrc)
2411 {
2412         struct ieee80211_ratectl_state *st = &ic->ic_ratectl;
2413         struct ieee80211_onoe_param *oparam;
2414
2415         if (st->rc_st_param != NULL) {
2416                 kfree(st->rc_st_param, M_DEVBUF);
2417                 st->rc_st_param = NULL;
2418         }
2419
2420         switch (nrc) {
2421         case IEEE80211_RATECTL_ONOE:
2422                 oparam = kmalloc(sizeof(*oparam), M_DEVBUF, M_INTWAIT);
2423
2424                 IEEE80211_ONOE_PARAM_SETUP(oparam);
2425                 oparam->onoe_raise = 20;
2426
2427                 st->rc_st_param = oparam;
2428                 break;
2429         case IEEE80211_RATECTL_NONE:
2430                 /* This could only happen during detaching */
2431                 break;
2432         default:
2433                 panic("unknown rate control algo %u\n", nrc);
2434         }
2435 }
2436
2437 DRIVER_MODULE(ural, uhub, ural_driver, ural_devclass, usbd_driver_load, 0);