1 /* $OpenBSD: if_urtwn.c,v 1.16 2011/02/10 17:26:40 jakemsr Exp $ */
4 * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr>
5 * Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org>
6 * Copyright (c) 2015-2016 Andriy Voskoboinyk <avos@FreeBSD.org>
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.
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.
21 #include <sys/cdefs.h>
22 __FBSDID("$FreeBSD$");
26 #include <sys/param.h>
28 #include <sys/mutex.h>
30 #include <sys/kernel.h>
31 #include <sys/socket.h>
32 #include <sys/systm.h>
33 #include <sys/malloc.h>
34 #include <sys/queue.h>
35 #include <sys/taskqueue.h>
37 #include <sys/endian.h>
38 #include <sys/linker.h>
41 #include <net/ethernet.h>
42 #include <net/if_media.h>
44 #include <net80211/ieee80211_var.h>
45 #include <net80211/ieee80211_radiotap.h>
46 #include <net80211/ieee80211_ratectl.h>
48 #include <dev/rtwn/if_rtwnreg.h>
49 #include <dev/rtwn/if_rtwnvar.h>
51 #include <dev/rtwn/if_rtwn_debug.h>
52 #include <dev/rtwn/if_rtwn_ridx.h>
53 #include <dev/rtwn/if_rtwn_rx.h>
54 #include <dev/rtwn/if_rtwn_task.h>
55 #include <dev/rtwn/if_rtwn_tx.h>
57 #include <dev/rtwn/rtl8192c/r92c.h>
58 #include <dev/rtwn/rtl8192c/r92c_reg.h>
59 #include <dev/rtwn/rtl8192c/r92c_var.h>
60 #include <dev/rtwn/rtl8192c/r92c_fw_cmd.h>
61 #include <dev/rtwn/rtl8192c/r92c_tx_desc.h>
64 #ifndef RTWN_WITHOUT_UCODE
66 r92c_fw_cmd(struct rtwn_softc *sc, uint8_t id, const void *buf, int len)
68 struct r92c_fw_cmd cmd;
71 KASSERT(len <= sizeof(cmd.msg),
72 ("%s: firmware command too long (%d > %zu)\n",
73 __func__, len, sizeof(cmd.msg)));
75 if (!(sc->sc_flags & RTWN_FW_LOADED)) {
76 RTWN_DPRINTF(sc, RTWN_DEBUG_FIRMWARE, "%s: firmware "
77 "was not loaded; command (id %u) will be discarded\n",
82 /* Wait for current FW box to be empty. */
83 for (ntries = 0; ntries < 100; ntries++) {
84 if (!(rtwn_read_1(sc, R92C_HMETFR) & (1 << sc->fwcur)))
89 device_printf(sc->sc_dev,
90 "could not send firmware command\n");
93 memset(&cmd, 0, sizeof(cmd));
96 /* Ext command: [id : byte2 : byte3 : byte4 : byte0 : byte1] */
97 cmd.id |= R92C_CMD_FLAG_EXT;
98 memcpy(cmd.msg, (const uint8_t *)buf + 2, len - 2);
99 memcpy(cmd.msg + 3, buf, 2);
101 memcpy(cmd.msg, buf, len);
103 /* Write the first word last since that will trigger the FW. */
105 error = rtwn_write_2(sc, R92C_HMEBOX_EXT(sc->fwcur),
106 *(uint16_t *)((uint8_t *)&cmd + 4));
110 error = rtwn_write_4(sc, R92C_HMEBOX(sc->fwcur),
115 sc->fwcur = (sc->fwcur + 1) % R92C_H2C_NBOX;
121 r92c_fw_reset(struct rtwn_softc *sc, int reason)
125 if (reason == RTWN_FW_RESET_CHECKSUM)
128 /* Tell 8051 to reset itself. */
129 rtwn_write_1(sc, R92C_HMETFR + 3, 0x20);
131 /* Wait until 8051 resets by itself. */
132 for (ntries = 0; ntries < 100; ntries++) {
133 if ((rtwn_read_2(sc, R92C_SYS_FUNC_EN) &
134 R92C_SYS_FUNC_EN_CPUEN) == 0)
138 /* Force 8051 reset. */
139 rtwn_setbits_1_shift(sc, R92C_SYS_FUNC_EN,
140 R92C_SYS_FUNC_EN_CPUEN, 0, 1);
144 r92c_fw_download_enable(struct rtwn_softc *sc, int enable)
148 rtwn_setbits_1_shift(sc, R92C_SYS_FUNC_EN, 0,
149 R92C_SYS_FUNC_EN_CPUEN, 1);
150 /* MCU firmware download enable. */
151 rtwn_setbits_1(sc, R92C_MCUFWDL, 0, R92C_MCUFWDL_EN);
153 rtwn_setbits_1_shift(sc, R92C_MCUFWDL, R92C_MCUFWDL_ROM_DLEN,
156 /* MCU download disable. */
157 rtwn_setbits_1(sc, R92C_MCUFWDL, R92C_MCUFWDL_EN, 0);
158 /* Reserved for f/w extension. */
159 rtwn_write_1(sc, R92C_MCUFWDL + 1, 0);
165 * Initialize firmware rate adaptation.
167 #ifndef RTWN_WITHOUT_UCODE
169 r92c_send_ra_cmd(struct rtwn_softc *sc, int macid, uint32_t rates,
172 struct r92c_fw_cmd_macid_cfg cmd;
176 /* XXX should be called directly from iv_newstate() for MACID_BC */
177 /* XXX joinbss, not send_ra_cmd() */
179 /* NB: group addressed frames are done at 11bg rates for now */
180 if (ic->ic_curmode == IEEE80211_MODE_11B)
181 mode = R92C_RAID_11B;
183 mode = R92C_RAID_11BG;
184 /* XXX misleading 'mode' value here for unicast frames */
185 RTWN_DPRINTF(sc, RTWN_DEBUG_RA,
186 "%s: mode 0x%x, rates 0x%08x, basicrates 0x%08x\n", __func__,
187 mode, rates, basicrates);
189 /* Set rates mask for group addressed frames. */
190 cmd.macid = RTWN_MACID_BC | R92C_CMD_MACID_VALID;
191 cmd.mask = htole32(mode << 28 | basicrates);
192 error = rtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd));
194 device_printf(sc->sc_dev,
195 "could not set RA mask for broadcast station\n");
200 /* Set rates mask for unicast frames. */
201 if (maxrate >= RTWN_RIDX_HT_MCS(0))
202 mode = R92C_RAID_11GN;
203 else if (maxrate >= RTWN_RIDX_OFDM6)
204 mode = R92C_RAID_11BG;
206 mode = R92C_RAID_11B;
207 cmd.macid = macid | R92C_CMD_MACID_VALID;
208 cmd.mask = htole32(mode << 28 | rates);
209 error = r92c_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd));
211 device_printf(sc->sc_dev,
212 "%s: could not set RA mask for %d station\n",
222 r92c_init_ra(struct rtwn_softc *sc, int macid)
224 struct ieee80211_htrateset *rs_ht;
225 struct ieee80211_node *ni;
230 if (sc->node_list[macid] == NULL) {
231 RTWN_DPRINTF(sc, RTWN_DEBUG_RA, "%s: macid %d, ni is NULL\n",
237 ni = ieee80211_ref_node(sc->node_list[macid]);
238 if (ni->ni_flags & IEEE80211_NODE_HT)
239 rs_ht = &ni->ni_htrates;
243 rtwn_get_rates(sc, &ni->ni_rates, rs_ht, &rates, &maxrate, 0);
246 #ifndef RTWN_WITHOUT_UCODE
247 if (sc->sc_ratectl == RTWN_RATECTL_FW) {
248 r92c_send_ra_cmd(sc, macid, rates, maxrate);
252 rtwn_write_1(sc, R92C_INIDATA_RATE_SEL(macid), maxrate);
254 ieee80211_free_node(ni);
258 r92c_joinbss_rpt(struct rtwn_softc *sc, int macid)
260 #ifndef RTWN_WITHOUT_UCODE
261 struct r92c_softc *rs = sc->sc_priv;
262 struct ieee80211vap *vap;
263 struct r92c_fw_cmd_joinbss_rpt cmd;
265 if (sc->vaps[0] == NULL) /* XXX fix */
268 vap = &sc->vaps[0]->vap;
269 if ((vap->iv_state == IEEE80211_S_RUN) ^
270 !(rs->rs_flags & R92C_FLAG_ASSOCIATED))
273 if (rs->rs_flags & R92C_FLAG_ASSOCIATED) {
274 cmd.mstatus = R92C_MSTATUS_DISASSOC;
275 rs->rs_flags &= ~R92C_FLAG_ASSOCIATED;
277 cmd.mstatus = R92C_MSTATUS_ASSOC;
278 rs->rs_flags |= R92C_FLAG_ASSOCIATED;
281 if (r92c_fw_cmd(sc, R92C_CMD_JOINBSS_RPT, &cmd, sizeof(cmd)) != 0) {
282 device_printf(sc->sc_dev, "%s: cannot change media status!\n",
289 /* TODO: init rates for RTWN_MACID_BC. */
290 if (macid & RTWN_MACID_VALID)
291 r92c_init_ra(sc, macid & ~RTWN_MACID_VALID);
294 #ifndef RTWN_WITHOUT_UCODE
296 r92c_set_rsvd_page(struct rtwn_softc *sc, int probe_resp, int null,
299 struct r92c_fw_cmd_rsvdpage rsvd;
301 rsvd.probe_resp = probe_resp;
303 rsvd.null_data = null;
305 return (r92c_fw_cmd(sc, R92C_CMD_RSVD_PAGE, &rsvd, sizeof(rsvd)));
309 r92c_set_pwrmode(struct rtwn_softc *sc, struct ieee80211vap *vap,
312 struct r92c_fw_cmd_pwrmode mode;
315 /* XXX dm_RF_saving */
317 if (off && vap->iv_state == IEEE80211_S_RUN &&
318 (vap->iv_flags & IEEE80211_F_PMGTON))
319 mode.mode = R92C_PWRMODE_MIN;
321 mode.mode = R92C_PWRMODE_CAM;
322 mode.smart_ps = R92C_PWRMODE_SMARTPS_NULLDATA;
323 mode.bcn_pass = 1; /* XXX */
324 error = r92c_fw_cmd(sc, R92C_CMD_SET_PWRMODE, &mode, sizeof(mode));
326 device_printf(sc->sc_dev,
327 "%s: CMD_SET_PWRMODE was not sent, error %d\n",
335 r92c_set_rssi(struct rtwn_softc *sc)
337 struct ieee80211_node *ni;
338 struct rtwn_node *rn;
339 struct r92c_fw_cmd_rssi cmd;
345 for (i = 0; i < sc->macid_limit; i++) {
347 ni = sc->node_list[i];
353 cmd.pwdb = rn->avg_pwdb;
354 RTWN_DPRINTF(sc, RTWN_DEBUG_RSSI,
355 "%s: sending RSSI command (macid %d, rssi %d)\n",
356 __func__, i, rn->avg_pwdb);
359 r92c_fw_cmd(sc, R92C_CMD_RSSI_SETTING, &cmd, sizeof(cmd));
366 r92c_ratectl_tx_complete(struct rtwn_softc *sc, uint8_t *buf, int len)
368 #if __FreeBSD_version >= 1200012
369 struct ieee80211_ratectl_tx_status txs;
371 struct r92c_c2h_tx_rpt *rpt;
372 struct ieee80211_node *ni;
376 if (sc->sc_ratectl != RTWN_RATECTL_NET80211) {
377 /* shouldn't happen */
378 device_printf(sc->sc_dev, "%s called while ratectl = %d!\n",
379 __func__, sc->sc_ratectl);
383 rpt = (struct r92c_c2h_tx_rpt *)buf;
384 if (len != sizeof(*rpt)) {
385 device_printf(sc->sc_dev,
386 "%s: wrong report size (%d, must be %zu)\n",
387 __func__, len, sizeof(*rpt));
391 RTWN_DPRINTF(sc, RTWN_DEBUG_INTR,
392 "%s: ccx report dump: 0: %02X, 1: %02X, queue time: "
393 "low %02X, high %02X, 4: %02X, 5: %02X, 6: %02X, 7: %02X\n",
394 __func__, rpt->rptb0, rpt->rptb1, rpt->queue_time_low,
395 rpt->queue_time_high, rpt->rptb4, rpt->rptb5, rpt->rptb6,
398 macid = MS(rpt->rptb5, R92C_RPTB5_MACID);
399 if (macid > sc->macid_limit) {
400 device_printf(sc->sc_dev,
401 "macid %u is too big; increase MACID_MAX limit\n",
406 ntries = MS(rpt->rptb0, R92C_RPTB0_RETRY_CNT);
409 ni = sc->node_list[macid];
411 RTWN_DPRINTF(sc, RTWN_DEBUG_INTR, "%s: frame for macid %u was"
412 "%s sent (%d retries)\n", __func__, macid,
413 (rpt->rptb7 & R92C_RPTB7_PKT_OK) ? "" : " not",
416 #if __FreeBSD_version >= 1200012
417 txs.flags = IEEE80211_RATECTL_STATUS_LONG_RETRY;
418 txs.long_retries = ntries;
419 if (rpt->rptb7 & R92C_RPTB7_PKT_OK)
420 txs.status = IEEE80211_RATECTL_TX_SUCCESS;
421 else if (rpt->rptb6 & R92C_RPTB6_RETRY_OVER)
422 txs.status = IEEE80211_RATECTL_TX_FAIL_LONG; /* XXX */
423 else if (rpt->rptb6 & R92C_RPTB6_LIFE_EXPIRE)
424 txs.status = IEEE80211_RATECTL_TX_FAIL_EXPIRED;
426 txs.status = IEEE80211_RATECTL_TX_FAIL_UNSPECIFIED;
427 ieee80211_ratectl_tx_complete(ni, &txs);
429 struct ieee80211vap *vap = ni->ni_vap;
430 if (rpt->rptb7 & R92C_RPTB7_PKT_OK) {
431 ieee80211_ratectl_tx_complete(vap, ni,
432 IEEE80211_RATECTL_TX_SUCCESS, &ntries, NULL);
434 ieee80211_ratectl_tx_complete(vap, ni,
435 IEEE80211_RATECTL_TX_FAILURE, &ntries, NULL);
439 RTWN_DPRINTF(sc, RTWN_DEBUG_INTR, "%s: macid %u, ni is NULL\n",
444 #ifdef IEEE80211_SUPPORT_SUPERG
445 if (sc->sc_tx_n_active > 0 && --sc->sc_tx_n_active <= 1)
446 rtwn_cmd_sleepable(sc, NULL, 0, rtwn_ff_flush_all);
451 r92c_handle_c2h_task(struct rtwn_softc *sc, union sec_param *data)
453 const uint16_t off = R92C_C2H_EVT_MSG + sizeof(struct r92c_c2h_evt);
454 struct r92c_softc *rs = sc->sc_priv;
455 uint16_t buf[R92C_C2H_MSG_MAX_LEN / 2 + 1];
456 uint8_t id, len, status;
459 /* Do not reschedule the task if device is not running. */
460 if (!(sc->sc_flags & RTWN_RUNNING))
463 /* Read current status. */
464 status = rtwn_read_1(sc, R92C_C2H_EVT_CLEAR);
465 if (status == R92C_C2H_EVT_HOST_CLOSE)
466 goto end; /* nothing to do */
467 else if (status == R92C_C2H_EVT_FW_CLOSE) {
468 len = rtwn_read_1(sc, R92C_C2H_EVT_MSG);
469 id = MS(len, R92C_C2H_EVTB0_ID);
470 len = MS(len, R92C_C2H_EVTB0_LEN);
472 memset(buf, 0, sizeof(buf));
473 /* Try to optimize event reads. */
474 for (i = 0; i < len; i += 2)
475 buf[i / 2] = rtwn_read_2(sc, off + i);
476 KASSERT(i < sizeof(buf), ("%s: buffer overrun (%d >= %zu)!",
477 __func__, i, sizeof(buf)));
480 case R92C_C2H_EVT_TX_REPORT:
481 r92c_ratectl_tx_complete(sc, (uint8_t *)buf, len);
484 device_printf(sc->sc_dev,
485 "%s: C2H report %u (len %u) was not handled\n",
491 /* Prepare for next event. */
492 rtwn_write_1(sc, R92C_C2H_EVT_CLEAR, R92C_C2H_EVT_HOST_CLOSE);
495 /* Adjust timeout for next call. */
496 if (rs->rs_c2h_pending != 0) {
497 rs->rs_c2h_pending = 0;
498 rs->rs_c2h_paused = 0;
502 if (rs->rs_c2h_paused > R92C_TX_PAUSED_THRESHOLD)
503 rs->rs_c2h_timeout = hz;
505 rs->rs_c2h_timeout = MAX(hz / 100, 1);
507 /* Reschedule the task. */
508 callout_reset(&rs->rs_c2h_report, rs->rs_c2h_timeout,
509 r92c_handle_c2h_report, sc);
513 r92c_handle_c2h_report(void *arg)
515 struct rtwn_softc *sc = arg;
517 rtwn_cmd_sleepable(sc, NULL, 0, r92c_handle_c2h_task);
520 #endif /* RTWN_WITHOUT_UCODE */