1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
5 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
6 * Linux device driver for RTL8192SU
8 * Modifications for inclusion into the Linux staging tree are
9 * Copyright(c) 2010 Larry Finger. All rights reserved.
11 * Contact information:
12 * WLAN FAE <wlanfae@realtek.com>
13 * Larry Finger <Larry.Finger@lwfinger.net>
15 ******************************************************************************/
17 #include <linux/rndis.h>
18 #include "osdep_service.h"
19 #include "drv_types.h"
20 #include "mlme_osdep.h"
21 #include "rtl871x_mp.h"
22 #include "rtl871x_mp_ioctl.h"
24 uint oid_null_function(struct oid_par_priv *poid_par_priv)
26 return RNDIS_STATUS_SUCCESS;
29 uint oid_rt_wireless_mode_hdl(struct oid_par_priv *poid_par_priv)
31 uint status = RNDIS_STATUS_SUCCESS;
32 struct _adapter *Adapter = (struct _adapter *)
33 (poid_par_priv->adapter_context);
35 if (poid_par_priv->type_of_oid == SET_OID) {
36 if (poid_par_priv->information_buf_len >= sizeof(u8))
37 Adapter->registrypriv.wireless_mode =
38 *(u8 *)poid_par_priv->information_buf;
40 status = RNDIS_STATUS_INVALID_LENGTH;
41 } else if (poid_par_priv->type_of_oid == QUERY_OID) {
42 if (poid_par_priv->information_buf_len >= sizeof(u8)) {
43 *(u8 *)poid_par_priv->information_buf =
44 Adapter->registrypriv.wireless_mode;
45 *poid_par_priv->bytes_rw =
46 poid_par_priv->information_buf_len;
48 status = RNDIS_STATUS_INVALID_LENGTH;
51 status = RNDIS_STATUS_NOT_ACCEPTED;
56 uint oid_rt_pro_write_bb_reg_hdl(struct oid_par_priv *poid_par_priv)
58 struct _adapter *Adapter = (struct _adapter *)
59 (poid_par_priv->adapter_context);
60 struct bb_reg_param *pbbreg;
64 if (poid_par_priv->type_of_oid != SET_OID)
65 return RNDIS_STATUS_NOT_ACCEPTED;
66 if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param))
67 return RNDIS_STATUS_INVALID_LENGTH;
68 pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf);
69 offset = (u16)(pbbreg->offset) & 0xFFF; /*0ffset :0x800~0xfff*/
70 if (offset < BB_REG_BASE_ADDR)
71 offset |= BB_REG_BASE_ADDR;
72 value = pbbreg->value;
73 r8712_bb_reg_write(Adapter, offset, value);
74 return RNDIS_STATUS_SUCCESS;
77 uint oid_rt_pro_read_bb_reg_hdl(struct oid_par_priv *poid_par_priv)
79 struct _adapter *Adapter = (struct _adapter *)
80 (poid_par_priv->adapter_context);
81 struct bb_reg_param *pbbreg;
85 if (poid_par_priv->type_of_oid != QUERY_OID)
86 return RNDIS_STATUS_NOT_ACCEPTED;
87 if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param))
88 return RNDIS_STATUS_INVALID_LENGTH;
89 pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf);
90 offset = (u16)(pbbreg->offset) & 0xFFF; /*0ffset :0x800~0xfff*/
91 if (offset < BB_REG_BASE_ADDR)
92 offset |= BB_REG_BASE_ADDR;
93 value = r8712_bb_reg_read(Adapter, offset);
94 pbbreg->value = value;
95 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
96 return RNDIS_STATUS_SUCCESS;
99 uint oid_rt_pro_write_rf_reg_hdl(struct oid_par_priv *poid_par_priv)
101 struct _adapter *Adapter = (struct _adapter *)
102 (poid_par_priv->adapter_context);
103 struct rf_reg_param *pbbreg;
108 if (poid_par_priv->type_of_oid != SET_OID)
109 return RNDIS_STATUS_NOT_ACCEPTED;
110 if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param))
111 return RNDIS_STATUS_INVALID_LENGTH;
112 pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf);
113 path = (u8)pbbreg->path;
114 if (path > RF_PATH_B)
115 return RNDIS_STATUS_NOT_ACCEPTED;
116 offset = (u8)pbbreg->offset;
117 value = pbbreg->value;
118 r8712_rf_reg_write(Adapter, path, offset, value);
119 return RNDIS_STATUS_SUCCESS;
122 uint oid_rt_pro_read_rf_reg_hdl(struct oid_par_priv *poid_par_priv)
124 struct _adapter *Adapter = (struct _adapter *)
125 (poid_par_priv->adapter_context);
126 struct rf_reg_param *pbbreg;
131 if (poid_par_priv->type_of_oid != QUERY_OID)
132 return RNDIS_STATUS_NOT_ACCEPTED;
133 if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param))
134 return RNDIS_STATUS_INVALID_LENGTH;
135 pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf);
136 path = (u8)pbbreg->path;
137 if (path > RF_PATH_B) /* 1T2R path_a /path_b */
138 return RNDIS_STATUS_NOT_ACCEPTED;
139 offset = (u8)pbbreg->offset;
140 value = r8712_rf_reg_read(Adapter, path, offset);
141 pbbreg->value = value;
142 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
143 return RNDIS_STATUS_SUCCESS;
146 /*This function initializes the DUT to the MP test mode*/
147 static int mp_start_test(struct _adapter *padapter)
149 struct mp_priv *pmppriv = &padapter->mppriv;
150 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
151 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
152 struct wlan_bssid_ex *bssid;
153 struct sta_info *psta;
154 unsigned long length;
158 bssid = kzalloc(sizeof(*bssid), GFP_KERNEL);
162 /* 3 1. initialize a new struct wlan_bssid_ex */
163 memcpy(bssid->MacAddress, pmppriv->network_macaddr, ETH_ALEN);
164 bssid->Ssid.SsidLength = 16;
165 memcpy(bssid->Ssid.Ssid, (unsigned char *)"mp_pseudo_adhoc",
166 bssid->Ssid.SsidLength);
167 bssid->InfrastructureMode = Ndis802_11IBSS;
168 bssid->NetworkTypeInUse = Ndis802_11DS;
170 length = r8712_get_wlan_bssid_ex_sz(bssid);
172 /*round up to multiple of 4 bytes.*/
173 bssid->Length = ((length >> 2) + 1) << 2;
175 bssid->Length = length;
177 spin_lock_irqsave(&pmlmepriv->lock, irqL);
178 if (check_fwstate(pmlmepriv, WIFI_MP_STATE))
179 goto end_of_mp_start_test;
180 /*init mp_start_test status*/
181 pmppriv->prev_fw_state = get_fwstate(pmlmepriv);
182 pmlmepriv->fw_state = WIFI_MP_STATE;
183 if (pmppriv->mode == _LOOPBOOK_MODE_)
184 set_fwstate(pmlmepriv, WIFI_MP_LPBK_STATE); /*append txdesc*/
185 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
186 /* 3 2. create a new psta for mp driver */
187 /* clear psta in the cur_network, if any */
188 psta = r8712_get_stainfo(&padapter->stapriv,
189 tgt_network->network.MacAddress);
191 r8712_free_stainfo(padapter, psta);
192 psta = r8712_alloc_stainfo(&padapter->stapriv, bssid->MacAddress);
195 goto end_of_mp_start_test;
197 /* 3 3. join pseudo AdHoc */
198 tgt_network->join_res = 1;
199 tgt_network->aid = psta->aid = 1;
200 memcpy(&tgt_network->network, bssid, length);
201 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
202 r8712_os_indicate_connect(padapter);
203 /* Set to LINKED STATE for MP TRX Testing */
204 set_fwstate(pmlmepriv, _FW_LINKED);
205 end_of_mp_start_test:
206 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
211 /*This function change the DUT from the MP test mode into normal mode */
212 static int mp_stop_test(struct _adapter *padapter)
214 struct mp_priv *pmppriv = &padapter->mppriv;
215 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
216 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
217 struct sta_info *psta;
220 spin_lock_irqsave(&pmlmepriv->lock, irqL);
221 if (!check_fwstate(pmlmepriv, WIFI_MP_STATE))
222 goto end_of_mp_stop_test;
223 /* 3 1. disconnect pseudo AdHoc */
224 r8712_os_indicate_disconnect(padapter);
225 /* 3 2. clear psta used in mp test mode. */
226 psta = r8712_get_stainfo(&padapter->stapriv,
227 tgt_network->network.MacAddress);
229 r8712_free_stainfo(padapter, psta);
230 /* 3 3. return to normal state (default:station mode) */
231 pmlmepriv->fw_state = pmppriv->prev_fw_state; /* WIFI_STATION_STATE;*/
232 /*flush the cur_network*/
233 memset(tgt_network, 0, sizeof(struct wlan_network));
235 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
239 uint oid_rt_pro_set_data_rate_hdl(struct oid_par_priv *poid_par_priv)
241 struct _adapter *Adapter = (struct _adapter *)
242 (poid_par_priv->adapter_context);
245 if (poid_par_priv->type_of_oid != SET_OID)
246 return RNDIS_STATUS_NOT_ACCEPTED;
247 if (poid_par_priv->information_buf_len != sizeof(u32))
248 return RNDIS_STATUS_INVALID_LENGTH;
249 ratevalue = *((u32 *)poid_par_priv->information_buf);
250 if (ratevalue >= MPT_RATE_LAST)
251 return RNDIS_STATUS_INVALID_DATA;
252 Adapter->mppriv.curr_rateidx = ratevalue;
253 r8712_SetDataRate(Adapter);
254 return RNDIS_STATUS_SUCCESS;
257 uint oid_rt_pro_start_test_hdl(struct oid_par_priv *poid_par_priv)
259 struct _adapter *Adapter = (struct _adapter *)
260 (poid_par_priv->adapter_context);
261 uint status = RNDIS_STATUS_SUCCESS;
265 if (poid_par_priv->type_of_oid != SET_OID)
266 return RNDIS_STATUS_NOT_ACCEPTED;
267 mode = *((u32 *)poid_par_priv->information_buf);
268 Adapter->mppriv.mode = mode;/* 1 for loopback*/
269 if (mp_start_test(Adapter))
270 status = RNDIS_STATUS_NOT_ACCEPTED;
271 r8712_write8(Adapter, MSR, 1); /* Link in ad hoc network, 0x1025004C */
272 r8712_write8(Adapter, RCR, 0); /* RCR : disable all pkt, 0x10250048 */
273 /* RCR disable Check BSSID, 0x1025004a */
274 r8712_write8(Adapter, RCR + 2, 0x57);
275 /* disable RX filter map , mgt frames will put in RX FIFO 0 */
276 r8712_write16(Adapter, RXFLTMAP0, 0x0);
277 val8 = r8712_read8(Adapter, EE_9346CR);
278 if (!(val8 & _9356SEL)) { /*boot from EFUSE*/
279 r8712_efuse_reg_init(Adapter);
280 r8712_efuse_change_max_size(Adapter);
281 r8712_efuse_reg_uninit(Adapter);
286 uint oid_rt_pro_stop_test_hdl(struct oid_par_priv *poid_par_priv)
288 struct _adapter *Adapter = (struct _adapter *)
289 (poid_par_priv->adapter_context);
291 if (poid_par_priv->type_of_oid != SET_OID)
292 return RNDIS_STATUS_NOT_ACCEPTED;
293 if (mp_stop_test(Adapter) == _FAIL)
294 return RNDIS_STATUS_NOT_ACCEPTED;
295 return RNDIS_STATUS_SUCCESS;
298 uint oid_rt_pro_set_channel_direct_call_hdl(struct oid_par_priv *poid_par_priv)
300 struct _adapter *Adapter = (struct _adapter *)
301 (poid_par_priv->adapter_context);
304 if (poid_par_priv->type_of_oid != SET_OID)
305 return RNDIS_STATUS_NOT_ACCEPTED;
306 if (poid_par_priv->information_buf_len != sizeof(u32))
307 return RNDIS_STATUS_INVALID_LENGTH;
308 Channel = *((u32 *)poid_par_priv->information_buf);
310 return RNDIS_STATUS_NOT_ACCEPTED;
311 Adapter->mppriv.curr_ch = Channel;
312 r8712_SetChannel(Adapter);
313 return RNDIS_STATUS_SUCCESS;
316 uint oid_rt_pro_set_antenna_bb_hdl(struct oid_par_priv *poid_par_priv)
318 struct _adapter *Adapter = (struct _adapter *)
319 (poid_par_priv->adapter_context);
322 if (poid_par_priv->type_of_oid != SET_OID)
323 return RNDIS_STATUS_NOT_ACCEPTED;
324 if (poid_par_priv->information_buf_len != sizeof(u32))
325 return RNDIS_STATUS_INVALID_LENGTH;
326 antenna = *((u32 *)poid_par_priv->information_buf);
327 Adapter->mppriv.antenna_tx = (u16)((antenna & 0xFFFF0000) >> 16);
328 Adapter->mppriv.antenna_rx = (u16)(antenna & 0x0000FFFF);
329 r8712_SwitchAntenna(Adapter);
330 return RNDIS_STATUS_SUCCESS;
333 uint oid_rt_pro_set_tx_power_control_hdl(struct oid_par_priv *poid_par_priv)
335 struct _adapter *Adapter = (struct _adapter *)
336 (poid_par_priv->adapter_context);
339 if (poid_par_priv->type_of_oid != SET_OID)
340 return RNDIS_STATUS_NOT_ACCEPTED;
341 if (poid_par_priv->information_buf_len != sizeof(u32))
342 return RNDIS_STATUS_INVALID_LENGTH;
343 tx_pwr_idx = *((u32 *)poid_par_priv->information_buf);
344 if (tx_pwr_idx > MAX_TX_PWR_INDEX_N_MODE)
345 return RNDIS_STATUS_NOT_ACCEPTED;
346 Adapter->mppriv.curr_txpoweridx = (u8)tx_pwr_idx;
347 r8712_SetTxPower(Adapter);
348 return RNDIS_STATUS_SUCCESS;
351 uint oid_rt_pro_query_tx_packet_sent_hdl(struct oid_par_priv *poid_par_priv)
353 struct _adapter *Adapter = (struct _adapter *)
354 (poid_par_priv->adapter_context);
356 if (poid_par_priv->type_of_oid != QUERY_OID)
357 return RNDIS_STATUS_NOT_ACCEPTED;
359 if (poid_par_priv->information_buf_len == sizeof(u32)) {
360 *(u32 *)poid_par_priv->information_buf =
361 Adapter->mppriv.tx_pktcount;
362 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
364 return RNDIS_STATUS_INVALID_LENGTH;
366 return RNDIS_STATUS_SUCCESS;
369 uint oid_rt_pro_query_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
371 struct _adapter *Adapter = (struct _adapter *)
372 (poid_par_priv->adapter_context);
374 if (poid_par_priv->type_of_oid != QUERY_OID)
375 return RNDIS_STATUS_NOT_ACCEPTED;
377 if (poid_par_priv->information_buf_len == sizeof(u32)) {
378 *(u32 *)poid_par_priv->information_buf =
379 Adapter->mppriv.rx_pktcount;
380 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
382 return RNDIS_STATUS_INVALID_LENGTH;
384 return RNDIS_STATUS_SUCCESS;
387 uint oid_rt_pro_query_rx_packet_crc32_error_hdl(struct oid_par_priv *poid_par_priv)
389 struct _adapter *Adapter = (struct _adapter *)
390 (poid_par_priv->adapter_context);
392 if (poid_par_priv->type_of_oid != QUERY_OID)
393 return RNDIS_STATUS_NOT_ACCEPTED;
395 if (poid_par_priv->information_buf_len == sizeof(u32)) {
396 *(u32 *)poid_par_priv->information_buf =
397 Adapter->mppriv.rx_crcerrpktcount;
398 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
400 return RNDIS_STATUS_INVALID_LENGTH;
402 return RNDIS_STATUS_SUCCESS;
405 uint oid_rt_pro_reset_tx_packet_sent_hdl(struct oid_par_priv *poid_par_priv)
407 struct _adapter *Adapter = (struct _adapter *)
408 (poid_par_priv->adapter_context);
410 if (poid_par_priv->type_of_oid != SET_OID)
411 return RNDIS_STATUS_NOT_ACCEPTED;
412 Adapter->mppriv.tx_pktcount = 0;
413 return RNDIS_STATUS_SUCCESS;
416 uint oid_rt_pro_reset_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
418 struct _adapter *Adapter = (struct _adapter *)
419 (poid_par_priv->adapter_context);
421 if (poid_par_priv->type_of_oid != SET_OID)
422 return RNDIS_STATUS_NOT_ACCEPTED;
423 if (poid_par_priv->information_buf_len == sizeof(u32)) {
424 Adapter->mppriv.rx_pktcount = 0;
425 Adapter->mppriv.rx_crcerrpktcount = 0;
427 return RNDIS_STATUS_INVALID_LENGTH;
429 return RNDIS_STATUS_SUCCESS;
432 uint oid_rt_reset_phy_rx_packet_count_hdl(struct oid_par_priv *poid_par_priv)
434 struct _adapter *Adapter = (struct _adapter *)
435 (poid_par_priv->adapter_context);
437 if (poid_par_priv->type_of_oid != SET_OID)
438 return RNDIS_STATUS_NOT_ACCEPTED;
439 r8712_ResetPhyRxPktCount(Adapter);
440 return RNDIS_STATUS_SUCCESS;
443 uint oid_rt_get_phy_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
445 struct _adapter *Adapter = (struct _adapter *)
446 (poid_par_priv->adapter_context);
448 if (poid_par_priv->type_of_oid != QUERY_OID)
449 return RNDIS_STATUS_NOT_ACCEPTED;
450 if (poid_par_priv->information_buf_len != sizeof(u32))
451 return RNDIS_STATUS_INVALID_LENGTH;
452 *(u32 *)poid_par_priv->information_buf =
453 r8712_GetPhyRxPktReceived(Adapter);
454 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
455 return RNDIS_STATUS_SUCCESS;
458 uint oid_rt_get_phy_rx_packet_crc32_error_hdl(struct oid_par_priv *poid_par_priv)
460 struct _adapter *Adapter = (struct _adapter *)
461 (poid_par_priv->adapter_context);
463 if (poid_par_priv->type_of_oid != QUERY_OID)
464 return RNDIS_STATUS_NOT_ACCEPTED;
465 if (poid_par_priv->information_buf_len != sizeof(u32))
466 return RNDIS_STATUS_INVALID_LENGTH;
467 *(u32 *)poid_par_priv->information_buf =
468 r8712_GetPhyRxPktCRC32Error(Adapter);
469 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
470 return RNDIS_STATUS_SUCCESS;
473 uint oid_rt_pro_set_modulation_hdl(struct oid_par_priv *poid_par_priv)
475 struct _adapter *Adapter = (struct _adapter *)
476 (poid_par_priv->adapter_context);
478 if (poid_par_priv->type_of_oid != SET_OID)
479 return RNDIS_STATUS_NOT_ACCEPTED;
481 Adapter->mppriv.curr_modem = *((u8 *)poid_par_priv->information_buf);
482 return RNDIS_STATUS_SUCCESS;
485 uint oid_rt_pro_set_continuous_tx_hdl(struct oid_par_priv *poid_par_priv)
487 struct _adapter *Adapter = (struct _adapter *)
488 (poid_par_priv->adapter_context);
491 if (poid_par_priv->type_of_oid != SET_OID)
492 return RNDIS_STATUS_NOT_ACCEPTED;
493 bStartTest = *((u32 *)poid_par_priv->information_buf);
494 r8712_SetContinuousTx(Adapter, (u8)bStartTest);
495 return RNDIS_STATUS_SUCCESS;
498 uint oid_rt_pro_set_single_carrier_tx_hdl(struct oid_par_priv *poid_par_priv)
500 struct _adapter *Adapter = (struct _adapter *)
501 (poid_par_priv->adapter_context);
504 if (poid_par_priv->type_of_oid != SET_OID)
505 return RNDIS_STATUS_NOT_ACCEPTED;
506 bStartTest = *((u32 *)poid_par_priv->information_buf);
507 r8712_SetSingleCarrierTx(Adapter, (u8)bStartTest);
508 return RNDIS_STATUS_SUCCESS;
511 uint oid_rt_pro_set_carrier_suppression_tx_hdl(struct oid_par_priv *poid_par_priv)
513 struct _adapter *Adapter = (struct _adapter *)
514 (poid_par_priv->adapter_context);
517 if (poid_par_priv->type_of_oid != SET_OID)
518 return RNDIS_STATUS_NOT_ACCEPTED;
519 bStartTest = *((u32 *)poid_par_priv->information_buf);
520 r8712_SetCarrierSuppressionTx(Adapter, (u8)bStartTest);
521 return RNDIS_STATUS_SUCCESS;
524 uint oid_rt_pro_set_single_tone_tx_hdl(struct oid_par_priv *poid_par_priv)
526 struct _adapter *Adapter = (struct _adapter *)
527 (poid_par_priv->adapter_context);
530 if (poid_par_priv->type_of_oid != SET_OID)
531 return RNDIS_STATUS_NOT_ACCEPTED;
532 bStartTest = *((u32 *)poid_par_priv->information_buf);
533 r8712_SetSingleToneTx(Adapter, (u8)bStartTest);
534 return RNDIS_STATUS_SUCCESS;
537 uint oid_rt_pro_read_register_hdl(struct oid_par_priv *poid_par_priv)
539 struct _adapter *Adapter = (struct _adapter *)
540 (poid_par_priv->adapter_context);
541 uint status = RNDIS_STATUS_SUCCESS;
542 struct mp_rw_reg *RegRWStruct;
545 if (poid_par_priv->type_of_oid != QUERY_OID)
546 return RNDIS_STATUS_NOT_ACCEPTED;
547 RegRWStruct = (struct mp_rw_reg *)poid_par_priv->information_buf;
548 if ((RegRWStruct->offset >= 0x10250800) &&
549 (RegRWStruct->offset <= 0x10250FFF)) {
550 /*baseband register*/
551 /*0ffset :0x800~0xfff*/
552 offset = (u16)(RegRWStruct->offset) & 0xFFF;
553 RegRWStruct->value = r8712_bb_reg_read(Adapter, offset);
555 switch (RegRWStruct->width) {
557 RegRWStruct->value = r8712_read8(Adapter,
558 RegRWStruct->offset);
561 RegRWStruct->value = r8712_read16(Adapter,
562 RegRWStruct->offset);
565 RegRWStruct->value = r8712_read32(Adapter,
566 RegRWStruct->offset);
569 status = RNDIS_STATUS_NOT_ACCEPTED;
573 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
577 uint oid_rt_pro_write_register_hdl(struct oid_par_priv *poid_par_priv)
579 struct _adapter *Adapter = (struct _adapter *)
580 (poid_par_priv->adapter_context);
581 uint status = RNDIS_STATUS_SUCCESS;
582 struct mp_rw_reg *RegRWStruct;
587 if (poid_par_priv->type_of_oid != SET_OID)
588 return RNDIS_STATUS_NOT_ACCEPTED;
589 RegRWStruct = (struct mp_rw_reg *)poid_par_priv->information_buf;
590 if ((RegRWStruct->offset >= 0x10250800) &&
591 (RegRWStruct->offset <= 0x10250FFF)) {
592 /*baseband register*/
593 offset = (u16)(RegRWStruct->offset) & 0xFFF;
594 value = RegRWStruct->value;
595 switch (RegRWStruct->width) {
597 oldValue = r8712_bb_reg_read(Adapter, offset);
598 oldValue &= 0xFFFFFF00;
603 oldValue = r8712_bb_reg_read(Adapter, offset);
604 oldValue &= 0xFFFF0000;
609 r8712_bb_reg_write(Adapter, offset, value);
611 switch (RegRWStruct->width) {
613 r8712_write8(Adapter, RegRWStruct->offset,
614 (unsigned char)RegRWStruct->value);
617 r8712_write16(Adapter, RegRWStruct->offset,
618 (unsigned short)RegRWStruct->value);
621 r8712_write32(Adapter, RegRWStruct->offset,
622 (unsigned int)RegRWStruct->value);
625 status = RNDIS_STATUS_NOT_ACCEPTED;
632 uint oid_rt_get_thermal_meter_hdl(struct oid_par_priv *poid_par_priv)
634 struct _adapter *Adapter = (struct _adapter *)
635 (poid_par_priv->adapter_context);
637 if (poid_par_priv->type_of_oid != QUERY_OID)
638 return RNDIS_STATUS_NOT_ACCEPTED;
640 if (Adapter->mppriv.act_in_progress)
641 return RNDIS_STATUS_NOT_ACCEPTED;
643 if (poid_par_priv->information_buf_len < sizeof(u8))
644 return RNDIS_STATUS_INVALID_LENGTH;
646 Adapter->mppriv.act_in_progress = true;
647 Adapter->mppriv.workparam.bcompleted = false;
648 Adapter->mppriv.workparam.act_type = MPT_GET_THERMAL_METER;
649 Adapter->mppriv.workparam.io_offset = 0;
650 Adapter->mppriv.workparam.io_value = 0xFFFFFFFF;
651 r8712_GetThermalMeter(Adapter, &Adapter->mppriv.workparam.io_value);
652 Adapter->mppriv.workparam.bcompleted = true;
653 Adapter->mppriv.act_in_progress = false;
654 *(u32 *)poid_par_priv->information_buf =
655 Adapter->mppriv.workparam.io_value;
656 *poid_par_priv->bytes_rw = sizeof(u32);
657 return RNDIS_STATUS_SUCCESS;
660 uint oid_rt_pro_read_efuse_hdl(struct oid_par_priv *poid_par_priv)
662 struct _adapter *Adapter = (struct _adapter *)
663 (poid_par_priv->adapter_context);
665 uint status = RNDIS_STATUS_SUCCESS;
667 struct EFUSE_ACCESS_STRUCT *pefuse;
669 u16 addr = 0, cnts = 0;
671 if (poid_par_priv->type_of_oid != QUERY_OID)
672 return RNDIS_STATUS_NOT_ACCEPTED;
673 if (poid_par_priv->information_buf_len <
674 sizeof(struct EFUSE_ACCESS_STRUCT))
675 return RNDIS_STATUS_INVALID_LENGTH;
676 pefuse = (struct EFUSE_ACCESS_STRUCT *)poid_par_priv->information_buf;
677 addr = pefuse->start_addr;
680 memset(data, 0xFF, cnts);
681 if ((addr > 511) || (cnts < 1) || (cnts > 512) || (addr + cnts) >
683 return RNDIS_STATUS_NOT_ACCEPTED;
684 if (!r8712_efuse_access(Adapter, true, addr, cnts, data))
685 status = RNDIS_STATUS_FAILURE;
686 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
690 /*------------------------------------------------------------------------*/
691 uint oid_rt_pro_write_efuse_hdl(struct oid_par_priv *poid_par_priv)
693 struct _adapter *Adapter = (struct _adapter *)
694 (poid_par_priv->adapter_context);
696 uint status = RNDIS_STATUS_SUCCESS;
698 struct EFUSE_ACCESS_STRUCT *pefuse;
700 u16 addr = 0, cnts = 0;
702 if (poid_par_priv->type_of_oid != SET_OID)
703 return RNDIS_STATUS_NOT_ACCEPTED;
705 pefuse = (struct EFUSE_ACCESS_STRUCT *)poid_par_priv->information_buf;
706 addr = pefuse->start_addr;
710 if ((addr > 511) || (cnts < 1) || (cnts > 512) ||
711 (addr + cnts) > r8712_efuse_get_max_size(Adapter))
712 return RNDIS_STATUS_NOT_ACCEPTED;
713 if (!r8712_efuse_access(Adapter, false, addr, cnts, data))
714 status = RNDIS_STATUS_FAILURE;
718 /*----------------------------------------------------------------------*/
720 uint oid_rt_get_efuse_current_size_hdl(struct oid_par_priv *poid_par_priv)
722 struct _adapter *Adapter = (struct _adapter *)
723 (poid_par_priv->adapter_context);
725 if (poid_par_priv->type_of_oid != QUERY_OID)
726 return RNDIS_STATUS_NOT_ACCEPTED;
727 if (poid_par_priv->information_buf_len < sizeof(int))
728 return RNDIS_STATUS_INVALID_LENGTH;
729 r8712_efuse_reg_init(Adapter);
730 *(int *)poid_par_priv->information_buf =
731 r8712_efuse_get_current_size(Adapter);
732 r8712_efuse_reg_uninit(Adapter);
733 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
734 return RNDIS_STATUS_SUCCESS;
737 uint oid_rt_get_efuse_max_size_hdl(struct oid_par_priv *poid_par_priv)
739 struct _adapter *Adapter = (struct _adapter *)
740 (poid_par_priv->adapter_context);
742 if (poid_par_priv->type_of_oid != QUERY_OID)
743 return RNDIS_STATUS_NOT_ACCEPTED;
744 if (poid_par_priv->information_buf_len < sizeof(u32))
745 return RNDIS_STATUS_INVALID_LENGTH;
746 *(int *)poid_par_priv->information_buf =
747 r8712_efuse_get_max_size(Adapter);
748 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
749 return RNDIS_STATUS_SUCCESS;
752 uint oid_rt_pro_efuse_hdl(struct oid_par_priv *poid_par_priv)
754 uint status = RNDIS_STATUS_SUCCESS;
756 if (poid_par_priv->type_of_oid == QUERY_OID)
757 status = oid_rt_pro_read_efuse_hdl(poid_par_priv);
759 status = oid_rt_pro_write_efuse_hdl(poid_par_priv);
763 uint oid_rt_pro_efuse_map_hdl(struct oid_par_priv *poid_par_priv)
765 struct _adapter *Adapter = (struct _adapter *)
766 (poid_par_priv->adapter_context);
767 uint status = RNDIS_STATUS_SUCCESS;
770 *poid_par_priv->bytes_rw = 0;
771 if (poid_par_priv->information_buf_len < EFUSE_MAP_MAX_SIZE)
772 return RNDIS_STATUS_INVALID_LENGTH;
773 data = (u8 *)poid_par_priv->information_buf;
774 if (poid_par_priv->type_of_oid == QUERY_OID) {
775 if (r8712_efuse_map_read(Adapter, 0, EFUSE_MAP_MAX_SIZE, data))
776 *poid_par_priv->bytes_rw = EFUSE_MAP_MAX_SIZE;
778 status = RNDIS_STATUS_FAILURE;
781 if (r8712_efuse_reg_init(Adapter)) {
782 if (r8712_efuse_map_write(Adapter, 0,
783 EFUSE_MAP_MAX_SIZE, data))
784 *poid_par_priv->bytes_rw = EFUSE_MAP_MAX_SIZE;
786 status = RNDIS_STATUS_FAILURE;
787 r8712_efuse_reg_uninit(Adapter);
789 status = RNDIS_STATUS_FAILURE;
795 uint oid_rt_set_bandwidth_hdl(struct oid_par_priv *poid_par_priv)
797 struct _adapter *Adapter = (struct _adapter *)
798 (poid_par_priv->adapter_context);
801 if (poid_par_priv->type_of_oid != SET_OID)
802 return RNDIS_STATUS_NOT_ACCEPTED;
803 if (poid_par_priv->information_buf_len < sizeof(u32))
804 return RNDIS_STATUS_INVALID_LENGTH;
805 bandwidth = *((u32 *)poid_par_priv->information_buf);/*4*/
806 if (bandwidth != HT_CHANNEL_WIDTH_20)
807 bandwidth = HT_CHANNEL_WIDTH_40;
808 Adapter->mppriv.curr_bandwidth = (u8)bandwidth;
809 r8712_SwitchBandwidth(Adapter);
810 return RNDIS_STATUS_SUCCESS;
813 uint oid_rt_set_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv)
815 struct _adapter *Adapter = (struct _adapter *)
816 (poid_par_priv->adapter_context);
820 if (poid_par_priv->type_of_oid != SET_OID)
821 return RNDIS_STATUS_NOT_ACCEPTED;
822 if (poid_par_priv->information_buf_len < sizeof(u8))
823 return RNDIS_STATUS_INVALID_LENGTH;
824 rx_pkt_type = *((u8 *)poid_par_priv->information_buf);/*4*/
825 rcr_val32 = r8712_read32(Adapter, RCR);/*RCR = 0x10250048*/
826 rcr_val32 &= ~(RCR_CBSSID | RCR_AB | RCR_AM | RCR_APM | RCR_AAP);
827 switch (rx_pkt_type) {
828 case RX_PKT_BROADCAST:
829 rcr_val32 |= (RCR_AB | RCR_AM | RCR_APM | RCR_AAP | RCR_ACRC32);
831 case RX_PKT_DEST_ADDR:
832 rcr_val32 |= (RCR_AB | RCR_AM | RCR_APM | RCR_AAP | RCR_ACRC32);
834 case RX_PKT_PHY_MATCH:
835 rcr_val32 |= (RCR_APM | RCR_ACRC32);
838 rcr_val32 &= ~(RCR_AAP |
845 if (rx_pkt_type == RX_PKT_DEST_ADDR)
846 Adapter->mppriv.check_mp_pkt = 1;
848 Adapter->mppriv.check_mp_pkt = 0;
849 r8712_write32(Adapter, RCR, rcr_val32);
850 return RNDIS_STATUS_SUCCESS;
853 /*--------------------------------------------------------------------------*/
855 unsigned int mp_ioctl_xmit_packet_hdl(struct oid_par_priv *poid_par_priv)
860 /*-------------------------------------------------------------------------*/
861 uint oid_rt_set_power_down_hdl(struct oid_par_priv *poid_par_priv)
863 if (poid_par_priv->type_of_oid != SET_OID)
864 return RNDIS_STATUS_NOT_ACCEPTED;
865 /*CALL the power_down function*/
866 return RNDIS_STATUS_SUCCESS;
869 /*-------------------------------------------------------------------------- */
870 uint oid_rt_get_power_mode_hdl(struct oid_par_priv *poid_par_priv)
872 struct _adapter *Adapter = (struct _adapter *)
873 (poid_par_priv->adapter_context);
875 if (poid_par_priv->type_of_oid != QUERY_OID)
876 return RNDIS_STATUS_NOT_ACCEPTED;
877 if (poid_par_priv->information_buf_len < sizeof(u32))
878 return RNDIS_STATUS_INVALID_LENGTH;
879 *(int *)poid_par_priv->information_buf =
880 Adapter->registrypriv.low_power ? POWER_LOW : POWER_NORMAL;
881 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
882 return RNDIS_STATUS_SUCCESS;