Cross Reference: /freebsd-11-stable/sys/dev/usb/wlan/if

Deleted Added

sdiff udiff text old ( 203138 ) new ( 205042 )

full compact

1/* $FreeBSD: head/sys/dev/usb/wlan/if_run.c 203138 2010-01-28 22:54:01Z thompsa $ */

1/* $FreeBSD: head/sys/dev/usb/wlan/if_run.c 205042 2010-03-11 22:05:12Z thompsa $ */

2
3/*-

4 * Copyright (c) 2008,2010 Damien Bergamini <damien.bergamini@free.fr>
5 * ported to FreeBSD by Akinori Furukoshi <moonlightakkiy@yahoo.ca>
6 * USB Consulting, Hans Petter Selasky <hselasky@freebsd.org>

7 *
8 * Permission to use, copy, modify, and distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above
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

20/* release date Jan. 09, 2010 */
21

21#include <sys/cdefs.h>

23__FBSDID("$FreeBSD: head/sys/dev/usb/wlan/if_run.c 203138 2010-01-28 22:54:01Z thompsa $");

22__FBSDID("$FreeBSD: head/sys/dev/usb/wlan/if_run.c 205042 2010-03-11 22:05:12Z thompsa $");

23
24/*-
25 * Ralink Technology RT2700U/RT2800U/RT3000U chipset driver.
26 * http://www.ralinktech.com/
27 */
28
29#include <sys/param.h>
30#include <sys/sockio.h>

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

101 { USB_VP(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RT3072) },
102 { USB_VP(USB_VENDOR_ABOCOM2, USB_PRODUCT_ABOCOM2_RT2870_1) },
103 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT2770) },
104 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT2870_1) },
105 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT2870_2) },
106 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT2870_3) },
107 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT2870_4) },
108 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT2870_5) },

109 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT3070) },

110 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT3070_1) },
111 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT3070_2) },
112 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT3070_3) },
113 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT3070_4) },

114 { USB_VP(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_RT3070_5) },

115 { USB_VP(USB_VENDOR_AIRTIES, USB_PRODUCT_AIRTIES_RT3070) },

116 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT2070) },
117 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT2770) },
118 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT2870) },
119 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT3070) },
120 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT3071) },
121 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT3072) },
122 { USB_VP(USB_VENDOR_ALLWIN, USB_PRODUCT_ALLWIN_RT3572) },

123 { USB_VP(USB_VENDOR_AMIGO, USB_PRODUCT_AMIGO_RT2870_1) },
124 { USB_VP(USB_VENDOR_AMIGO, USB_PRODUCT_AMIGO_RT2870_2) },
125 { USB_VP(USB_VENDOR_AMIT, USB_PRODUCT_AMIT_CGWLUSB2GNR) },
126 { USB_VP(USB_VENDOR_AMIT, USB_PRODUCT_AMIT_RT2870_1) },
127 { USB_VP(USB_VENDOR_AMIT2, USB_PRODUCT_AMIT2_RT2870) },
128 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2870_1) },
129 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2870_2) },
130 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2870_3) },
131 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2870_4) },
132 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2870_5) },

133 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_USBN13) },
134 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT3070_1) },

135 { USB_VP(USB_VENDOR_ASUS2, USB_PRODUCT_ASUS2_USBN11) },
136 { USB_VP(USB_VENDOR_AZUREWAVE, USB_PRODUCT_AZUREWAVE_RT2870_1) },
137 { USB_VP(USB_VENDOR_AZUREWAVE, USB_PRODUCT_AZUREWAVE_RT2870_2) },
138 { USB_VP(USB_VENDOR_AZUREWAVE, USB_PRODUCT_AZUREWAVE_RT3070_1) },
139 { USB_VP(USB_VENDOR_AZUREWAVE, USB_PRODUCT_AZUREWAVE_RT3070_2) },
140 { USB_VP(USB_VENDOR_AZUREWAVE, USB_PRODUCT_AZUREWAVE_RT3070_3) },
141 { USB_VP(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5D8053V3) },
142 { USB_VP(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5D8055) },
143 { USB_VP(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F6D4050V1) },
144 { USB_VP(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_RT2870_1) },
145 { USB_VP(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_RT2870_2) },

146 { USB_VP(USB_VENDOR_CISCOLINKSYS2, USB_PRODUCT_CISCOLINKSYS2_RT3070) },
147 { USB_VP(USB_VENDOR_CISCOLINKSYS3, USB_PRODUCT_CISCOLINKSYS2_RT3070) },

148 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_1) },
149 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_2) },
150 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_3) },
151 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_4) },
152 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_5) },
153 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_6) },
154 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_7) },
155 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT2870_8) },

156 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT3070_1) },
157 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_RT3070_2) },

158 { USB_VP(USB_VENDOR_CONCEPTRONIC2, USB_PRODUCT_CONCEPTRONIC2_VIGORN61) },
159 { USB_VP(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_CGWLUSB300GNM) },
160 { USB_VP(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_RT2870_1) },
161 { USB_VP(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_RT2870_2) },
162 { USB_VP(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_RT2870_3) },
163 { USB_VP(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_RT3070) },
164 { USB_VP(USB_VENDOR_CYBERTAN, USB_PRODUCT_CYBERTAN_RT2870) },
165 { USB_VP(USB_VENDOR_DLINK, USB_PRODUCT_DLINK_RT2870) },
166 { USB_VP(USB_VENDOR_DLINK, USB_PRODUCT_DLINK_RT3072) },
167 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA130) },
168 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT2870_1) },
169 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT2870_2) },
170 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3070_1) },
171 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3070_2) },
172 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3070_3) },
173 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3070_4) },

174 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3070_5) },

175 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3072) },

176 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT3072_1) },

177 { USB_VP(USB_VENDOR_EDIMAX, USB_PRODUCT_EDIMAX_EW7717) },
178 { USB_VP(USB_VENDOR_EDIMAX, USB_PRODUCT_EDIMAX_EW7718) },
179 { USB_VP(USB_VENDOR_EDIMAX, USB_PRODUCT_EDIMAX_RT2870_1) },
180 { USB_VP(USB_VENDOR_ENCORE, USB_PRODUCT_ENCORE_RT3070_1) },
181 { USB_VP(USB_VENDOR_ENCORE, USB_PRODUCT_ENCORE_RT3070_2) },
182 { USB_VP(USB_VENDOR_ENCORE, USB_PRODUCT_ENCORE_RT3070_3) },
183 { USB_VP(USB_VENDOR_GIGABYTE, USB_PRODUCT_GIGABYTE_GNWB31N) },
184 { USB_VP(USB_VENDOR_GIGABYTE, USB_PRODUCT_GIGABYTE_GNWB32L) },

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

189 { USB_VP(USB_VENDOR_HAWKING, USB_PRODUCT_HAWKING_HWUN2) },
190 { USB_VP(USB_VENDOR_HAWKING, USB_PRODUCT_HAWKING_RT2870_1) },
191 { USB_VP(USB_VENDOR_HAWKING, USB_PRODUCT_HAWKING_RT2870_2) },
192 { USB_VP(USB_VENDOR_HAWKING, USB_PRODUCT_HAWKING_RT3070) },
193 { USB_VP(USB_VENDOR_IODATA, USB_PRODUCT_IODATA_RT3072_1) },
194 { USB_VP(USB_VENDOR_IODATA, USB_PRODUCT_IODATA_RT3072_2) },
195 { USB_VP(USB_VENDOR_IODATA, USB_PRODUCT_IODATA_RT3072_3) },
196 { USB_VP(USB_VENDOR_IODATA, USB_PRODUCT_IODATA_RT3072_4) },

197 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_RT3070) },

198 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_WUSB100) },
199 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_WUSB54GCV3) },
200 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_WUSB600N) },
201 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_WUSB600NV2) },
202 { USB_VP(USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_RT2870_1) },
203 { USB_VP(USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_RT2870_2) },
204 { USB_VP(USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_RT2870_3) },

205 { USB_VP(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_RT2870_1) },
206 { USB_VP(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_RT2870_2) },

207 { USB_VP(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCAG300N) },
208 { USB_VP(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCG300N) },
209 { USB_VP(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCGN) },

210 { USB_VP(USB_VENDOR_MOTOROLA4, USB_PRODUCT_MOTOROLA4_RT2770) },
211 { USB_VP(USB_VENDOR_MOTOROLA4, USB_PRODUCT_MOTOROLA4_RT3070) },

212 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_1) },
213 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_2) },
214 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_3) },
215 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_4) },
216 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_5) },
217 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_6) },
218 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_7) },

219 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_8) },
220 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_9) },
221 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_10) },
222 { USB_VP(USB_VENDOR_MSI, USB_PRODUCT_MSI_RT3070_11) },
223 { USB_VP(USB_VENDOR_OVISLINK, USB_PRODUCT_OVISLINK_RT3072) },

224 { USB_VP(USB_VENDOR_PARA, USB_PRODUCT_PARA_RT3070) },
225 { USB_VP(USB_VENDOR_PEGATRON, USB_PRODUCT_PEGATRON_RT2870) },
226 { USB_VP(USB_VENDOR_PEGATRON, USB_PRODUCT_PEGATRON_RT3070) },
227 { USB_VP(USB_VENDOR_PEGATRON, USB_PRODUCT_PEGATRON_RT3070_2) },

228 { USB_VP(USB_VENDOR_PEGATRON, USB_PRODUCT_PEGATRON_RT3070_3) },

229 { USB_VP(USB_VENDOR_PHILIPS, USB_PRODUCT_PHILIPS_RT2870) },
230 { USB_VP(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GWUS300MINIS) },
231 { USB_VP(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GWUSMICRON) },
232 { USB_VP(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_RT2870) },
233 { USB_VP(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_RT3070) },
234 { USB_VP(USB_VENDOR_QCOM, USB_PRODUCT_QCOM_RT2870) },
235 { USB_VP(USB_VENDOR_QUANTA, USB_PRODUCT_QUANTA_RT3070) },
236 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT2070) },
237 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT2770) },
238 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT2870) },
239 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT3070) },
240 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT3071) },
241 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT3072) },

242 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT3370) },

243 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT3572) },

244 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT8070) },

245 { USB_VP(USB_VENDOR_SAMSUNG2, USB_PRODUCT_SAMSUNG2_RT2870_1) },
246 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT2870_1) },
247 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT2870_2) },
248 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT2870_3) },
249 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT2870_4) },
250 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT3070) },
251 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT3071) },
252 { USB_VP(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_RT3072_1) },

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

258 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT2870_1) },
259 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT2870_2) },
260 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT2870_3) },
261 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT2870_4) },
262 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3070) },
263 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3070_2) },
264 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3070_3) },
265 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3070_4) },

266 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3071) },

267 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3072_1) },
268 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3072_2) },
269 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3072_3) },
270 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3072_4) },
271 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3072_5) },
272 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_RT3072_6) },
273 { USB_VP(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_WL608) },
274 { USB_VP(USB_VENDOR_SPARKLAN, USB_PRODUCT_SPARKLAN_RT2870_1) },
275 { USB_VP(USB_VENDOR_SPARKLAN, USB_PRODUCT_SPARKLAN_RT3070) },

276 { USB_VP(USB_VENDOR_SWEEX2, USB_PRODUCT_SWEEX2_LW153) },

277 { USB_VP(USB_VENDOR_SWEEX2, USB_PRODUCT_SWEEX2_LW303) },
278 { USB_VP(USB_VENDOR_SWEEX2, USB_PRODUCT_SWEEX2_LW313) },

279 { USB_VP(USB_VENDOR_TOSHIBA, USB_PRODUCT_TOSHIBA_RT3070) },

280 { USB_VP(USB_VENDOR_UMEDIA, USB_PRODUCT_UMEDIA_RT2870_1) },
281 { USB_VP(USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_RT2870_1) },
282 { USB_VP(USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_RT2870_2) },
283 { USB_VP(USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT2870_1) },
284 { USB_VP(USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT2870_2) },
285 { USB_VP(USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT3070) },
286 { USB_VP(USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT3072_1) },
287 { USB_VP(USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT3072_2) },
288 { USB_VP(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_RT2870_1) },

289 { USB_VP(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_RT2870_2) },

290};
291
292MODULE_DEPEND(run, wlan, 1, 1, 1);
293MODULE_DEPEND(run, wlan_amrr, 1, 1, 1);
294MODULE_DEPEND(run, usb, 1, 1, 1);
295MODULE_DEPEND(run, firmware, 1, 1, 1);
296
297static device_probe_t run_match;

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

368 struct ieee80211_node *, int, int);
369static int run_tx_param(struct run_softc *, struct mbuf *,
370 struct ieee80211_node *,
371 const struct ieee80211_bpf_params *);
372static int run_raw_xmit(struct ieee80211_node *, struct mbuf *,
373 const struct ieee80211_bpf_params *);
374static void run_start(struct ifnet *);
375static int run_ioctl(struct ifnet *, u_long, caddr_t);

376static void run_set_agc(struct run_softc *, uint8_t);

377static void run_select_chan_group(struct run_softc *, int);
378static void run_set_rx_antenna(struct run_softc *, int);
379static void run_rt2870_set_chan(struct run_softc *, u_int);
380static void run_rt3070_set_chan(struct run_softc *, u_int);

381static void run_rt3572_set_chan(struct run_softc *, u_int);

382static int run_set_chan(struct run_softc *, struct ieee80211_channel *);
383static void run_set_channel(struct ieee80211com *);
384static void run_scan_start(struct ieee80211com *);
385static void run_scan_end(struct ieee80211com *);
386static uint8_t run_rate2mcs(uint8_t);
387static void run_update_beacon(struct ieee80211vap *, int);
388static void run_update_beacon_locked(struct ieee80211vap *, int);
389static void run_updateprot(struct ieee80211com *);

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

399static void run_updateslot(struct ifnet *);
400static int8_t run_rssi2dbm(struct run_softc *, uint8_t, uint8_t);
401static void run_update_promisc_locked(struct ifnet *);
402static void run_update_promisc(struct ifnet *);
403static int run_bbp_init(struct run_softc *);
404static int run_rt3070_rf_init(struct run_softc *);
405static int run_rt3070_filter_calib(struct run_softc *, uint8_t, uint8_t,
406 uint8_t *);

407static void run_rt3070_rf_setup(struct run_softc *);

408static int run_txrx_enable(struct run_softc *);
409static void run_init(void *);
410static void run_init_locked(struct run_softc *);
411static void run_stop(void *);
412static void run_delay(struct run_softc *, unsigned int);
413
414static const struct {
415 uint32_t reg;

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

429 uint8_t chan;
430 uint32_t r1, r2, r3, r4;
431} rt2860_rf2850[] = {
432 RT2860_RF2850
433};
434
435struct {
436 uint8_t n, r, k;

~~401~~} run_rf3020_freqs[] = {
~~402~~ RT3070_RF3020

437} rt3070_freqs[] = {
438 RT3070_RF3052

439};
440
441static const struct {
442 uint8_t reg;
443 uint8_t val;
444} rt3070_def_rf[] = {
445 RT3070_DEF_RF

446},rt3572_def_rf[] = {
447 RT3572_DEF_RF

448};
449
450static const struct usb_config run_config[RUN_N_XFER] = {
451 [RUN_BULK_TX_BE] = {
452 .type = UE_BULK,
453 .endpoint = UE_ADDR_ANY,
454 .ep_index = 0,
455 .direction = UE_DIR_OUT,

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

535
536static int
537run_attach(device_t self)
538{
539 struct run_softc *sc = device_get_softc(self);
540 struct usb_attach_arg *uaa = device_get_ivars(self);
541 struct ieee80211com *ic;
542 struct ifnet *ifp;

543 uint32_t ver;

544 int i, ntries, error;
545 uint8_t iface_index, bands;
546
547 device_set_usb_desc(self);
548 sc->sc_udev = uaa->device;
549 sc->sc_dev = self;
550
551 mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev),
552 MTX_NETWORK_LOCK, MTX_DEF);
553
554 iface_index = RT2860_IFACE_INDEX;

~~516~~ /* Rx transfer has own lock */

555 error = usbd_transfer_setup(uaa->device, &iface_index,
556 sc->sc_xfer, run_config, RUN_N_XFER, sc, &sc->sc_mtx);
557 if (error) {

~~520~~ device_printf(self, "could not allocate USB Tx transfers, "

558 device_printf(self, "could not allocate USB transfers, "

559 "err=%s\n", usbd_errstr(error));
560 goto detach;
561 }
562
563 RUN_LOCK(sc);
564
565 /* wait for the chip to settle */
566 for (ntries = 0; ntries < 100; ntries++) {

~~529~~ if (run_read(sc, RT2860_ASIC_VER_ID, &sc->mac_rev) != 0){

567 if (run_read(sc, RT2860_ASIC_VER_ID, &ver) != 0){

568 RUN_UNLOCK(sc);
569 goto detach;
570 }

~~533~~ if (sc->mac_rev != 0 && sc->mac_rev != 0xffffffff)

571 if (ver != 0 && ver != 0xffffffff)

572 break;
573 run_delay(sc, 10);
574 }
575 if (ntries == 100) {
576 device_printf(sc->sc_dev,
577 "timeout waiting for NIC to initialize\n");
578 RUN_UNLOCK(sc);
579 goto detach;
580 }

581 sc->mac_ver = ver >> 16;
582 sc->mac_rev = ver & 0xffff;

583
584 /* retrieve RF rev. no and various other things from EEPROM */
585 run_read_eeprom(sc);
586
587 device_printf(sc->sc_dev,
588 "MAC/BBP RT%04X (rev 0x%04X), RF %s (MIMO %dT%dR), address %s\n",

~~549~~ sc->mac_rev >> 16, sc->mac_rev & 0xffff, run_get_rf(sc->rf_rev),

589 sc->mac_ver, sc->mac_rev, run_get_rf(sc->rf_rev),

590 sc->ntxchains, sc->nrxchains, ether_sprintf(sc->sc_bssid));
591
592 if ((error = run_load_microcode(sc)) != 0) {
593 device_printf(sc->sc_dev, "could not load 8051 microcode\n");
594 RUN_UNLOCK(sc);
595 goto detach;
596 }
597

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

644 setbit(&bands, IEEE80211_MODE_11B);
645 setbit(&bands, IEEE80211_MODE_11G);
646 ieee80211_init_channels(ic, NULL, &bands);
647
648 /*
649 * Do this by own because h/w supports
650 * more channels than ieee80211_init_channels()
651 */

~~612~~ if (sc->rf_rev == RT2860_RF_2750 || sc->rf_rev == RT2860_RF_2850) {

652 if (sc->rf_rev == RT2860_RF_2750 ||
653 sc->rf_rev == RT2860_RF_2850 ||
654 sc->rf_rev == RT3070_RF_3052) {

655 /* set supported .11a rates */
656 for (i = 14; i < nitems(rt2860_rf2850); i++) {
657 uint8_t chan = rt2860_rf2850[i].chan;
658 ic->ic_channels[ic->ic_nchans].ic_freq =
659 ieee80211_ieee2mhz(chan, IEEE80211_CHAN_A);
660 ic->ic_channels[ic->ic_nchans].ic_ieee = chan;
661 ic->ic_channels[ic->ic_nchans].ic_flags = IEEE80211_CHAN_A;
662 ic->ic_channels[ic->ic_nchans].ic_extieee = 0;

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

780 if(vap == NULL)
781 return;
782
783 ic = vap->iv_ic;
784 ifp = ic->ic_ifp;
785
786 sc = ifp->if_softc;
787

~~746~~ if (ifp && ifp->if_flags & IFF_UP){
~~747~~ RUN_LOCK(sc);
~~748~~ run_stop(sc);
~~749~~ RUN_UNLOCK(sc);
~~750~~ }

788 RUN_LOCK(sc);
789 sc->sc_rvp->amrr_run = RUN_AMRR_OFF;
790 RUN_UNLOCK(sc);

791

792 /* drain them all */
793 usb_callout_drain(&sc->sc_rvp->amrr_ch);
794 ieee80211_draintask(ic, &sc->sc_rvp->amrr_task);
795 ieee80211_draintask(ic, &sc->wme_task);
796 ieee80211_draintask(ic, &sc->usb_timeout_task);
797

798 ieee80211_amrr_cleanup(&rvp->amrr);
799 ieee80211_vap_detach(vap);
800 free(rvp, M_80211_VAP);
801 sc->sc_rvp = NULL;
802}
803
804static void
805run_setup_tx_list(struct run_softc *sc, struct run_endpoint_queue *pq)

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

849 usb_device_request_t req;
850 const struct firmware *fw;
851 const u_char *base;
852 uint32_t tmp;
853 int ntries, error;
854 const uint64_t *temp;
855 uint64_t bytes;
856

857 RUN_UNLOCK(sc);

858 fw = firmware_get("runfw");

859 RUN_LOCK(sc);

860 if(fw == NULL){
861 device_printf(sc->sc_dev,
862 "failed loadfirmware of file %s\n", "runfw");
863 return ENOENT;
864 }
865
866 if (fw->datasize != 8192) {
867 device_printf(sc->sc_dev,

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

872
873 /*
874 * RT3071/RT3072 use a different firmware
875 * run-rt2870 (8KB) contains both,
876 * first half (4KB) is for rt2870,
877 * last half is for rt3071.
878 */
879 base = fw->data;

~~832~~ if ((sc->mac_rev >> 16) != 0x2860 &&
~~833~~ (sc->mac_rev >> 16) != 0x2872 &&
~~834~~ (sc->mac_rev >> 16) != 0x3070 &&
~~835~~ (sc->mac_rev >> 16) != 0x3572){

880 if ((sc->mac_ver) != 0x2860 &&
881 (sc->mac_ver) != 0x2872 &&
882 (sc->mac_ver) != 0x3070){

883 base += 4096;

~~837~~ device_printf(sc->sc_dev, "loading RT3071 firmware\n");
~~838~~ } else
~~839~~ device_printf(sc->sc_dev, "loading RT2870 firmware\n");

884 }

885
886 /* cheap sanity check */
887 temp = fw->data;
888 bytes = *temp;
889 if(bytes != be64toh(0xffffff0210280210)) {
890 device_printf(sc->sc_dev, "firmware checksum failed\n");
891 error = EINVAL;
892 goto fail;

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

906 if ((error = usbd_do_request(sc->sc_udev, &sc->sc_mtx, &req, NULL)) != 0) {
907 device_printf(sc->sc_dev, "firmware reset failed\n");
908 goto fail;
909 }
910
911 run_delay(sc, 10);
912
913 run_write(sc, RT2860_H2M_MAILBOX, 0);

~~869~~ if ((error = run_mcu_cmd(sc, RT2860_MCU_CMD_BOOT, 0)) != 0)

914 if ((error = run_mcu_cmd(sc, RT2860_MCU_CMD_RFRESET, 0)) != 0)

915 goto fail;
916
917 /* wait until microcontroller is ready */
918 for (ntries = 0; ntries < 1000; ntries++) {
919 if ((error = run_read(sc, RT2860_SYS_CTRL, &tmp)) != 0) {
920 goto fail;
921 }
922 if (tmp & RT2860_MCU_READY)
923 break;
924 run_delay(sc, 10);
925 }
926 if (ntries == 1000) {
927 device_printf(sc->sc_dev,
928 "timeout waiting for MCU to initialize\n");
929 error = ETIMEDOUT;
930 goto fail;
931 }

~~887~~ DPRINTF("microcode successfully loaded after %d tries\n", ntries);

932 device_printf(sc->sc_dev, "firmware %s loaded\n",
933 (base == fw->data) ? "RT2870" : "RT3071");

934
935fail:
936 firmware_put(fw, FIRMWARE_UNLOAD);
937 return (error);
938}
939
940int
941run_reset(struct run_softc *sc)

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

1324{
1325 int8_t delta_2ghz, delta_5ghz;
1326 uint32_t tmp;
1327 uint16_t val;
1328 int ridx, ant, i;
1329
1330 /* check whether the ROM is eFUSE ROM or EEPROM */
1331 sc->sc_srom_read = run_eeprom_read_2;

~~1286~~ if ((sc->mac_rev & 0xfff00000) >= 0x30700000) {

1332 if (sc->mac_ver >= 0x3070) {

1333 run_read(sc, RT3070_EFUSE_CTRL, &tmp);
1334 DPRINTF("EFUSE_CTRL=0x%08x\n", tmp);
1335 if (tmp & RT3070_SEL_EFUSE)
1336 sc->sc_srom_read = run_efuse_read_2;
1337 }
1338
1339 /* read ROM version */
1340 run_srom_read(sc, RT2860_EEPROM_VERSION, &val);

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

1346 sc->sc_bssid[1] = val >> 8;
1347 run_srom_read(sc, RT2860_EEPROM_MAC23, &val);
1348 sc->sc_bssid[2] = val & 0xff;
1349 sc->sc_bssid[3] = val >> 8;
1350 run_srom_read(sc, RT2860_EEPROM_MAC45, &val);
1351 sc->sc_bssid[4] = val & 0xff;
1352 sc->sc_bssid[5] = val >> 8;
1353

~~1308~~ /* read default BBP settings */
~~1309~~ for (i = 0; i < 8; i++) {

1354 /* read vender BBP settings */
1355 for (i = 0; i < 10; i++) {

1356 run_srom_read(sc, RT2860_EEPROM_BBP_BASE + i, &val);
1357 sc->bbp[i].val = val & 0xff;
1358 sc->bbp[i].reg = val >> 8;
1359 DPRINTF("BBP%d=0x%02x\n", sc->bbp[i].reg, sc->bbp[i].val);
1360 }

1361 if (sc->mac_ver >= 0x3071) {
1362 /* read vendor RF settings */
1363 for (i = 0; i < 10; i++) {
1364 run_srom_read(sc, RT3071_EEPROM_RF_BASE + i, &val);
1365 sc->rf[i].val = val & 0xff;
1366 sc->rf[i].reg = val >> 8;
1367 DPRINTF("RF%d=0x%02x\n", sc->rf[i].reg,
1368 sc->rf[i].val);
1369 }
1370 }

1371
1372 /* read RF frequency offset from EEPROM */
1373 run_srom_read(sc, RT2860_EEPROM_FREQ_LEDS, &val);
1374 sc->freq = ((val & 0xff) != 0xff) ? val & 0xff : 0;
1375 DPRINTF("EEPROM freq offset %d\n", sc->freq & 0xff);
1376

~~1321~~ if ((sc->leds = val >> 8) != 0xff) {

1377 if (val >> 8 != 0xff) {

1378 /* read LEDs operating mode */

1379 sc->leds = val >> 8;

1380 run_srom_read(sc, RT2860_EEPROM_LED1, &sc->led[0]);
1381 run_srom_read(sc, RT2860_EEPROM_LED2, &sc->led[1]);
1382 run_srom_read(sc, RT2860_EEPROM_LED3, &sc->led[2]);
1383 } else {
1384 /* broken EEPROM, use default settings */
1385 sc->leds = 0x01;
1386 sc->led[0] = 0x5555;
1387 sc->led[1] = 0x2221;
1388 sc->led[2] = 0x5627; /* differs from RT2860 */
1389 }
1390 DPRINTF("EEPROM LED mode=0x%02x, LEDs=0x%04x/0x%04x/0x%04x\n",
1391 sc->leds, sc->led[0], sc->led[1], sc->led[2]);
1392
1393 /* read RF information */
1394 run_srom_read(sc, RT2860_EEPROM_ANTENNA, &val);
1395 if (val == 0xffff) {
1396 DPRINTF("invalid EEPROM antenna info, using default\n");

~~1340~~ if ((sc->mac_rev >> 16) >= 0x3070) {

1397 if (sc->mac_ver == 0x3572) {
1398 /* default to RF3052 2T2R */
1399 sc->rf_rev = RT3070_RF_3052;
1400 sc->ntxchains = 2;
1401 sc->nrxchains = 2;
1402 } else if (sc->mac_ver >= 0x3070) {

1403 /* default to RF3020 1T1R */
1404 sc->rf_rev = RT3070_RF_3020;
1405 sc->ntxchains = 1;
1406 sc->nrxchains = 1;
1407 } else {
1408 /* default to RF2820 1T2R */
1409 sc->rf_rev = RT2860_RF_2820;
1410 sc->ntxchains = 1;
1411 sc->nrxchains = 2;
1412 }
1413 } else {
1414 sc->rf_rev = (val >> 8) & 0xf;
1415 sc->ntxchains = (val >> 4) & 0xf;
1416 sc->nrxchains = val & 0xf;
1417 }
1418 DPRINTF("EEPROM RF rev=0x%02x chains=%dT%dR\n",
1419 sc->rf_rev, sc->ntxchains, sc->nrxchains);
1420

~~1359~~ /* check if RF supports automatic Tx access gain control */

1421 run_srom_read(sc, RT2860_EEPROM_CONFIG, &val);
1422 DPRINTF("EEPROM CFG 0x%04x\n", val);

1423 /* check if driver should patch the DAC issue */
1424 if ((val >> 8) != 0xff)
1425 sc->patch_dac = (val >> 15) & 1;

1426 if ((val & 0xff) != 0xff) {
1427 sc->ext_5ghz_lna = (val >> 3) & 1;
1428 sc->ext_2ghz_lna = (val >> 2) & 1;

1429 /* check if RF supports automatic Tx access gain control */

1430 sc->calib_2ghz = sc->calib_5ghz = (val >> 1) & 1;

1431 /* check if we have a hardware radio switch */
1432 sc->rfswitch = val & 1;

1433 }
1434
1435 /* read power settings for 2GHz channels */
1436 for (i = 0; i < 14; i += 2) {
1437 run_srom_read(sc, RT2860_EEPROM_PWR2GHZ_BASE1 + i / 2, &val);
1438 sc->txpow1[i + 0] = (int8_t)(val & 0xff);
1439 sc->txpow1[i + 1] = (int8_t)(val >> 8);
1440

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

1447 if (sc->txpow1[i] < 0 || sc->txpow1[i] > 31)
1448 sc->txpow1[i] = 5;
1449 if (sc->txpow2[i] < 0 || sc->txpow2[i] > 31)
1450 sc->txpow2[i] = 5;
1451 DPRINTF("chan %d: power1=%d, power2=%d\n",
1452 rt2860_rf2850[i].chan, sc->txpow1[i], sc->txpow2[i]);
1453 }
1454 /* read power settings for 5GHz channels */

~~1388~~ for (i = 0; i < 36; i += 2) {

1455 for (i = 0; i < 40; i += 2) {

1456 run_srom_read(sc, RT2860_EEPROM_PWR5GHZ_BASE1 + i / 2, &val);
1457 sc->txpow1[i + 14] = (int8_t)(val & 0xff);
1458 sc->txpow1[i + 15] = (int8_t)(val >> 8);
1459
1460 run_srom_read(sc, RT2860_EEPROM_PWR5GHZ_BASE2 + i / 2, &val);
1461 sc->txpow2[i + 14] = (int8_t)(val & 0xff);
1462 sc->txpow2[i + 15] = (int8_t)(val >> 8);
1463 }
1464 /* fix broken Tx power entries */

~~1398~~ for (i = 0; i < 36; i++) {

1465 for (i = 0; i < 40; i++) {

1466 if (sc->txpow1[14 + i] < -7 || sc->txpow1[14 + i] > 15)
1467 sc->txpow1[14 + i] = 5;
1468 if (sc->txpow2[14 + i] < -7 || sc->txpow2[14 + i] > 15)
1469 sc->txpow2[14 + i] = 5;
1470 DPRINTF("chan %d: power1=%d, power2=%d\n",
1471 rt2860_rf2850[14 + i].chan, sc->txpow1[14 + i],
1472 sc->txpow2[14 + i]);
1473 }

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

1506 sc->txpow40mhz_2ghz[ridx], sc->txpow40mhz_5ghz[ridx]);
1507 }
1508
1509 /* read RSSI offsets and LNA gains from EEPROM */
1510 run_srom_read(sc, RT2860_EEPROM_RSSI1_2GHZ, &val);
1511 sc->rssi_2ghz[0] = val & 0xff; /* Ant A */
1512 sc->rssi_2ghz[1] = val >> 8; /* Ant B */
1513 run_srom_read(sc, RT2860_EEPROM_RSSI2_2GHZ, &val);

~~1447~~ sc->rssi_2ghz[2] = val & 0xff; /* Ant C */

1514 if (sc->mac_ver >= 0x3070) {
1515 /*
1516 * On RT3070 chips (limited to 2 Rx chains), this ROM
1517 * field contains the Tx mixer gain for the 2GHz band.
1518 */
1519 if ((val & 0xff) != 0xff)
1520 sc->txmixgain_2ghz = val & 0x7;
1521 DPRINTF("tx mixer gain=%u (2GHz)\n", sc->txmixgain_2ghz);
1522 } else
1523 sc->rssi_2ghz[2] = val & 0xff; /* Ant C */

1524 sc->lna[2] = val >> 8; /* channel group 2 */
1525
1526 run_srom_read(sc, RT2860_EEPROM_RSSI1_5GHZ, &val);
1527 sc->rssi_5ghz[0] = val & 0xff; /* Ant A */
1528 sc->rssi_5ghz[1] = val >> 8; /* Ant B */
1529 run_srom_read(sc, RT2860_EEPROM_RSSI2_5GHZ, &val);

~~1454~~ sc->rssi_5ghz[2] = val & 0xff; /* Ant C */

1530 if (sc->mac_ver == 0x3572) {
1531 /*
1532 * On RT3572 chips (limited to 2 Rx chains), this ROM
1533 * field contains the Tx mixer gain for the 5GHz band.
1534 */
1535 if ((val & 0xff) != 0xff)
1536 sc->txmixgain_5ghz = val & 0x7;
1537 DPRINTF("tx mixer gain=%u (5GHz)\n", sc->txmixgain_5ghz);
1538 } else
1539 sc->rssi_5ghz[2] = val & 0xff; /* Ant C */

1540 sc->lna[3] = val >> 8; /* channel group 3 */
1541
1542 run_srom_read(sc, RT2860_EEPROM_LNA, &val);
1543 sc->lna[0] = val & 0xff; /* channel group 0 */
1544 sc->lna[1] = val >> 8; /* channel group 1 */
1545
1546 /* fix broken 5GHz LNA entries */
1547 if (sc->lna[2] == 0 || sc->lna[2] == 0xff) {

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

2719 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
2720 (!hasqos || (qos & IEEE80211_QOS_ACKPOLICY) !=
2721 IEEE80211_QOS_ACKPOLICY_NOACK)) {
2722 xflags |= RT2860_TX_ACK;
2723 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
2724 dur = rt2860_rates[ridx].sp_ack_dur;
2725 else
2726 dur = rt2860_rates[ridx].lp_ack_dur;

~~2642~~ *(uint16_t *)wh->i_dur = htole16(dur + sc->sifs);

2727 *(uint16_t *)wh->i_dur = htole16(dur);

2728 }
2729
2730 /* reserve slots for mgmt packets, just in case */
2731 if (sc->sc_epq[qid].tx_nfree < 3) {
2732 DPRINTFN(10, "tx ring %d is full\n", qid);
2733 return (-1);
2734 }
2735

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

3086 error = EINVAL;
3087 break;
3088 }
3089
3090 return (error);
3091}
3092
3093static void

3094run_set_agc(struct run_softc *sc, uint8_t agc)
3095{
3096 uint8_t bbp;
3097
3098 if (sc->mac_ver == 0x3572) {
3099 run_bbp_read(sc, 27, &bbp);
3100 bbp &= ~(0x3 << 5);
3101 run_bbp_write(sc, 27, bbp | 0 << 5); /* select Rx0 */
3102 run_bbp_write(sc, 66, agc);
3103 run_bbp_write(sc, 27, bbp | 1 << 5); /* select Rx1 */
3104 run_bbp_write(sc, 66, agc);
3105 } else
3106 run_bbp_write(sc, 66, agc);
3107}
3108
3109static void

3110run_select_chan_group(struct run_softc *sc, int group)
3111{
3112 uint32_t tmp;

3113 uint8_t agc;

3114
3115 run_bbp_write(sc, 62, 0x37 - sc->lna[group]);
3116 run_bbp_write(sc, 63, 0x37 - sc->lna[group]);
3117 run_bbp_write(sc, 64, 0x37 - sc->lna[group]);
3118 run_bbp_write(sc, 86, 0x00);
3119
3120 if (group == 0) {
3121 if (sc->ext_2ghz_lna) {
3122 run_bbp_write(sc, 82, 0x62);
3123 run_bbp_write(sc, 75, 0x46);
3124 } else {
3125 run_bbp_write(sc, 82, 0x84);
3126 run_bbp_write(sc, 75, 0x50);
3127 }
3128 } else {

~~3027~~ if (sc->ext_5ghz_lna) {

3129 if (sc->mac_ver == 0x3572)
3130 run_bbp_write(sc, 82, 0x94);
3131 else

3132 run_bbp_write(sc, 82, 0xf2);

3133 if (sc->ext_5ghz_lna)

3134 run_bbp_write(sc, 75, 0x46);

~~3030~~ } else {
~~3031~~ run_bbp_write(sc, 82, 0xf2);

3135 else

3136 run_bbp_write(sc, 75, 0x50);

~~3033~~ }

3137 }
3138
3139 run_read(sc, RT2860_TX_BAND_CFG, &tmp);
3140 tmp &= ~(RT2860_5G_BAND_SEL_N | RT2860_5G_BAND_SEL_P);
3141 tmp |= (group == 0) ? RT2860_5G_BAND_SEL_N : RT2860_5G_BAND_SEL_P;
3142 run_write(sc, RT2860_TX_BAND_CFG, tmp);
3143
3144 /* enable appropriate Power Amplifiers and Low Noise Amplifiers */

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

3151 tmp |= RT2860_LNA_PE_G1_EN;
3152 } else { /* 5GHz */
3153 tmp |= RT2860_PA_PE_A0_EN | RT2860_LNA_PE_A0_EN;
3154 if (sc->ntxchains > 1)
3155 tmp |= RT2860_PA_PE_A1_EN;
3156 if (sc->nrxchains > 1)
3157 tmp |= RT2860_LNA_PE_A1_EN;
3158 }

~~3056~~ run_write(sc, RT2860_TX_PIN_CFG, tmp);

3159 if (sc->mac_ver == 0x3572) {
3160 run_rt3070_rf_write(sc, 8, 0x00);
3161 run_write(sc, RT2860_TX_PIN_CFG, tmp);
3162 run_rt3070_rf_write(sc, 8, 0x80);
3163 } else
3164 run_write(sc, RT2860_TX_PIN_CFG, tmp);

3165
3166 /* set initial AGC value */

~~3059~~ if (group == 0)
~~3060~~ run_bbp_write(sc, 66, 0x2e + sc->lna[0]);
~~3061~~ else
~~3062~~ run_bbp_write(sc, 66, 0x32 + (sc->lna[group] * 5) / 3);

3167 if (group == 0) { /* 2GHz band */
3168 if (sc->mac_ver >= 0x3070)
3169 agc = 0x1c + sc->lna[0] * 2;
3170 else
3171 agc = 0x2e + sc->lna[0];
3172 } else { /* 5GHz band */
3173 if (sc->mac_ver == 0x3572)
3174 agc = 0x22 + (sc->lna[group] * 5) / 3;
3175 else
3176 agc = 0x32 + (sc->lna[group] * 5) / 3;
3177 }
3178 run_set_agc(sc, agc);

3179}
3180
3181static void
3182run_rt2870_set_chan(struct run_softc *sc, uint32_t chan)
3183{
3184 const struct rfprog *rfprog = rt2860_rf2850;
3185 uint32_t r2, r3, r4;
3186 int8_t txpow1, txpow2;

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

3233 run_rt2870_rf_write(sc, RT2860_RF4, r4);
3234}
3235
3236static void
3237run_rt3070_set_chan(struct run_softc *sc, uint32_t chan)
3238{
3239 int8_t txpow1, txpow2;
3240 uint8_t rf;

3241 int i;

3242
3243 /* RT3070 is 2GHz only */
3244 KASSERT(chan >= 1 && chan <= 14, ("wrong channel selected\n"));
3245

3246 /* find the settings for this channel (we know it exists) */
3247 for (i = 0; rt2860_rf2850[i].chan != chan; i++);
3248

3249 /* use Tx power values from EEPROM */

~~3130~~ txpow1 = sc->txpow1[chan - 1];
~~3131~~ txpow2 = sc->txpow2[chan - 1];

3250 txpow1 = sc->txpow1[i];
3251 txpow2 = sc->txpow2[i];

3252

~~3133~~ run_rt3070_rf_write(sc, 2, run_rf3020_freqs[chan - 1].n);
~~3134~~ run_rt3070_rf_write(sc, 3, run_rf3020_freqs[chan - 1].k);

3253 run_rt3070_rf_write(sc, 2, rt3070_freqs[i].n);
3254 run_rt3070_rf_write(sc, 3, rt3070_freqs[i].k);

3255 run_rt3070_rf_read(sc, 6, &rf);

~~3136~~ rf = (rf & ~0x03) | run_rf3020_freqs[chan - 1].r;

3256 rf = (rf & ~0x03) | rt3070_freqs[i].r;

3257 run_rt3070_rf_write(sc, 6, rf);
3258
3259 /* set Tx0 power */
3260 run_rt3070_rf_read(sc, 12, &rf);
3261 rf = (rf & ~0x1f) | txpow1;
3262 run_rt3070_rf_write(sc, 12, rf);
3263
3264 /* set Tx1 power */

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

3279 run_rt3070_rf_write(sc, 1, rf);
3280
3281 /* set RF offset */
3282 run_rt3070_rf_read(sc, 23, &rf);
3283 rf = (rf & ~0x7f) | sc->freq;
3284 run_rt3070_rf_write(sc, 23, rf);
3285
3286 /* program RF filter */

~~3167~~ run_rt3070_rf_write(sc, 24, sc->rf24_20mhz);
~~3168~~ run_rt3070_rf_write(sc, 31, sc->rf24_20mhz);

3287 run_rt3070_rf_read(sc, 24, &rf); /* Tx */
3288 rf = (rf & ~0x3f) | sc->rf24_20mhz;
3289 run_rt3070_rf_write(sc, 24, rf);
3290 run_rt3070_rf_read(sc, 31, &rf); /* Rx */
3291 rf = (rf & ~0x3f) | sc->rf24_20mhz;
3292 run_rt3070_rf_write(sc, 31, rf);

3293
3294 /* enable RF tuning */
3295 run_rt3070_rf_read(sc, 7, &rf);
3296 run_rt3070_rf_write(sc, 7, rf | 0x01);
3297}
3298
3299static void

3300run_rt3572_set_chan(struct run_softc *sc, u_int chan)
3301{
3302 int8_t txpow1, txpow2;
3303 uint32_t tmp;
3304 uint8_t rf;
3305 int i;
3306
3307 /* find the settings for this channel (we know it exists) */
3308 for (i = 0; rt2860_rf2850[i].chan != chan; i++);
3309
3310 /* use Tx power values from EEPROM */
3311 txpow1 = sc->txpow1[i];
3312 txpow2 = sc->txpow2[i];
3313
3314 if (chan <= 14) {
3315 run_bbp_write(sc, 25, sc->bbp25);
3316 run_bbp_write(sc, 26, sc->bbp26);
3317 } else {
3318 /* enable IQ phase correction */
3319 run_bbp_write(sc, 25, 0x09);
3320 run_bbp_write(sc, 26, 0xff);
3321 }
3322
3323 run_rt3070_rf_write(sc, 2, rt3070_freqs[i].n);
3324 run_rt3070_rf_write(sc, 3, rt3070_freqs[i].k);
3325 run_rt3070_rf_read(sc, 6, &rf);
3326 rf = (rf & ~0x0f) | rt3070_freqs[i].r;
3327 rf |= (chan <= 14) ? 0x08 : 0x04;
3328 run_rt3070_rf_write(sc, 6, rf);
3329
3330 /* set PLL mode */
3331 run_rt3070_rf_read(sc, 5, &rf);
3332 rf &= ~(0x08 | 0x04);
3333 rf |= (chan <= 14) ? 0x04 : 0x08;
3334 run_rt3070_rf_write(sc, 5, rf);
3335
3336 /* set Tx power for chain 0 */
3337 if (chan <= 14)
3338 rf = 0x60 | txpow1;
3339 else
3340 rf = 0xe0 | (txpow1 & 0xc) << 1 | (txpow1 & 0x3);
3341 run_rt3070_rf_write(sc, 12, rf);
3342
3343 /* set Tx power for chain 1 */
3344 if (chan <= 14)
3345 rf = 0x60 | txpow2;
3346 else
3347 rf = 0xe0 | (txpow2 & 0xc) << 1 | (txpow2 & 0x3);
3348 run_rt3070_rf_write(sc, 13, rf);
3349
3350 /* set Tx/Rx streams */
3351 run_rt3070_rf_read(sc, 1, &rf);
3352 rf &= ~0xfc;
3353 if (sc->ntxchains == 1)
3354 rf |= 1 << 7 | 1 << 5; /* 1T: disable Tx chains 2 & 3 */
3355 else if (sc->ntxchains == 2)
3356 rf |= 1 << 7; /* 2T: disable Tx chain 3 */
3357 if (sc->nrxchains == 1)
3358 rf |= 1 << 6 | 1 << 4; /* 1R: disable Rx chains 2 & 3 */
3359 else if (sc->nrxchains == 2)
3360 rf |= 1 << 6; /* 2R: disable Rx chain 3 */
3361 run_rt3070_rf_write(sc, 1, rf);
3362
3363 /* set RF offset */
3364 run_rt3070_rf_read(sc, 23, &rf);
3365 rf = (rf & ~0x7f) | sc->freq;
3366 run_rt3070_rf_write(sc, 23, rf);
3367
3368 /* program RF filter */
3369 rf = sc->rf24_20mhz;
3370 run_rt3070_rf_write(sc, 24, rf); /* Tx */
3371 run_rt3070_rf_write(sc, 31, rf); /* Rx */
3372
3373 /* enable RF tuning */
3374 run_rt3070_rf_read(sc, 7, &rf);
3375 rf = (chan <= 14) ? 0xd8 : ((rf & ~0xc8) | 0x14);
3376 run_rt3070_rf_write(sc, 7, rf);
3377
3378 /* TSSI */
3379 rf = (chan <= 14) ? 0xc3 : 0xc0;
3380 run_rt3070_rf_write(sc, 9, rf);
3381
3382 /* set loop filter 1 */
3383 run_rt3070_rf_write(sc, 10, 0xf1);
3384 /* set loop filter 2 */
3385 run_rt3070_rf_write(sc, 11, (chan <= 14) ? 0xb9 : 0x00);
3386
3387 /* set tx_mx2_ic */
3388 run_rt3070_rf_write(sc, 15, (chan <= 14) ? 0x53 : 0x43);
3389 /* set tx_mx1_ic */
3390 if (chan <= 14)
3391 rf = 0x48 | sc->txmixgain_2ghz;
3392 else
3393 rf = 0x78 | sc->txmixgain_5ghz;
3394 run_rt3070_rf_write(sc, 16, rf);
3395
3396 /* set tx_lo1 */
3397 run_rt3070_rf_write(sc, 17, 0x23);
3398 /* set tx_lo2 */
3399 if (chan <= 14)
3400 rf = 0x93;
3401 else if (chan <= 64)
3402 rf = 0xb7;
3403 else if (chan <= 128)
3404 rf = 0x74;
3405 else
3406 rf = 0x72;
3407 run_rt3070_rf_write(sc, 19, rf);
3408
3409 /* set rx_lo1 */
3410 if (chan <= 14)
3411 rf = 0xb3;
3412 else if (chan <= 64)
3413 rf = 0xf6;
3414 else if (chan <= 128)
3415 rf = 0xf4;
3416 else
3417 rf = 0xf3;
3418 run_rt3070_rf_write(sc, 20, rf);
3419
3420 /* set pfd_delay */
3421 if (chan <= 14)
3422 rf = 0x15;
3423 else if (chan <= 64)
3424 rf = 0x3d;
3425 else
3426 rf = 0x01;
3427 run_rt3070_rf_write(sc, 25, rf);
3428
3429 /* set rx_lo2 */
3430 run_rt3070_rf_write(sc, 26, (chan <= 14) ? 0x85 : 0x87);
3431 /* set ldo_rf_vc */
3432 run_rt3070_rf_write(sc, 27, (chan <= 14) ? 0x00 : 0x01);
3433 /* set drv_cc */
3434 run_rt3070_rf_write(sc, 29, (chan <= 14) ? 0x9b : 0x9f);
3435
3436 run_read(sc, RT2860_GPIO_CTRL, &tmp);
3437 tmp &= ~0x8080;
3438 if (chan <= 14)
3439 tmp |= 0x80;
3440 run_write(sc, RT2860_GPIO_CTRL, tmp);
3441
3442 /* enable RF tuning */
3443 run_rt3070_rf_read(sc, 7, &rf);
3444 run_rt3070_rf_write(sc, 7, rf | 0x01);
3445
3446 run_delay(sc, 2);
3447}
3448
3449static void

3450run_set_rx_antenna(struct run_softc *sc, int aux)
3451{
3452 uint32_t tmp;
3453
3454 if (aux) {

~~3181~~ run_read(sc, RT2860_PCI_EECTRL, &tmp);
~~3182~~ run_write(sc, RT2860_PCI_EECTRL, tmp & ~RT2860_C);

3455 run_mcu_cmd(sc, RT2860_MCU_CMD_ANTSEL, 0);

3456 run_read(sc, RT2860_GPIO_CTRL, &tmp);
3457 run_write(sc, RT2860_GPIO_CTRL, (tmp & ~0x0808) | 0x08);
3458 } else {

~~3186~~ run_read(sc, RT2860_PCI_EECTRL, &tmp);
~~3187~~ run_write(sc, RT2860_PCI_EECTRL, tmp | RT2860_C);

3459 run_mcu_cmd(sc, RT2860_MCU_CMD_ANTSEL, 1);

3460 run_read(sc, RT2860_GPIO_CTRL, &tmp);
3461 run_write(sc, RT2860_GPIO_CTRL, tmp & ~0x0808);
3462 }
3463}
3464
3465static int
3466run_set_chan(struct run_softc *sc, struct ieee80211_channel *c)
3467{
3468 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
3469 uint32_t chan, group;
3470
3471 chan = ieee80211_chan2ieee(ic, c);
3472 if (chan == 0 || chan == IEEE80211_CHAN_ANY)
3473 return EINVAL;
3474

~~3203~~ if ((sc->mac_rev >> 16) >= 0x3070)

3475 if (sc->mac_ver == 0x3572)
3476 run_rt3572_set_chan(sc, chan);
3477 else if (sc->mac_ver >= 0x3070)

3478 run_rt3070_set_chan(sc, chan);
3479 else
3480 run_rt2870_set_chan(sc, chan);
3481

~~3208~~ /* 802.11a uses a 16 microseconds short interframe space */
~~3209~~ sc->sifs = IEEE80211_IS_CHAN_5GHZ(c) ? 16 : 10;
~~3210~~

3482 /* determine channel group */
3483 if (chan <= 14)
3484 group = 0;
3485 else if (chan <= 64)
3486 group = 1;
3487 else if (chan <= 128)
3488 group = 2;
3489 else

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

3639}
3640
3641static void
3642run_usb_timeout_cb(void *arg, int pending)
3643{
3644 struct run_softc *sc = arg;
3645 struct ieee80211vap *vap = &sc->sc_rvp->vap;
3646

~~3376~~ RUN_LOCK_ASSERT(sc, MA_OWNED);

3647 RUN_LOCK(sc);

3648
3649 if(vap->iv_state == IEEE80211_S_RUN &&
3650 vap->iv_opmode != IEEE80211_M_STA)
3651 run_reset_livelock(sc);
3652 else if(vap->iv_state == IEEE80211_S_SCAN){
3653 DPRINTF("timeout caused by scan\n");
3654 /* cancel bgscan */
3655 ieee80211_cancel_scan(vap);
3656 } else
3657 DPRINTF("timeout by unknown cause\n");

3658
3659 RUN_UNLOCK(sc);

3660}
3661
3662static void
3663run_reset_livelock(struct run_softc *sc)
3664{
3665 uint32_t tmp;
3666
3667 /*

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

3879
3880 /* initialize BBP registers to default values */
3881 for (i = 0; i < nitems(rt2860_def_bbp); i++) {
3882 run_bbp_write(sc, rt2860_def_bbp[i].reg,
3883 rt2860_def_bbp[i].val);
3884 }
3885
3886 /* fix BBP84 for RT2860E */

~~3614~~ if ((sc->mac_rev >> 16) == 0x2860 && (sc->mac_rev & 0xffff) != 0x0101)
~~3615~~ run_bbp_write(sc, 84, 0x19);

3887 if (sc->mac_ver == 0x2860 && sc->mac_rev != 0x0101)
3888 run_bbp_write(sc, 84, 0x19);

3889

~~3617~~ if ((sc->mac_rev >> 16) >= 0x3070) {

3890 if (sc->mac_ver >= 0x3070) {

3891 run_bbp_write(sc, 79, 0x13);
3892 run_bbp_write(sc, 80, 0x05);
3893 run_bbp_write(sc, 81, 0x33);

~~3621~~ /* XXX RT3090 needs more */
~~3622~~ } else if (sc->mac_rev == 0x28600100) {

3894 } else if (sc->mac_ver == 0x2860 && sc->mac_rev == 0x0100) {

3895 run_bbp_write(sc, 69, 0x16);
3896 run_bbp_write(sc, 73, 0x12);
3897 }
3898 return 0;
3899}
3900
3901static int
3902run_rt3070_rf_init(struct run_softc *sc)
3903{
3904 uint32_t tmp;

~~3633~~ uint8_t rf, bbp4;

3905 uint8_t rf, target, bbp4;

3906 int i;
3907
3908 run_rt3070_rf_read(sc, 30, &rf);
3909 /* toggle RF R30 bit 7 */
3910 run_rt3070_rf_write(sc, 30, rf | 0x80);
3911 run_delay(sc, 10);
3912 run_rt3070_rf_write(sc, 30, rf & ~0x80);
3913
3914 /* initialize RF registers to default value */

~~3643~~ for (i = 0; i < nitems(rt3070_def_rf); i++) {
~~3644~~ run_rt3070_rf_write(sc, rt3070_def_rf[i].reg,
~~3645~~ rt3070_def_rf[i].val);

3915 if (sc->mac_ver == 0x3572) {
3916 for (i = 0; i < nitems(rt3572_def_rf); i++) {
3917 run_rt3070_rf_write(sc, rt3572_def_rf[i].reg,
3918 rt3572_def_rf[i].val);
3919 }
3920 } else {
3921 for (i = 0; i < nitems(rt3070_def_rf); i++) {
3922 run_rt3070_rf_write(sc, rt3070_def_rf[i].reg,
3923 rt3070_def_rf[i].val);
3924 }

3925 }

~~3647~~ if ((sc->mac_rev >> 16) == 0x3070) {

3926
3927 if (sc->mac_ver == 0x3070) {

3928 /* change voltage from 1.2V to 1.35V for RT3070 */
3929 run_read(sc, RT3070_LDO_CFG0, &tmp);
3930 tmp = (tmp & ~0x0f000000) | 0x0d000000;
3931 run_write(sc, RT3070_LDO_CFG0, tmp);
3932

~~3653~~ } else if ((sc->mac_rev >> 16) == 0x3071) {

3933 } else if (sc->mac_ver == 0x3071) {

3934 run_rt3070_rf_read(sc, 6, &rf);
3935 run_rt3070_rf_write(sc, 6, rf | 0x40);
3936 run_rt3070_rf_write(sc, 31, 0x14);
3937
3938 run_read(sc, RT3070_LDO_CFG0, &tmp);
3939 tmp &= ~0x1f000000;

~~3660~~ if ((sc->mac_rev & 0xffff) < 0x0211)
~~3661~~ tmp |= 0x0d000000;

3940 if (sc->mac_rev < 0x0211)
3941 tmp |= 0x0d000000; /* 1.3V */

3942 else

~~3663~~ tmp |= 0x01000000;

3943 tmp |= 0x01000000; /* 1.2V */

3944 run_write(sc, RT3070_LDO_CFG0, tmp);
3945
3946 /* patch LNA_PE_G1 */
3947 run_read(sc, RT3070_GPIO_SWITCH, &tmp);
3948 run_write(sc, RT3070_GPIO_SWITCH, tmp & ~0x20);

~~3669~~ } else if((sc->mac_rev >> 16) == 0x3572){
~~3670~~ if ((sc->mac_rev & 0xffff) < 0x0211){

3949 } else if(sc->mac_ver == 0x3572){
3950 run_rt3070_rf_read(sc, 6, &rf);
3951 run_rt3070_rf_write(sc, 6, rf | 0x40);
3952
3953 if (sc->mac_rev < 0x0211){
3954 /* increase voltage from 1.2V to 1.35V */

3955 run_read(sc, RT3070_LDO_CFG0, &tmp);
3956 tmp = (tmp & ~0x0f000000) | 0x0d000000;
3957 run_write(sc, RT3070_LDO_CFG0, tmp);
3958 } else {

3959 /* increase voltage from 1.2V to 1.35V */

3960 run_read(sc, RT3070_LDO_CFG0, &tmp);
3961 tmp = (tmp & ~0x1f000000) | 0x0d000000;
3962 run_write(sc, RT3070_LDO_CFG0, tmp);
3963
3964 run_delay(sc, 1); /* wait for 1msec */
3965

3966 /* decrease voltage back to 1.2V */

3967 tmp = (tmp & ~0x1f000000) | 0x01000000;
3968 run_write(sc, RT3070_LDO_CFG0, tmp);
3969 }
3970 }
3971
3972 /* select 20MHz bandwidth */
3973 run_rt3070_rf_read(sc, 31, &rf);
3974 run_rt3070_rf_write(sc, 31, rf & ~0x20);
3975
3976 /* calibrate filter for 20MHz bandwidth */
3977 sc->rf24_20mhz = 0x1f; /* default value */

~~3692~~ run_rt3070_filter_calib(sc, 0x07, 0x16, &sc->rf24_20mhz);

3978 target = (sc->mac_ver < 0x3071) ? 0x16 : 0x13;
3979 run_rt3070_filter_calib(sc, 0x07, target, &sc->rf24_20mhz);

3980
3981 /* select 40MHz bandwidth */
3982 run_bbp_read(sc, 4, &bbp4);
3983 run_bbp_write(sc, 4, (bbp4 & ~0x08) | 0x10);

3984 run_rt3070_rf_read(sc, 31, &rf);
3985 run_rt3070_rf_write(sc, 31, rf | 0x20);

3986
3987 /* calibrate filter for 40MHz bandwidth */
3988 sc->rf24_40mhz = 0x2f; /* default value */

~~3700~~ run_rt3070_filter_calib(sc, 0x27, 0x19, &sc->rf24_40mhz);

3989 target = (sc->mac_ver < 0x3071) ? 0x19 : 0x15;
3990 run_rt3070_filter_calib(sc, 0x27, target, &sc->rf24_40mhz);

3991
3992 /* go back to 20MHz bandwidth */
3993 run_bbp_read(sc, 4, &bbp4);
3994 run_bbp_write(sc, 4, bbp4 & ~0x18);
3995

~~3706~~ if ((sc->mac_rev & 0xffff) < 0x0211)

3996 if (sc->mac_ver == 0x3572) {
3997 /* save default BBP registers 25 and 26 values */
3998 run_bbp_read(sc, 25, &sc->bbp25);
3999 run_bbp_read(sc, 26, &sc->bbp26);
4000 } else if (sc->mac_rev < 0x0211)

4001 run_rt3070_rf_write(sc, 27, 0x03);
4002
4003 run_read(sc, RT3070_OPT_14, &tmp);
4004 run_write(sc, RT3070_OPT_14, tmp | 1);
4005

~~3712~~ if ((sc->mac_rev >> 16) == 0x3071) {

4006 if (sc->mac_ver == 0x3070 || sc->mac_ver == 0x3071) {
4007 run_rt3070_rf_read(sc, 17, &rf);
4008 rf &= ~RT3070_TX_LO1;
4009 if ((sc->mac_ver == 0x3070 ||
4010 (sc->mac_ver == 0x3071 && sc->mac_rev >= 0x0211)) &&
4011 !sc->ext_2ghz_lna)
4012 rf |= 0x20; /* fix for long range Rx issue */
4013 if (sc->txmixgain_2ghz >= 1)
4014 rf = (rf & ~0x7) | sc->txmixgain_2ghz;
4015 run_rt3070_rf_write(sc, 17, rf);
4016 }
4017
4018 if (sc->mac_rev == 0x3071) {

4019 run_rt3070_rf_read(sc, 1, &rf);
4020 rf &= ~(RT3070_RX0_PD | RT3070_TX0_PD);
4021 rf |= RT3070_RF_BLOCK | RT3070_RX1_PD | RT3070_TX1_PD;
4022 run_rt3070_rf_write(sc, 1, rf);
4023
4024 run_rt3070_rf_read(sc, 15, &rf);
4025 run_rt3070_rf_write(sc, 15, rf & ~RT3070_TX_LO2);
4026

~~3721~~ run_rt3070_rf_read(sc, 17, &rf);
~~3722~~ rf &= ~RT3070_TX_LO1;
~~3723~~ if ((sc->mac_rev & 0xffff) >= 0x0211 && !sc->ext_2ghz_lna)
~~3724~~ rf |= 0x20; /* fix for long range Rx issue */
~~3725~~ run_rt3070_rf_write(sc, 17, rf);
~~3726~~

4027 run_rt3070_rf_read(sc, 20, &rf);
4028 run_rt3070_rf_write(sc, 20, rf & ~RT3070_RX_LO1);
4029
4030 run_rt3070_rf_read(sc, 21, &rf);
4031 run_rt3070_rf_write(sc, 21, rf & ~RT3070_RX_LO2);

4032 }

4033

4034 if (sc->mac_ver == 0x3070 || sc->mac_ver == 0x3071) {
4035 /* fix Tx to Rx IQ glitch by raising RF voltage */

4036 run_rt3070_rf_read(sc, 27, &rf);
4037 rf &= ~0x77;

~~3735~~ if ((sc->mac_rev & 0xffff) < 0x0211)

4038 if (sc->mac_rev < 0x0211)

4039 rf |= 0x03;
4040 run_rt3070_rf_write(sc, 27, rf);
4041 }
4042 return 0;
4043}
4044
4045static int
4046run_rt3070_filter_calib(struct run_softc *sc, uint8_t init, uint8_t target,
4047 uint8_t *val)
4048{
4049 uint8_t rf22, rf24;
4050 uint8_t bbp55_pb, bbp55_sb, delta;
4051 int ntries;
4052
4053 /* program filter */

~~3751~~ rf24 = init; /* initial filter value */

4054 run_rt3070_rf_read(sc, 24, &rf24);
4055 rf24 = (rf24 & 0xc0) | init; /* initial filter value */

4056 run_rt3070_rf_write(sc, 24, rf24);
4057
4058 /* enable baseband loopback mode */
4059 run_rt3070_rf_read(sc, 22, &rf22);
4060 run_rt3070_rf_write(sc, 22, rf22 | 0x01);
4061
4062 /* set power and frequency of passband test tone */
4063 run_bbp_write(sc, 24, 0x00);

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

4102
4103 /* disable baseband loopback mode */
4104 run_rt3070_rf_read(sc, 22, &rf22);
4105 run_rt3070_rf_write(sc, 22, rf22 & ~0x01);
4106
4107 return 0;
4108}
4109

4110static void
4111run_rt3070_rf_setup(struct run_softc *sc)
4112{
4113 uint8_t bbp, rf;
4114 int i;
4115
4116 if (sc->mac_ver == 0x3572) {
4117 /* enable DC filter */
4118 if (sc->mac_rev >= 0x0201)
4119 run_bbp_write(sc, 103, 0xc0);
4120
4121 run_bbp_read(sc, 138, &bbp);
4122 if (sc->ntxchains == 1)
4123 bbp |= 0x20; /* turn off DAC1 */
4124 if (sc->nrxchains == 1)
4125 bbp &= ~0x02; /* turn off ADC1 */
4126 run_bbp_write(sc, 138, bbp);
4127
4128 if (sc->mac_rev >= 0x0211) {
4129 /* improve power consumption */
4130 run_bbp_read(sc, 31, &bbp);
4131 run_bbp_write(sc, 31, bbp & ~0x03);
4132 }
4133
4134 run_rt3070_rf_read(sc, 16, &rf);
4135 rf = (rf & ~0x07) | sc->txmixgain_2ghz;
4136 run_rt3070_rf_write(sc, 16, rf);
4137
4138 } else if (sc->mac_ver == 0x3071) {
4139 /* enable DC filter */
4140 if (sc->mac_rev >= 0x0201)
4141 run_bbp_write(sc, 103, 0xc0);
4142
4143 run_bbp_read(sc, 138, &bbp);
4144 if (sc->ntxchains == 1)
4145 bbp |= 0x20; /* turn off DAC1 */
4146 if (sc->nrxchains == 1)
4147 bbp &= ~0x02; /* turn off ADC1 */
4148 run_bbp_write(sc, 138, bbp);
4149
4150 if (sc->mac_rev >= 0x0211) {
4151 /* improve power consumption */
4152 run_bbp_read(sc, 31, &bbp);
4153 run_bbp_write(sc, 31, bbp & ~0x03);
4154 }
4155
4156 run_write(sc, RT2860_TX_SW_CFG1, 0);
4157 if (sc->mac_rev < 0x0211) {
4158 run_write(sc, RT2860_TX_SW_CFG2,
4159 sc->patch_dac ? 0x2c : 0x0f);
4160 } else
4161 run_write(sc, RT2860_TX_SW_CFG2, 0);
4162
4163 } else if (sc->mac_ver == 0x3070) {
4164 if (sc->mac_rev >= 0x0201) {
4165 /* enable DC filter */
4166 run_bbp_write(sc, 103, 0xc0);
4167
4168 /* improve power consumption */
4169 run_bbp_read(sc, 31, &bbp);
4170 run_bbp_write(sc, 31, bbp & ~0x03);
4171 }
4172
4173 if (sc->mac_rev < 0x0211) {
4174 run_write(sc, RT2860_TX_SW_CFG1, 0);
4175 run_write(sc, RT2860_TX_SW_CFG2, 0x2c);
4176 } else
4177 run_write(sc, RT2860_TX_SW_CFG2, 0);
4178 }
4179
4180 /* initialize RF registers from ROM for >=RT3071*/
4181 if (sc->mac_ver >= 0x3071) {
4182 for (i = 0; i < 10; i++) {
4183 if (sc->rf[i].reg == 0 || sc->rf[i].reg == 0xff)
4184 continue;
4185 run_rt3070_rf_write(sc, sc->rf[i].reg, sc->rf[i].val);
4186 }
4187 }
4188}
4189

4190static int
4191run_txrx_enable(struct run_softc *sc)
4192{
4193 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
4194 uint32_t tmp;
4195 int error, ntries;
4196
4197 run_write(sc, RT2860_MAC_SYS_CTRL, RT2860_MAC_TX_EN);

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

4233 return 0;
4234}
4235
4236static void
4237run_init_locked(struct run_softc *sc)
4238{
4239 struct ifnet *ifp = sc->sc_ifp;
4240 struct ieee80211com *ic = ifp->if_l2com;

~~3857~~ struct ieee80211vap *vap = &sc->sc_rvp->vap;

4241 uint32_t tmp;
4242 uint8_t bbp1, bbp3;
4243 int i;
4244 int ridx;
4245 int ntries;
4246
4247 run_stop(sc);
4248

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

4299 }
4300
4301 for (i = 0; i < nitems(rt2870_def_mac); i++)
4302 run_write(sc, rt2870_def_mac[i].reg, rt2870_def_mac[i].val);
4303 run_write(sc, RT2860_WMM_AIFSN_CFG, 0x00002273);
4304 run_write(sc, RT2860_WMM_CWMIN_CFG, 0x00002344);
4305 run_write(sc, RT2860_WMM_CWMAX_CFG, 0x000034aa);
4306

~~3924~~ if ((sc->mac_rev >> 16) >= 0x3070) {

4307 if (sc->mac_ver >= 0x3070) {

4308 /* set delay of PA_PE assertion to 1us (unit of 0.25us) */
4309 run_write(sc, RT2860_TX_SW_CFG0,
4310 4 << RT2860_DLY_PAPE_EN_SHIFT);

~~3928~~ run_write(sc, RT2860_TX_SW_CFG1, 0);
~~3929~~ run_write(sc, RT2860_TX_SW_CFG2, 0x1f);

4311 }
4312
4313 /* wait while MAC is busy */
4314 for (ntries = 0; ntries < 100; ntries++) {
4315 if (run_read(sc, RT2860_MAC_STATUS_REG, &tmp) != 0)
4316 goto fail;
4317 if (!(tmp & (RT2860_RX_STATUS_BUSY | RT2860_TX_STATUS_BUSY)))
4318 break;

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

4345 run_set_region_4(sc, RT2860_SKEY(0, 0), 0, 8 * 32);
4346 /* clear shared key mode */
4347 run_set_region_4(sc, RT2860_SKEY_MODE_0_7, 0, 4);
4348
4349 run_read(sc, RT2860_US_CYC_CNT, &tmp);
4350 tmp = (tmp & ~0xff) | 0x1e;
4351 run_write(sc, RT2860_US_CYC_CNT, tmp);
4352

~~3972~~ if ((sc->mac_rev >> 16) == 0x2860 && (sc->mac_rev & 0xffff) != 0x0101)

4353 if (sc->mac_rev != 0x0101)

4354 run_write(sc, RT2860_TXOP_CTRL_CFG, 0x0000583f);
4355
4356 run_write(sc, RT2860_WMM_TXOP0_CFG, 0);
4357 run_write(sc, RT2860_WMM_TXOP1_CFG, 48 << 16 | 96);
4358
4359 /* write vendor-specific BBP values (from EEPROM) */
4360 for (i = 0; i < 8; i++) {
4361 if (sc->bbp[i].reg == 0 || sc->bbp[i].reg == 0xff)

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

4367 if (sc->rf_rev == RT3070_RF_3020)
4368 run_set_rx_antenna(sc, 0);
4369
4370 /* send LEDs operating mode to microcontroller */
4371 (void)run_mcu_cmd(sc, RT2860_MCU_CMD_LED1, sc->led[0]);
4372 (void)run_mcu_cmd(sc, RT2860_MCU_CMD_LED2, sc->led[1]);
4373 (void)run_mcu_cmd(sc, RT2860_MCU_CMD_LED3, sc->led[2]);
4374

4375 if (sc->mac_ver >= 0x3070)
4376 run_rt3070_rf_init(sc);
4377

4378 /* disable non-existing Rx chains */
4379 run_bbp_read(sc, 3, &bbp3);
4380 bbp3 &= ~(1 << 3 | 1 << 4);
4381 if (sc->nrxchains == 2)
4382 bbp3 |= 1 << 3;
4383 else if (sc->nrxchains == 3)
4384 bbp3 |= 1 << 4;
4385 run_bbp_write(sc, 3, bbp3);
4386
4387 /* disable non-existing Tx chains */
4388 run_bbp_read(sc, 1, &bbp1);
4389 if (sc->ntxchains == 1)
4390 bbp1 &= ~(1 << 3 | 1 << 4);
4391 run_bbp_write(sc, 1, bbp1);
4392

~~4009~~ if ((sc->mac_rev >> 16) >= 0x3070)
~~4010~~ run_rt3070_rf_init(sc);

4393 if (sc->mac_ver >= 0x3070)
4394 run_rt3070_rf_setup(sc);

4395
4396 /* select default channel */

~~4013~~ vap->iv_bss->ni_chan = ic->ic_curchan; /* ic_bsschan?? */

4397 run_set_chan(sc, ic->ic_curchan);
4398
4399 /* setup initial protection mode */
4400 run_updateprot(ic);
4401
4402 /* turn radio LED on */
4403 run_set_leds(sc, RT2860_LED_RADIO);
4404

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

4441 struct ifnet *ifp = sc->sc_ifp;
4442 struct ieee80211com *ic = ifp->if_l2com;
4443 uint32_t tmp;
4444 int i;
4445 int ntries;
4446
4447 RUN_LOCK_ASSERT(sc, MA_OWNED);
4448

~~4066~~ if (ic->ic_flags & IEEE80211_F_SCAN)
~~4067~~ ieee80211_cancel_scan(&sc->sc_rvp->vap);

4449 if(sc->sc_rvp != NULL){
4450 sc->sc_rvp->amrr_run = RUN_AMRR_OFF;
4451 if (ic->ic_flags & IEEE80211_F_SCAN)
4452 ieee80211_cancel_scan(&sc->sc_rvp->vap);
4453 }

4454
4455 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
4456 run_set_leds(sc, 0); /* turn all LEDs off */
4457
4458 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
4459

~~4074~~ sc->sc_rvp->amrr_run = RUN_AMRR_OFF;
~~4075~~

4460 RUN_UNLOCK(sc);
4461

~~4078~~ /* drain them all */
~~4079~~ usb_callout_drain(&sc->sc_rvp->amrr_ch);
~~4080~~ ieee80211_draintask(ic, &sc->sc_rvp->amrr_task);
~~4081~~ ieee80211_draintask(ic, &sc->wme_task);

4462 for(i = 0; i < RUN_N_XFER; i++)
4463 usbd_transfer_drain(sc->sc_xfer[i]);

~~4084~~ ieee80211_draintask(ic, &sc->usb_timeout_task);

4464
4465 RUN_LOCK(sc);
4466
4467 if(sc->rx_m != NULL){
4468 m_free(sc->rx_m);
4469 sc->rx_m = NULL;
4470 }
4471

--- 56 unchanged lines hidden ---