/* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright (c) 2003, 2004 * Daan Vreeken . All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Daan Vreeken. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Daan Vreeken AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Daan Vreeken OR THE VOICES IN HIS HEAD * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ /* * Atmel AT76c503 / AT76c503a / AT76c505 / AT76c505a USB WLAN driver * * Originally written by Daan Vreeken * http://vitsch.net/bsd/atuwi * * Contributed to by : * Chris Whitehouse, Alistair Phillips, Peter Pilka, Martijn van Buul, * Suihong Liang, Arjan van Leeuwen, Stuart Walsh * * Ported to OpenBSD by Theo de Raadt and David Gwynne. */ #include #include #include #include #include #define USBDRV_MAJOR_VER 2 #define USBDRV_MINOR_VER 0 #include #include #include "fw/atmel_rfmd.hex" #include "fw/atmel_rfmd2958.hex" #include "fw/atmel_rfmd2958-smc.hex" #include "fw/atmel_intersil.hex" #include "fw/atmel_at76c505_rfmd.hex" #include "fw/atmel_at76c503_rfmd_acc.hex" #include "fw/atmel_at76c503_i3863.hex" #include "atu.h" static void *atu_soft_state_p; static mac_callbacks_t atu_m_callbacks; static const struct ieee80211_rateset atu_rateset = {4, {2, 4, 11, 22}}; static int atu_usb_request(struct atu_softc *sc, uint8_t type, uint8_t request, uint16_t value, uint16_t index, uint16_t length, uint8_t *data) { usb_ctrl_setup_t req; usb_cb_flags_t cf; usb_cr_t cr; mblk_t *mp = NULL; int uret = USB_SUCCESS; bzero(&req, sizeof (req)); req.bmRequestType = type; req.bRequest = request; req.wValue = value; req.wIndex = index; req.wLength = length; req.attrs = USB_ATTRS_NONE; if (type & USB_DEV_REQ_DEV_TO_HOST) { req.attrs = USB_ATTRS_AUTOCLEARING; uret = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp, &cr, &cf, 0); if (mp == NULL) return (EIO); if (uret == USB_SUCCESS) bcopy(mp->b_rptr, data, length); } else { if ((mp = allocb(length, BPRI_HI)) == NULL) return (ENOMEM); bcopy(data, mp->b_wptr, length); mp->b_wptr += length; uret = usb_pipe_ctrl_xfer_wait(sc->sc_udev->dev_default_ph, &req, &mp, &cr, &cf, 0); } if (mp) freemsg(mp); return (uret == USB_SUCCESS ? 0 : EIO); } static int atu_get_mib(struct atu_softc *sc, uint8_t type, uint8_t size, uint8_t index, uint8_t *buf) { return atu_usb_request(sc, ATU_VENDOR_IF_IN, 0x033, type << 8, index, size, buf); } static int atu_get_cmd_status(struct atu_softc *sc, uint8_t cmd, uint8_t *status) { /* * all other drivers (including Windoze) request 40 bytes of status * and get a short-xfer of just 6 bytes. we can save 34 bytes of * buffer if we just request those 6 bytes in the first place :) */ return atu_usb_request(sc, ATU_VENDOR_IF_IN, 0x22, cmd, 0x0000, 6, status); } static uint8_t atu_get_dfu_state(struct atu_softc *sc) { uint8_t state; if (atu_usb_request(sc, DFU_GETSTATE, 0, 0, 1, &state)) return (DFUState_DFUError); return (state); } static int atu_get_opmode(struct atu_softc *sc, uint8_t *mode) { return atu_usb_request(sc, ATU_VENDOR_IF_IN, 0x33, 0x0001, 0x0000, 1, mode); } static int atu_get_config(struct atu_softc *sc) { struct ieee80211com *ic = &sc->sc_ic; struct atu_rfmd_conf rfmd_conf; struct atu_intersil_conf intersil_conf; int err; switch (sc->sc_radio) { case RadioRFMD: case RadioRFMD2958: case RadioRFMD2958_SMC: case AT76C503_RFMD_ACC: case AT76C505_RFMD: err = atu_usb_request(sc, ATU_VENDOR_IF_IN, 0x33, 0x0a02, 0x0000, sizeof (rfmd_conf), (uint8_t *)&rfmd_conf); if (err) { cmn_err(CE_WARN, "%s: get RFMD config failed\n", sc->sc_name); return (err); } bcopy(rfmd_conf.MACAddr, ic->ic_macaddr, IEEE80211_ADDR_LEN); break; case RadioIntersil: case AT76C503_i3863: err = atu_usb_request(sc, ATU_VENDOR_IF_IN, 0x33, 0x0902, 0x0000, sizeof (intersil_conf), (uint8_t *)&intersil_conf); if (err) { cmn_err(CE_WARN, "%s: get Intersil config failed\n", sc->sc_name); return (err); } bcopy(intersil_conf.MACAddr, ic->ic_macaddr, IEEE80211_ADDR_LEN); break; } return (0); } static int atu_wait_completion(struct atu_softc *sc, uint8_t cmd, uint8_t *status) { uint8_t statusreq[6]; int idle_count = 0, err; while ((err = atu_get_cmd_status(sc, cmd, statusreq)) == 0) { if ((statusreq[5] != STATUS_IN_PROGRESS) && (statusreq[5] != STATUS_IDLE)) { if (status != NULL) *status = statusreq[5]; return (0); } else if (idle_count++ > 60) { cmn_err(CE_WARN, "%s: command (0x%02x) timeout\n", sc->sc_name, cmd); return (ETIME); } drv_usecwait(10 * 1000); } return (err); } static int atu_send_command(struct atu_softc *sc, uint8_t *command, int size) { return atu_usb_request(sc, ATU_VENDOR_DEV_OUT, 0x0e, 0x0000, 0x0000, size, command); } static int atu_send_mib(struct atu_softc *sc, uint8_t type, uint8_t size, uint8_t index, void *data) { struct atu_cmd_set_mib request; int err; bzero(&request, sizeof (request)); request.AtCmd = CMD_SET_MIB; request.AtSize = size + 4; request.MIBType = type; request.MIBSize = size; request.MIBIndex = index; request.MIBReserved = 0; /* * For 1 and 2 byte requests we assume a direct value, * everything bigger than 2 bytes we assume a pointer to the data */ switch (size) { case 0: break; case 1: request.data[0] = (long)data & 0x000000ff; break; case 2: request.data[0] = (long)data & 0x000000ff; request.data[1] = (long)data >> 8; break; default: bcopy(data, request.data, size); break; } err = atu_usb_request(sc, ATU_VENDOR_DEV_OUT, 0x0e, 0x0000, 0x0000, size+8, (uint8_t *)&request); if (err) return (err); return (atu_wait_completion(sc, CMD_SET_MIB, NULL)); } static int atu_switch_radio(struct atu_softc *sc, boolean_t on) { struct atu_cmd radio; boolean_t ostate; int err; /* Intersil doesn't seem to support radio switch */ if (sc->sc_radio == RadioIntersil) return (0); ostate = ATU_RADIO_ON(sc) ? B_TRUE : B_FALSE; if (on != ostate) { bzero(&radio, sizeof (radio)); radio.Cmd = on ? CMD_RADIO_ON : CMD_RADIO_OFF; err = atu_send_command(sc, (uint8_t *)&radio, sizeof (radio)); if (err) return (err); err = atu_wait_completion(sc, radio.Cmd, NULL); if (err) return (err); if (on) sc->sc_flags |= ATU_FLAG_RADIO_ON; else sc->sc_flags &= ~ATU_FLAG_RADIO_ON; } return (0); } static int atu_config(struct atu_softc *sc) { struct ieee80211com *ic = &sc->sc_ic; struct ieee80211_key *k; struct atu_cmd_card_config cmd; uint8_t rates[4] = {0x82, 0x84, 0x8B, 0x96}; int err, i; err = atu_send_mib(sc, MIB_MAC_ADDR_STA, ic->ic_macaddr); if (err) { cmn_err(CE_WARN, "%s: setting MAC address failed\n", sc->sc_name); return (err); } bzero(&cmd, sizeof (cmd)); cmd.Cmd = CMD_STARTUP; cmd.Reserved = 0; cmd.Size = sizeof (cmd) - 4; cmd.Channel = ATU_DEF_CHAN; cmd.ShortRetryLimit = 7; cmd.RTS_Threshold = 2347; cmd.FragThreshold = 2346; cmd.PromiscuousMode = 1; cmd.AutoRateFallback = 1; bcopy(rates, cmd.BasicRateSet, 4); if (ic->ic_flags & IEEE80211_F_PRIVACY) { k = ic->ic_nw_keys + ic->ic_def_txkey; switch (k->wk_keylen) { case 5: cmd.EncryptionType = ATU_ENC_WEP40; break; case 13: cmd.EncryptionType = ATU_ENC_WEP104; break; default: cmn_err(CE_WARN, "%s: key invalid (%d bytes)\n", sc->sc_name, k->wk_keylen); goto nowep; } cmd.PrivacyInvoked = 1; cmd.ExcludeUnencrypted = 1; cmd.WEP_DefaultKeyID = ic->ic_def_txkey; for (i = 0; i < IEEE80211_WEP_NKID; i++) { k = ic->ic_nw_keys + i; if (k->wk_keylen == 0) continue; bcopy(k->wk_key, cmd.WEP_DefaultKey + i, k->wk_keylen); } } else { nowep: cmd.EncryptionType = ATU_ENC_NONE; } bcopy(ic->ic_des_essid, cmd.SSID, ic->ic_des_esslen); cmd.SSID_Len = ic->ic_des_esslen; cmd.BeaconPeriod = 100; err = atu_send_command(sc, (uint8_t *)&cmd, sizeof (cmd)); if (err) return (err); err = atu_wait_completion(sc, CMD_STARTUP, NULL); if (err) return (err); err = atu_switch_radio(sc, B_TRUE); if (err) return (err); err = atu_send_mib(sc, MIB_MAC_MGMT_POWER_MODE, (void *)ATU_POWER_ACTIVE); if (err) return (err); return (0); } static int atu_start_scan(struct atu_softc *sc) { struct ieee80211com *ic = &sc->sc_ic; struct atu_cmd_do_scan scan; int err; if (!ATU_RUNNING(sc)) return (EIO); bzero(&scan, sizeof (scan)); scan.Cmd = CMD_START_SCAN; scan.Reserved = 0; scan.Size = sizeof (scan) - 4; (void) memset(scan.BSSID, 0xff, sizeof (scan.BSSID)); bcopy(ic->ic_des_essid, scan.SSID, ic->ic_des_esslen); scan.SSID_Len = ic->ic_des_esslen; scan.ScanType = ATU_SCAN_ACTIVE; scan.Channel = ieee80211_chan2ieee(ic, ic->ic_curchan); scan.ProbeDelay = 0; scan.MinChannelTime = 20; scan.MaxChannelTime = 40; scan.InternationalScan = 0; err = atu_send_command(sc, (uint8_t *)&scan, sizeof (scan)); if (err) { cmn_err(CE_WARN, "%s: SCAN command failed\n", sc->sc_name); return (err); } err = atu_wait_completion(sc, CMD_START_SCAN, NULL); if (err) { cmn_err(CE_WARN, "%s: SCAN completion failed\n", sc->sc_name); return (err); } return (0); } static int atu_join(struct atu_softc *sc, struct ieee80211_node *node) { struct atu_cmd_join join; uint8_t status; int err; bzero(&join, sizeof (join)); join.Cmd = CMD_JOIN; join.Reserved = 0x00; join.Size = sizeof (join) - 4; bcopy(node->in_bssid, join.bssid, IEEE80211_ADDR_LEN); bcopy(node->in_essid, join.essid, node->in_esslen); join.essid_size = node->in_esslen; if (node->in_capinfo & IEEE80211_CAPINFO_IBSS) join.bss_type = ATU_MODE_IBSS; else join.bss_type = ATU_MODE_STA; join.channel = ieee80211_chan2ieee(&sc->sc_ic, node->in_chan); join.timeout = ATU_JOIN_TIMEOUT; join.reserved = 0x00; err = atu_send_command(sc, (uint8_t *)&join, sizeof (join)); if (err) { cmn_err(CE_WARN, "%s: JOIN command failed\n", sc->sc_name); return (err); } err = atu_wait_completion(sc, CMD_JOIN, &status); if (err) return (err); if (status != STATUS_COMPLETE) { cmn_err(CE_WARN, "%s: incorrect JOIN state (0x%02x)\n", sc->sc_name, status); return (EIO); } return (0); } static int atu_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) { struct atu_softc *sc = (struct atu_softc *)ic; enum ieee80211_state ostate = ic->ic_state; int err = 0; ATU_LOCK(sc); if (sc->sc_scan_timer != 0) { ATU_UNLOCK(sc); (void) untimeout(sc->sc_scan_timer); ATU_LOCK(sc); sc->sc_scan_timer = 0; } ostate = ic->ic_state; switch (nstate) { case IEEE80211_S_SCAN: switch (ostate) { case IEEE80211_S_SCAN: case IEEE80211_S_AUTH: case IEEE80211_S_ASSOC: case IEEE80211_S_RUN: ATU_UNLOCK(sc); sc->sc_newstate(ic, nstate, arg); ATU_LOCK(sc); if ((err = atu_start_scan(sc)) != 0) { ATU_UNLOCK(sc); ieee80211_cancel_scan(ic); return (err); } sc->sc_scan_timer = timeout( (void (*) (void*))ieee80211_next_scan, (void *)&sc->sc_ic, 0); ATU_UNLOCK(sc); return (err); default: break; } break; case IEEE80211_S_AUTH: switch (ostate) { case IEEE80211_S_INIT: case IEEE80211_S_SCAN: err = atu_join(sc, ic->ic_bss); if (err) { ATU_UNLOCK(sc); return (err); } break; default: break; } default: break; } ATU_UNLOCK(sc); err = sc->sc_newstate(ic, nstate, arg); return (err); } static int atu_open_pipes(struct atu_softc *sc) { usb_ep_data_t *ep; usb_pipe_policy_t policy = {0}; int uret; ep = usb_lookup_ep_data(sc->sc_dip, sc->sc_udev, 0, 0, 0, USB_EP_ATTR_BULK, USB_EP_DIR_OUT); policy.pp_max_async_reqs = ATU_TX_LIST_CNT; uret = usb_pipe_open(sc->sc_dip, &ep->ep_descr, &policy, USB_FLAGS_SLEEP, &sc->sc_tx_pipe); if (uret != USB_SUCCESS) goto fail; ep = usb_lookup_ep_data(sc->sc_dip, sc->sc_udev, 0, 0, 0, USB_EP_ATTR_BULK, USB_EP_DIR_IN); policy.pp_max_async_reqs = ATU_RX_LIST_CNT + 32; uret = usb_pipe_open(sc->sc_dip, &ep->ep_descr, &policy, USB_FLAGS_SLEEP, &sc->sc_rx_pipe); if (uret != USB_SUCCESS) goto fail; return (0); fail: if (sc->sc_rx_pipe != NULL) { usb_pipe_close(sc->sc_dip, sc->sc_rx_pipe, USB_FLAGS_SLEEP, NULL, 0); sc->sc_rx_pipe = NULL; } if (sc->sc_tx_pipe != NULL) { usb_pipe_close(sc->sc_dip, sc->sc_tx_pipe, USB_FLAGS_SLEEP, NULL, 0); sc->sc_tx_pipe = NULL; } return (EIO); } static void atu_close_pipes(struct atu_softc *sc) { usb_flags_t flags = USB_FLAGS_SLEEP; if (sc->sc_rx_pipe != NULL) { usb_pipe_reset(sc->sc_dip, sc->sc_rx_pipe, flags, NULL, 0); usb_pipe_close(sc->sc_dip, sc->sc_rx_pipe, flags, NULL, 0); sc->sc_rx_pipe = NULL; } if (sc->sc_tx_pipe != NULL) { usb_pipe_reset(sc->sc_dip, sc->sc_tx_pipe, flags, NULL, 0); usb_pipe_close(sc->sc_dip, sc->sc_tx_pipe, flags, NULL, 0); sc->sc_tx_pipe = NULL; } } static int atu_rx_trigger(struct atu_softc *sc); /*ARGSUSED*/ static void atu_rxeof(usb_pipe_handle_t pipe, usb_bulk_req_t *req) { struct atu_softc *sc = (struct atu_softc *)req->bulk_client_private; struct ieee80211com *ic = &sc->sc_ic; struct ieee80211_node *ni; struct atu_rx_hdr *h; struct ieee80211_frame *wh; mblk_t *mp = req->bulk_data; int len, pktlen; req->bulk_data = NULL; if (req->bulk_completion_reason != USB_CR_OK) { sc->sc_rx_err++; goto fail; } len = msgdsize(mp); if (len < ATU_RX_HDRLEN + ATU_MIN_FRAMELEN) { cmn_err(CE_CONT, "%s: fragment (%d bytes)\n", sc->sc_name, len); sc->sc_rx_err++; goto fail; } h = (struct atu_rx_hdr *)mp->b_rptr; pktlen = h->length - 4; if (pktlen + ATU_RX_HDRLEN + 4 != len) { cmn_err(CE_CONT, "%s: jumbo (%d bytes -> %d bytes)\n", sc->sc_name, len, pktlen); sc->sc_rx_err++; goto fail; } mp->b_rptr += ATU_RX_HDRLEN; mp->b_wptr = mp->b_rptr + pktlen; wh = (struct ieee80211_frame *)mp->b_rptr; if (wh->i_fc[1] & IEEE80211_FC1_WEP) wh->i_fc[1] &= ~IEEE80211_FC1_WEP; ni = ieee80211_find_rxnode(ic, wh); (void) ieee80211_input(ic, mp, ni, h->rssi, h->rx_time); ieee80211_free_node(ni); done: usb_free_bulk_req(req); mutex_enter(&sc->sc_rxlock); sc->rx_queued--; mutex_exit(&sc->sc_rxlock); if (ATU_RUNNING(sc)) (void) atu_rx_trigger(sc); return; fail: freemsg(mp); goto done; } /*ARGSUSED*/ static void atu_txeof(usb_pipe_handle_t pipe, usb_bulk_req_t *req) { struct atu_softc *sc = (struct atu_softc *)req->bulk_client_private; struct ieee80211com *ic = &sc->sc_ic; if (req->bulk_completion_reason != USB_CR_OK) ic->ic_stats.is_tx_failed++; usb_free_bulk_req(req); mutex_enter(&sc->sc_txlock); sc->tx_queued--; if (sc->sc_need_sched) { sc->sc_need_sched = 0; mac_tx_update(ic->ic_mach); } mutex_exit(&sc->sc_txlock); } static int atu_rx_trigger(struct atu_softc *sc) { usb_bulk_req_t *req; int uret; req = usb_alloc_bulk_req(sc->sc_dip, ATU_RX_BUFSZ, USB_FLAGS_SLEEP); if (req == NULL) return (ENOMEM); req->bulk_len = ATU_RX_BUFSZ; req->bulk_client_private = (usb_opaque_t)sc; req->bulk_timeout = 0; req->bulk_attributes = USB_ATTRS_SHORT_XFER_OK | USB_ATTRS_AUTOCLEARING; req->bulk_cb = atu_rxeof; req->bulk_exc_cb = atu_rxeof; req->bulk_completion_reason = 0; req->bulk_cb_flags = 0; uret = usb_pipe_bulk_xfer(sc->sc_rx_pipe, req, 0); if (uret != USB_SUCCESS) { usb_free_bulk_req(req); return (EIO); } mutex_enter(&sc->sc_rxlock); sc->rx_queued++; mutex_exit(&sc->sc_rxlock); return (0); } static int atu_tx_trigger(struct atu_softc *sc, mblk_t *mp) { usb_bulk_req_t *req; int uret; req = usb_alloc_bulk_req(sc->sc_dip, 0, USB_FLAGS_SLEEP); if (req == NULL) return (EIO); req->bulk_len = msgdsize(mp); req->bulk_data = mp; req->bulk_client_private = (usb_opaque_t)sc; req->bulk_timeout = 10; req->bulk_attributes = USB_ATTRS_AUTOCLEARING; req->bulk_cb = atu_txeof; req->bulk_exc_cb = atu_txeof; req->bulk_completion_reason = 0; req->bulk_cb_flags = 0; uret = usb_pipe_bulk_xfer(sc->sc_tx_pipe, req, 0); if (uret != USB_SUCCESS) { req->bulk_data = NULL; usb_free_bulk_req(req); return (EIO); } mutex_enter(&sc->sc_txlock); sc->tx_queued++; mutex_exit(&sc->sc_txlock); return (0); } static int atu_init_rx_queue(struct atu_softc *sc) { int err, i; mutex_enter(&sc->sc_rxlock); sc->rx_queued = 0; mutex_exit(&sc->sc_rxlock); for (i = 0; i < ATU_RX_LIST_CNT; i++) { err = atu_rx_trigger(sc); if (err) return (err); } return (0); } static void atu_init_tx_queue(struct atu_softc *sc) { mutex_enter(&sc->sc_txlock); sc->tx_queued = 0; mutex_exit(&sc->sc_txlock); } static int atu_send(ieee80211com_t *ic, mblk_t *mp, uint8_t type) { struct atu_softc *sc = (struct atu_softc *)ic; struct ieee80211_node *ni = NULL; struct atu_tx_hdr *desc; struct ieee80211_frame *wh; mblk_t *m; int pktlen = msgdsize(mp), err = 0; mutex_enter(&sc->sc_txlock); if (sc->tx_queued > ATU_TX_LIST_CNT) { sc->sc_tx_nobuf++; mutex_exit(&sc->sc_txlock); err = ENOMEM; goto fail; } mutex_exit(&sc->sc_txlock); m = allocb(ATU_TX_BUFSZ, BPRI_MED); if (m == NULL) { sc->sc_tx_nobuf++; err = ENOMEM; goto fail; } /* reserve tx header space */ m->b_rptr += ATU_TX_HDRLEN; m->b_wptr += ATU_TX_HDRLEN; /* copy and (implicitly) free old data */ mcopymsg(mp, m->b_wptr); m->b_wptr += pktlen; wh = (struct ieee80211_frame *)m->b_rptr; ni = ieee80211_find_txnode(ic, wh->i_addr1); if (ni == NULL) { ic->ic_stats.is_tx_failed++; freemsg(m); err = ENXIO; goto fail; } if (type == IEEE80211_FC0_TYPE_DATA) (void) ieee80211_encap(ic, m, ni); /* full WEP in device, prune WEP fields (IV, KID) */ if (wh->i_fc[1] & IEEE80211_FC1_WEP) { (void) memmove(m->b_rptr + IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN, m->b_rptr, sizeof (struct ieee80211_frame)); m->b_rptr += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN; } pktlen = msgdsize(m); m->b_rptr -= ATU_TX_HDRLEN; /* setup tx header */ desc = (struct atu_tx_hdr *)m->b_rptr; bzero(desc, ATU_TX_HDRLEN); desc->length = (uint16_t)pktlen; desc->tx_rate = ATU_DEF_TX_RATE; err = atu_tx_trigger(sc, m); if (!err) { ic->ic_stats.is_tx_frags++; ic->ic_stats.is_tx_bytes += pktlen; } else { ic->ic_stats.is_tx_failed++; freemsg(m); } fail: if (ni != NULL) ieee80211_free_node(ni); return (err); } static int atu_stop(struct atu_softc *sc) { sc->sc_flags &= ~ATU_FLAG_RUNNING; atu_close_pipes(sc); return (atu_switch_radio(sc, B_FALSE)); } static int atu_init(struct atu_softc *sc) { int err; err = atu_stop(sc); if (err) return (err); err = atu_open_pipes(sc); if (err) goto fail; err = atu_config(sc); if (err) { cmn_err(CE_WARN, "%s: startup config failed\n", sc->sc_name); goto fail; } atu_init_tx_queue(sc); err = atu_init_rx_queue(sc); if (err) { cmn_err(CE_WARN, "%s: rx queue init failed\n", sc->sc_name); goto fail; } sc->sc_flags |= ATU_FLAG_RUNNING; return (0); fail: (void) atu_stop(sc); return (err); } static void atu_watchdog(void *arg) { struct atu_softc *sc = arg; struct ieee80211com *ic = &sc->sc_ic; ieee80211_stop_watchdog(ic); ATU_LOCK(sc); if (!ATU_RUNNING(sc)) { ATU_UNLOCK(sc); return; } ATU_UNLOCK(sc); switch (ic->ic_state) { case IEEE80211_S_AUTH: case IEEE80211_S_ASSOC: if (ic->ic_bss->in_fails > 0) ieee80211_new_state(ic, IEEE80211_S_INIT, -1); else ieee80211_watchdog(ic); break; } } static int atu_dfu_stage1(void *arg) { struct atu_softc *sc = arg; uint8_t state, *ptr = NULL, status[6]; int block_size, bytes_left = 0, block = 0, err, i, count = 0; /* * Uploading firmware is done with the DFU (Device Firmware Upgrade) * interface. See "Universal Serial Bus - Device Class Specification * for Device Firmware Upgrade" pdf for details of the protocol. * Maybe this could be moved to a separate 'firmware driver' once more * device drivers need it... For now we'll just do it here. * * Just for your information, the Atmel's DFU descriptor looks like * this: * * 07 size * 21 type * 01 capabilities : only firmware download, *need* reset * after download * 13 05 detach timeout : max 1299ms between DFU_DETACH and * reset * 00 04 max bytes of firmware per transaction : 1024 */ for (i = 0; i < sizeof (atu_fw_table) / sizeof (atu_fw_table[0]); i++) if (sc->sc_radio == atu_fw_table[i].atur_type) { ptr = atu_fw_table[i].atur_int; bytes_left = atu_fw_table[i].atur_int_size; } state = atu_get_dfu_state(sc); while (block >= 0 && state > 0) { switch (state) { case DFUState_DnLoadSync: /* get DFU status */ err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0, 6, status); if (err) { cmn_err(CE_WARN, "%s: DFU get status failed\n", sc->sc_name); return (err); } /* success means state => DnLoadIdle */ state = DFUState_DnLoadIdle; continue; case DFUState_DFUIdle: case DFUState_DnLoadIdle: if (bytes_left >= DFU_MaxBlockSize) block_size = DFU_MaxBlockSize; else block_size = bytes_left; err = atu_usb_request(sc, DFU_DNLOAD, block++, 0, block_size, ptr); if (err) { cmn_err(CE_WARN, "%s: DFU download failed\n", sc->sc_name); return (err); } ptr += block_size; bytes_left -= block_size; if (block_size == 0) block = -1; break; case DFUState_DFUError: cmn_err(CE_WARN, "%s: DFU state error\n", sc->sc_name); return (EIO); default: drv_usecwait(10*1000); if (++count > 100) { cmn_err(CE_WARN, "%s: DFU timeout\n", sc->sc_name); return (ETIME); } break; } state = atu_get_dfu_state(sc); } if (state != DFUState_ManifestSync) cmn_err(CE_WARN, "%s: DFU state (%d) != ManifestSync\n", sc->sc_name, state); err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0, 6, status); if (err) { cmn_err(CE_WARN, "%s: DFU get status failed\n", sc->sc_name); return (err); } err = atu_usb_request(sc, DFU_REMAP, 0, 0, 0, NULL); if (err && !(sc->sc_quirk & ATU_QUIRK_NO_REMAP)) { cmn_err(CE_WARN, "%s: DFU remap failed\n", sc->sc_name); return (err); } /* * after a lot of trying and measuring I found out the device needs * about 56 miliseconds after sending the remap command before * it's ready to communicate again. So we'll wait just a little bit * longer than that to be sure... */ drv_usecwait((56+100)*1000); return (0); } static int atu_dfu_stage2(void *arg) { struct atu_softc *sc = arg; uint8_t *ptr = NULL; int block_size, bytes_left = 0, block = 0, err, i; for (i = 0; i < sizeof (atu_fw_table) / sizeof (atu_fw_table[0]); i++) if (sc->sc_radio == atu_fw_table[i].atur_type) { ptr = atu_fw_table[i].atur_ext; bytes_left = atu_fw_table[i].atur_ext_size; } while (bytes_left) { if (bytes_left > 1024) block_size = 1024; else block_size = bytes_left; err = atu_usb_request(sc, ATU_VENDOR_DEV_OUT, 0x0e, 0x0802, block, block_size, ptr); if (err) { cmn_err(CE_WARN, "%s: stage2 firmware load failed\n", sc->sc_name); return (err); } ptr += block_size; block++; bytes_left -= block_size; } err = atu_usb_request(sc, ATU_VENDOR_DEV_OUT, 0x0e, 0x0802, block, 0, NULL); if (err) { cmn_err(CE_WARN, "%s: zero-length block load failed\n", sc->sc_name); return (err); } /* * The SMC2662w V.4 seems to require some time to do its thing with * the stage2 firmware... 20 ms isn't enough, but 21 ms works 100 * times out of 100 tries. We'll wait a bit longer just to be sure */ if (sc->sc_quirk & ATU_QUIRK_FW_DELAY) drv_usecwait((21 + 100) * 1000); return (0); } static int atu_load_microcode(struct atu_softc *sc, boolean_t attach) { usb_dev_reset_lvl_t reset; uint8_t mode, chan; int err; reset = attach ? USB_RESET_LVL_REATTACH : USB_RESET_LVL_DEFAULT; err = atu_get_opmode(sc, &mode); if (!err) { if (mode == ATU_DEV_READY) return (0); /* * Opmode of SMC2662 V.4 does not change after stage2 * firmware download. If succeeded reading the channel * number, stage2 firmware is already running. */ if (sc->sc_radio != RadioIntersil && atu_get_mib(sc, MIB_PHY_CHANNEL, &chan) == 0) return (0); if (mode == ATU_DEV_STAGE2) stage2: return (atu_dfu_stage2(sc)); } err = atu_dfu_stage1(sc); if (err) return (err); if (usb_reset_device(sc->sc_dip, reset) != USB_SUCCESS) return (EIO); if (attach) return (EAGAIN); else goto stage2; } static int atu_disconnect(dev_info_t *dip) { struct atu_softc *sc; struct ieee80211com *ic; sc = ddi_get_soft_state(atu_soft_state_p, ddi_get_instance(dip)); ic = &sc->sc_ic; ieee80211_new_state(ic, IEEE80211_S_INIT, -1); ieee80211_stop_watchdog(ic); ATU_LOCK(sc); if (sc->sc_scan_timer != 0) { ATU_UNLOCK(sc); (void) untimeout(sc->sc_scan_timer); ATU_LOCK(sc); sc->sc_scan_timer = 0; } sc->sc_flags &= ~(ATU_FLAG_RUNNING | ATU_FLAG_RADIO_ON); atu_close_pipes(sc); ATU_UNLOCK(sc); return (0); } static int atu_reconnect(dev_info_t *dip) { struct atu_softc *sc; int err; sc = ddi_get_soft_state(atu_soft_state_p, ddi_get_instance(dip)); if (usb_check_same_device(sc->sc_dip, NULL, USB_LOG_L2, -1, USB_CHK_BASIC, NULL) != USB_SUCCESS) return (DDI_FAILURE); ATU_LOCK(sc); err = atu_load_microcode(sc, B_FALSE); if (!err) err = atu_init(sc); ATU_UNLOCK(sc); return (err ? DDI_FAILURE : DDI_SUCCESS); } static int atu_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) { struct atu_softc *sc; struct ieee80211com *ic; mac_register_t *macp; wifi_data_t wd = {0}; int instance, i, err; switch (cmd) { case DDI_ATTACH: break; case DDI_RESUME: sc = ddi_get_soft_state(atu_soft_state_p, ddi_get_instance(dip)); if (usb_check_same_device(sc->sc_dip, NULL, USB_LOG_L2, -1, USB_CHK_BASIC, NULL) != USB_SUCCESS) return (DDI_SUCCESS); if (atu_load_microcode(sc, B_FALSE) == 0) (void) atu_init(sc); return (DDI_SUCCESS); default: return (DDI_FAILURE); } instance = ddi_get_instance(dip); if (ddi_soft_state_zalloc(atu_soft_state_p, instance) != DDI_SUCCESS) return (DDI_FAILURE); sc = ddi_get_soft_state(atu_soft_state_p, instance); ic = &sc->sc_ic; sc->sc_dip = dip; (void) snprintf(sc->sc_name, sizeof (sc->sc_name), "%s%d", "atu", instance); err = usb_client_attach(dip, USBDRV_VERSION, 0); if (err != USB_SUCCESS) goto fail1; err = usb_get_dev_data(dip, &sc->sc_udev, USB_PARSE_LVL_ALL, 0); if (err != USB_SUCCESS) { sc->sc_udev = NULL; goto fail2; } for (i = 0; i < sizeof (atu_dev_table)/sizeof (atu_dev_table[0]); i++) { struct atu_dev_type *t = &atu_dev_table[i]; if (sc->sc_udev->dev_descr->idVendor == t->atu_vid && sc->sc_udev->dev_descr->idProduct == t->atu_pid) { sc->sc_radio = t->atu_radio; sc->sc_quirk = t->atu_quirk; } } err = atu_load_microcode(sc, B_TRUE); if (err == EAGAIN) { sc->sc_flags |= ATU_FLAG_REATTACH; /* reattaching */ return (DDI_SUCCESS); } else if (err) { goto fail2; } sc->sc_flags &= ~ATU_FLAG_REATTACH; /* read device config & MAC address */ err = atu_get_config(sc); if (err) { cmn_err(CE_WARN, "%s: read device config failed\n", sc->sc_name); goto fail2; } mutex_init(&sc->sc_genlock, NULL, MUTEX_DRIVER, NULL); mutex_init(&sc->sc_txlock, NULL, MUTEX_DRIVER, NULL); mutex_init(&sc->sc_rxlock, NULL, MUTEX_DRIVER, NULL); ic->ic_phytype = IEEE80211_T_DS; ic->ic_opmode = IEEE80211_M_STA; ic->ic_caps = IEEE80211_C_SHPREAMBLE | IEEE80211_C_WEP; ic->ic_sup_rates[IEEE80211_MODE_11B] = atu_rateset; ic->ic_maxrssi = atu_fw_table[sc->sc_radio].max_rssi; ic->ic_state = IEEE80211_S_INIT; for (i = 1; i <= 14; i++) { ic->ic_sup_channels[i].ich_freq = ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ); ic->ic_sup_channels[i].ich_flags = IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_PASSIVE; } ic->ic_xmit = atu_send; ieee80211_attach(ic); sc->sc_newstate = ic->ic_newstate; ic->ic_newstate = atu_newstate; ic->ic_watchdog = atu_watchdog; ieee80211_media_init(ic); ic->ic_def_txkey = 0; wd.wd_opmode = ic->ic_opmode; wd.wd_secalloc = WIFI_SEC_NONE; IEEE80211_ADDR_COPY(wd.wd_bssid, ic->ic_bss->in_bssid); macp = mac_alloc(MAC_VERSION); if (macp == NULL) goto fail3; macp->m_type_ident = MAC_PLUGIN_IDENT_WIFI; macp->m_driver = sc; macp->m_dip = dip; macp->m_src_addr = ic->ic_macaddr; macp->m_callbacks = &atu_m_callbacks; macp->m_min_sdu = 0; macp->m_max_sdu = IEEE80211_MTU; macp->m_pdata = &wd; macp->m_pdata_size = sizeof (wd); err = mac_register(macp, &ic->ic_mach); mac_free(macp); if (err) goto fail3; err = usb_register_hotplug_cbs(sc->sc_dip, atu_disconnect, atu_reconnect); if (err != USB_SUCCESS) goto fail4; err = ddi_create_minor_node(dip, sc->sc_name, S_IFCHR, instance + 1, DDI_NT_NET_WIFI, 0); if (err != DDI_SUCCESS) cmn_err(CE_WARN, "%s: minor node creation failed\n", sc->sc_name); mac_link_update(ic->ic_mach, LINK_STATE_DOWN); return (DDI_SUCCESS); fail4: (void) mac_unregister(ic->ic_mach); fail3: mutex_destroy(&sc->sc_genlock); mutex_destroy(&sc->sc_rxlock); mutex_destroy(&sc->sc_txlock); fail2: usb_client_detach(sc->sc_dip, sc->sc_udev); fail1: ddi_soft_state_free(atu_soft_state_p, instance); return (DDI_FAILURE); } static int atu_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) { struct atu_softc *sc; int err; sc = ddi_get_soft_state(atu_soft_state_p, ddi_get_instance(dip)); switch (cmd) { case DDI_DETACH: break; case DDI_SUSPEND: ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1); ieee80211_stop_watchdog(&sc->sc_ic); ATU_LOCK(sc); if (sc->sc_scan_timer != 0) { ATU_UNLOCK(sc); (void) untimeout(sc->sc_scan_timer); ATU_LOCK(sc); sc->sc_scan_timer = 0; } (void) atu_stop(sc); ATU_UNLOCK(sc); return (DDI_SUCCESS); default: return (DDI_FAILURE); } if (!ATU_REATTACH(sc)) { err = mac_disable(sc->sc_ic.ic_mach); if (err) return (DDI_FAILURE); (void) atu_stop(sc); usb_unregister_hotplug_cbs(dip); (void) mac_unregister(sc->sc_ic.ic_mach); ieee80211_detach(&sc->sc_ic); mutex_destroy(&sc->sc_genlock); mutex_destroy(&sc->sc_txlock); mutex_destroy(&sc->sc_rxlock); ddi_remove_minor_node(dip, NULL); } usb_client_detach(dip, sc->sc_udev); ddi_soft_state_free(atu_soft_state_p, ddi_get_instance(dip)); return (DDI_SUCCESS); } DDI_DEFINE_STREAM_OPS(atu_dev_ops, nulldev, nulldev, atu_attach, atu_detach, nodev, NULL, D_MP, NULL, ddi_quiesce_not_needed); static struct modldrv atu_modldrv = { &mod_driverops, "atu driver v1.1", &atu_dev_ops }; static struct modlinkage modlinkage = { MODREV_1, (void *)&atu_modldrv, NULL }; int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } int _init(void) { int status; status = ddi_soft_state_init(&atu_soft_state_p, sizeof (struct atu_softc), 1); if (status != 0) return (status); mac_init_ops(&atu_dev_ops, "atu"); status = mod_install(&modlinkage); if (status != 0) { mac_fini_ops(&atu_dev_ops); ddi_soft_state_fini(&atu_soft_state_p); } return (status); } int _fini(void) { int status; status = mod_remove(&modlinkage); if (status == 0) { mac_fini_ops(&atu_dev_ops); ddi_soft_state_fini(&atu_soft_state_p); } return (status); } static int atu_m_start(void *arg) { struct atu_softc *sc = (struct atu_softc *)arg; int err; ATU_LOCK(sc); err = atu_init(sc); ATU_UNLOCK(sc); return (err); } static void atu_m_stop(void *arg) { struct atu_softc *sc = (struct atu_softc *)arg; struct ieee80211com *ic = &sc->sc_ic; ieee80211_new_state(ic, IEEE80211_S_INIT, -1); ieee80211_stop_watchdog(ic); ATU_LOCK(sc); if (sc->sc_scan_timer != 0) { ATU_UNLOCK(sc); (void) untimeout(sc->sc_scan_timer); ATU_LOCK(sc); sc->sc_scan_timer = 0; } (void) atu_stop(sc); ATU_UNLOCK(sc); } /*ARGSUSED*/ static int atu_m_unicst(void *arg, const uint8_t *macaddr) { return (ENOTSUP); } /*ARGSUSED*/ static int atu_m_multicst(void *arg, boolean_t add, const uint8_t *mca) { return (ENOTSUP); } /*ARGSUSED*/ static int atu_m_promisc(void *arg, boolean_t on) { return (0); } static int atu_m_setprop(void *arg, const char *name, mac_prop_id_t id, uint_t len, const void *buf) { struct atu_softc *sc = (struct atu_softc *)arg; struct ieee80211com *ic = &sc->sc_ic; int err; err = ieee80211_setprop(ic, name, id, len, buf); if (err != ENETRESET) return (err); if (ic->ic_des_esslen == 0) return (0); ATU_LOCK(sc); if (ATU_RUNNING(sc)) { if (sc->sc_scan_timer != 0) { ATU_UNLOCK(sc); (void) untimeout(sc->sc_scan_timer); ATU_LOCK(sc); sc->sc_scan_timer = 0; } err = atu_init(sc); ATU_UNLOCK(sc); if (err) return (err); ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); ATU_LOCK(sc); } ATU_UNLOCK(sc); return (0); } static int atu_m_getprop(void *arg, const char *name, mac_prop_id_t id, uint_t length, void *buf) { struct atu_softc *sc = (struct atu_softc *)arg; struct ieee80211com *ic = &sc->sc_ic; return (ieee80211_getprop(ic, name, id, length, buf)); } static void atu_m_propinfo(void *arg, const char *name, mac_prop_id_t id, mac_prop_info_handle_t mph) { struct atu_softc *sc = (struct atu_softc *)arg; struct ieee80211com *ic = &sc->sc_ic; ieee80211_propinfo(ic, name, id, mph); } static void atu_m_ioctl(void* arg, queue_t *wq, mblk_t *mp) { struct atu_softc *sc = (struct atu_softc *)arg; struct ieee80211com *ic = &sc->sc_ic; int err; err = ieee80211_ioctl(ic, wq, mp); if (err != ENETRESET || ic->ic_des_esslen == 0) return; ATU_LOCK(sc); if (ATU_RUNNING(sc)) { if (sc->sc_scan_timer != 0) { ATU_UNLOCK(sc); (void) untimeout(sc->sc_scan_timer); ATU_LOCK(sc); sc->sc_scan_timer = 0; } err = atu_init(sc); ATU_UNLOCK(sc); if (err) return; ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); ATU_LOCK(sc); } ATU_UNLOCK(sc); } static mblk_t * atu_m_tx(void *arg, mblk_t *mp) { struct atu_softc *sc = (struct atu_softc *)arg; struct ieee80211com *ic = &sc->sc_ic; mblk_t *next; if (ic->ic_state != IEEE80211_S_RUN) { freemsgchain(mp); return (NULL); } while (mp != NULL) { next = mp->b_next; mp->b_next = NULL; if (atu_send(ic, mp, IEEE80211_FC0_TYPE_DATA) == ENOMEM) { mutex_enter(&sc->sc_txlock); sc->sc_need_sched = 1; mutex_exit(&sc->sc_txlock); mp->b_next = next; return (mp); } mp = next; } return (mp); } static int atu_m_stat(void *arg, uint_t stat, uint64_t *val) { struct atu_softc *sc = (struct atu_softc *)arg; ieee80211com_t *ic = &sc->sc_ic; ieee80211_node_t *in; ATU_LOCK(sc); switch (stat) { case MAC_STAT_IFSPEED: in = ic->ic_bss; *val = ((ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) ? IEEE80211_RATE(in->in_txrate) : ic->ic_fixed_rate) / 2 * 1000000; break; case MAC_STAT_NOXMTBUF: *val = sc->sc_tx_nobuf; break; case MAC_STAT_NORCVBUF: *val = sc->sc_rx_nobuf; break; case MAC_STAT_IERRORS: *val = sc->sc_rx_err; break; case MAC_STAT_RBYTES: *val = ic->ic_stats.is_rx_bytes; break; case MAC_STAT_IPACKETS: *val = ic->ic_stats.is_rx_frags; break; case MAC_STAT_OBYTES: *val = ic->ic_stats.is_tx_bytes; break; case MAC_STAT_OPACKETS: *val = ic->ic_stats.is_tx_frags; break; case MAC_STAT_OERRORS: *val = ic->ic_stats.is_tx_failed; break; case WIFI_STAT_TX_FRAGS: case WIFI_STAT_MCAST_TX: case WIFI_STAT_TX_FAILED: case WIFI_STAT_TX_RETRANS: case WIFI_STAT_TX_RERETRANS: case WIFI_STAT_RTS_SUCCESS: case WIFI_STAT_RTS_FAILURE: case WIFI_STAT_ACK_FAILURE: case WIFI_STAT_RX_FRAGS: case WIFI_STAT_MCAST_RX: case WIFI_STAT_FCS_ERRORS: case WIFI_STAT_WEP_ERRORS: case WIFI_STAT_RX_DUPS: ATU_UNLOCK(sc); return (ieee80211_stat(ic, stat, val)); default: ATU_UNLOCK(sc); return (ENOTSUP); } ATU_UNLOCK(sc); return (0); } static mac_callbacks_t atu_m_callbacks = { MC_IOCTL | MC_SETPROP | MC_GETPROP | MC_PROPINFO, atu_m_stat, atu_m_start, atu_m_stop, atu_m_promisc, atu_m_multicst, atu_m_unicst, atu_m_tx, NULL, atu_m_ioctl, NULL, NULL, NULL, atu_m_setprop, atu_m_getprop, atu_m_propinfo };