1 /****************************************************************************** 2 * rtl871x_mp_ioctl.c 3 * 4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. 5 * Linux device driver for RTL8192SU 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of version 2 of the GNU General Public License as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program; if not, write to the Free Software Foundation, Inc., 18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 19 * 20 * Modifications for inclusion into the Linux staging tree are 21 * Copyright(c) 2010 Larry Finger. All rights reserved. 22 * 23 * Contact information: 24 * WLAN FAE <wlanfae@realtek.com> 25 * Larry Finger <Larry.Finger@lwfinger.net> 26 * 27 ******************************************************************************/ 28 29 #include <linux/rndis.h> 30 #include "osdep_service.h" 31 #include "drv_types.h" 32 #include "mlme_osdep.h" 33 #include "rtl871x_mp.h" 34 #include "rtl871x_mp_ioctl.h" 35 36 uint oid_null_function(struct oid_par_priv *poid_par_priv) 37 { 38 return RNDIS_STATUS_SUCCESS; 39 } 40 41 uint oid_rt_wireless_mode_hdl(struct oid_par_priv *poid_par_priv) 42 { 43 uint status = RNDIS_STATUS_SUCCESS; 44 struct _adapter *Adapter = (struct _adapter *) 45 (poid_par_priv->adapter_context); 46 47 if (poid_par_priv->type_of_oid == SET_OID) { 48 if (poid_par_priv->information_buf_len >= sizeof(u8)) 49 Adapter->registrypriv.wireless_mode = 50 *(u8 *)poid_par_priv->information_buf; 51 else 52 status = RNDIS_STATUS_INVALID_LENGTH; 53 } else if (poid_par_priv->type_of_oid == QUERY_OID) { 54 if (poid_par_priv->information_buf_len >= sizeof(u8)) { 55 *(u8 *)poid_par_priv->information_buf = 56 Adapter->registrypriv.wireless_mode; 57 *poid_par_priv->bytes_rw = 58 poid_par_priv->information_buf_len; 59 } else 60 status = RNDIS_STATUS_INVALID_LENGTH; 61 } else { 62 status = RNDIS_STATUS_NOT_ACCEPTED; 63 } 64 return status; 65 } 66 67 uint oid_rt_pro_write_bb_reg_hdl(struct oid_par_priv *poid_par_priv) 68 { 69 struct _adapter *Adapter = (struct _adapter *) 70 (poid_par_priv->adapter_context); 71 struct bb_reg_param *pbbreg; 72 u16 offset; 73 u32 value; 74 75 if (poid_par_priv->type_of_oid != SET_OID) 76 return RNDIS_STATUS_NOT_ACCEPTED; 77 if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param)) 78 return RNDIS_STATUS_INVALID_LENGTH; 79 pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf); 80 offset = (u16)(pbbreg->offset) & 0xFFF; /*0ffset :0x800~0xfff*/ 81 if (offset < BB_REG_BASE_ADDR) 82 offset |= BB_REG_BASE_ADDR; 83 value = pbbreg->value; 84 r8712_bb_reg_write(Adapter, offset, value); 85 return RNDIS_STATUS_SUCCESS; 86 } 87 88 uint oid_rt_pro_read_bb_reg_hdl(struct oid_par_priv *poid_par_priv) 89 { 90 struct _adapter *Adapter = (struct _adapter *) 91 (poid_par_priv->adapter_context); 92 struct bb_reg_param *pbbreg; 93 u16 offset; 94 u32 value; 95 96 if (poid_par_priv->type_of_oid != QUERY_OID) 97 return RNDIS_STATUS_NOT_ACCEPTED; 98 if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param)) 99 return RNDIS_STATUS_INVALID_LENGTH; 100 pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf); 101 offset = (u16)(pbbreg->offset) & 0xFFF; /*0ffset :0x800~0xfff*/ 102 if (offset < BB_REG_BASE_ADDR) 103 offset |= BB_REG_BASE_ADDR; 104 value = r8712_bb_reg_read(Adapter, offset); 105 pbbreg->value = value; 106 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 107 return RNDIS_STATUS_SUCCESS; 108 } 109 110 uint oid_rt_pro_write_rf_reg_hdl(struct oid_par_priv *poid_par_priv) 111 { 112 struct _adapter *Adapter = (struct _adapter *) 113 (poid_par_priv->adapter_context); 114 struct rf_reg_param *pbbreg; 115 u8 path; 116 u8 offset; 117 u32 value; 118 119 if (poid_par_priv->type_of_oid != SET_OID) 120 return RNDIS_STATUS_NOT_ACCEPTED; 121 if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param)) 122 return RNDIS_STATUS_INVALID_LENGTH; 123 pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf); 124 path = (u8)pbbreg->path; 125 if (path > RF_PATH_B) 126 return RNDIS_STATUS_NOT_ACCEPTED; 127 offset = (u8)pbbreg->offset; 128 value = pbbreg->value; 129 r8712_rf_reg_write(Adapter, path, offset, value); 130 return RNDIS_STATUS_SUCCESS; 131 } 132 133 uint oid_rt_pro_read_rf_reg_hdl(struct oid_par_priv *poid_par_priv) 134 { 135 struct _adapter *Adapter = (struct _adapter *) 136 (poid_par_priv->adapter_context); 137 struct rf_reg_param *pbbreg; 138 u8 path; 139 u8 offset; 140 u32 value; 141 142 if (poid_par_priv->type_of_oid != QUERY_OID) 143 return RNDIS_STATUS_NOT_ACCEPTED; 144 if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param)) 145 return RNDIS_STATUS_INVALID_LENGTH; 146 pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf); 147 path = (u8)pbbreg->path; 148 if (path > RF_PATH_B) /* 1T2R path_a /path_b */ 149 return RNDIS_STATUS_NOT_ACCEPTED; 150 offset = (u8)pbbreg->offset; 151 value = r8712_rf_reg_read(Adapter, path, offset); 152 pbbreg->value = value; 153 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 154 return RNDIS_STATUS_SUCCESS; 155 } 156 157 /*This function initializes the DUT to the MP test mode*/ 158 static int mp_start_test(struct _adapter *padapter) 159 { 160 struct mp_priv *pmppriv = &padapter->mppriv; 161 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 162 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 163 struct ndis_wlan_bssid_ex bssid; 164 struct sta_info *psta; 165 unsigned long length; 166 unsigned long irqL; 167 int res = _SUCCESS; 168 169 /* 3 1. initialize a new struct ndis_wlan_bssid_ex */ 170 memcpy(bssid.MacAddress, pmppriv->network_macaddr, ETH_ALEN); 171 bssid.Ssid.SsidLength = 16; 172 memcpy(bssid.Ssid.Ssid, (unsigned char *)"mp_pseudo_adhoc", 173 bssid.Ssid.SsidLength); 174 bssid.InfrastructureMode = Ndis802_11IBSS; 175 bssid.NetworkTypeInUse = Ndis802_11DS; 176 bssid.IELength = 0; 177 length = r8712_get_ndis_wlan_bssid_ex_sz(&bssid); 178 if (length % 4) { 179 /*round up to multiple of 4 bytes.*/ 180 bssid.Length = ((length >> 2) + 1) << 2; 181 } else 182 bssid.Length = length; 183 spin_lock_irqsave(&pmlmepriv->lock, irqL); 184 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == true) 185 goto end_of_mp_start_test; 186 /*init mp_start_test status*/ 187 pmppriv->prev_fw_state = get_fwstate(pmlmepriv); 188 pmlmepriv->fw_state = WIFI_MP_STATE; 189 if (pmppriv->mode == _LOOPBOOK_MODE_) 190 set_fwstate(pmlmepriv, WIFI_MP_LPBK_STATE); /*append txdesc*/ 191 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 192 /* 3 2. create a new psta for mp driver */ 193 /* clear psta in the cur_network, if any */ 194 psta = r8712_get_stainfo(&padapter->stapriv, 195 tgt_network->network.MacAddress); 196 if (psta) 197 r8712_free_stainfo(padapter, psta); 198 psta = r8712_alloc_stainfo(&padapter->stapriv, bssid.MacAddress); 199 if (psta == NULL) { 200 res = _FAIL; 201 goto end_of_mp_start_test; 202 } 203 /* 3 3. join psudo AdHoc */ 204 tgt_network->join_res = 1; 205 tgt_network->aid = psta->aid = 1; 206 memcpy(&tgt_network->network, &bssid, length); 207 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 208 r8712_os_indicate_connect(padapter); 209 /* Set to LINKED STATE for MP TRX Testing */ 210 set_fwstate(pmlmepriv, _FW_LINKED); 211 end_of_mp_start_test: 212 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 213 return res; 214 } 215 216 /*This function change the DUT from the MP test mode into normal mode */ 217 static int mp_stop_test(struct _adapter *padapter) 218 { 219 struct mp_priv *pmppriv = &padapter->mppriv; 220 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 221 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 222 struct sta_info *psta; 223 unsigned long irqL; 224 225 spin_lock_irqsave(&pmlmepriv->lock, irqL); 226 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false) 227 goto end_of_mp_stop_test; 228 /* 3 1. disconnect psudo AdHoc */ 229 r8712_os_indicate_disconnect(padapter); 230 /* 3 2. clear psta used in mp test mode. */ 231 psta = r8712_get_stainfo(&padapter->stapriv, 232 tgt_network->network.MacAddress); 233 if (psta) 234 r8712_free_stainfo(padapter, psta); 235 /* 3 3. return to normal state (default:station mode) */ 236 pmlmepriv->fw_state = pmppriv->prev_fw_state; /* WIFI_STATION_STATE;*/ 237 /*flush the cur_network*/ 238 memset(tgt_network, 0, sizeof(struct wlan_network)); 239 end_of_mp_stop_test: 240 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 241 return _SUCCESS; 242 } 243 244 int mp_start_joinbss(struct _adapter *padapter, struct ndis_802_11_ssid *pssid) 245 { 246 struct mp_priv *pmppriv = &padapter->mppriv; 247 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 248 unsigned char res = _SUCCESS; 249 250 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false) 251 return _FAIL; 252 if (check_fwstate(pmlmepriv, _FW_LINKED) == false) 253 return _FAIL; 254 _clr_fwstate_(pmlmepriv, _FW_LINKED); 255 res = r8712_setassocsta_cmd(padapter, pmppriv->network_macaddr); 256 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 257 return res; 258 } 259 260 uint oid_rt_pro_set_data_rate_hdl(struct oid_par_priv 261 *poid_par_priv) 262 { 263 struct _adapter *Adapter = (struct _adapter *) 264 (poid_par_priv->adapter_context); 265 u32 ratevalue; 266 267 if (poid_par_priv->type_of_oid != SET_OID) 268 return RNDIS_STATUS_NOT_ACCEPTED; 269 if (poid_par_priv->information_buf_len != sizeof(u32)) 270 return RNDIS_STATUS_INVALID_LENGTH; 271 ratevalue = *((u32 *)poid_par_priv->information_buf); 272 if (ratevalue >= MPT_RATE_LAST) 273 return RNDIS_STATUS_INVALID_DATA; 274 Adapter->mppriv.curr_rateidx = ratevalue; 275 r8712_SetDataRate(Adapter); 276 return RNDIS_STATUS_SUCCESS; 277 } 278 279 uint oid_rt_pro_start_test_hdl(struct oid_par_priv *poid_par_priv) 280 { 281 struct _adapter *Adapter = (struct _adapter *) 282 (poid_par_priv->adapter_context); 283 uint status = RNDIS_STATUS_SUCCESS; 284 u32 mode; 285 u8 val8; 286 287 if (poid_par_priv->type_of_oid != SET_OID) 288 return RNDIS_STATUS_NOT_ACCEPTED; 289 mode = *((u32 *)poid_par_priv->information_buf); 290 Adapter->mppriv.mode = mode;/* 1 for loopback*/ 291 if (mp_start_test(Adapter) == _FAIL) 292 status = RNDIS_STATUS_NOT_ACCEPTED; 293 r8712_write8(Adapter, MSR, 1); /* Link in ad hoc network, 0x1025004C */ 294 r8712_write8(Adapter, RCR, 0); /* RCR : disable all pkt, 0x10250048 */ 295 /* RCR disable Check BSSID, 0x1025004a */ 296 r8712_write8(Adapter, RCR+2, 0x57); 297 /* disable RX filter map , mgt frames will put in RX FIFO 0 */ 298 r8712_write16(Adapter, RXFLTMAP0, 0x0); 299 val8 = r8712_read8(Adapter, EE_9346CR); 300 if (!(val8 & _9356SEL)) { /*boot from EFUSE*/ 301 r8712_efuse_reg_init(Adapter); 302 r8712_efuse_change_max_size(Adapter); 303 r8712_efuse_reg_uninit(Adapter); 304 } 305 return status; 306 } 307 308 uint oid_rt_pro_stop_test_hdl(struct oid_par_priv *poid_par_priv) 309 { 310 struct _adapter *Adapter = (struct _adapter *) 311 (poid_par_priv->adapter_context); 312 uint status = RNDIS_STATUS_SUCCESS; 313 314 if (poid_par_priv->type_of_oid != SET_OID) 315 return RNDIS_STATUS_NOT_ACCEPTED; 316 if (mp_stop_test(Adapter) == _FAIL) 317 status = RNDIS_STATUS_NOT_ACCEPTED; 318 return status; 319 } 320 321 uint oid_rt_pro_set_channel_direct_call_hdl(struct oid_par_priv 322 *poid_par_priv) 323 { 324 struct _adapter *Adapter = (struct _adapter *) 325 (poid_par_priv->adapter_context); 326 u32 Channel; 327 328 if (poid_par_priv->type_of_oid != SET_OID) 329 return RNDIS_STATUS_NOT_ACCEPTED; 330 if (poid_par_priv->information_buf_len != sizeof(u32)) 331 return RNDIS_STATUS_INVALID_LENGTH; 332 Channel = *((u32 *)poid_par_priv->information_buf); 333 if (Channel > 14) 334 return RNDIS_STATUS_NOT_ACCEPTED; 335 Adapter->mppriv.curr_ch = Channel; 336 r8712_SetChannel(Adapter); 337 return RNDIS_STATUS_SUCCESS; 338 } 339 340 uint oid_rt_pro_set_antenna_bb_hdl(struct oid_par_priv *poid_par_priv) 341 { 342 struct _adapter *Adapter = (struct _adapter *) 343 (poid_par_priv->adapter_context); 344 u32 antenna; 345 346 if (poid_par_priv->type_of_oid != SET_OID) 347 return RNDIS_STATUS_NOT_ACCEPTED; 348 if (poid_par_priv->information_buf_len != sizeof(u32)) 349 return RNDIS_STATUS_INVALID_LENGTH; 350 antenna = *((u32 *)poid_par_priv->information_buf); 351 Adapter->mppriv.antenna_tx = (u16)((antenna & 0xFFFF0000) >> 16); 352 Adapter->mppriv.antenna_rx = (u16)(antenna & 0x0000FFFF); 353 r8712_SwitchAntenna(Adapter); 354 return RNDIS_STATUS_SUCCESS; 355 } 356 357 uint oid_rt_pro_set_tx_power_control_hdl( 358 struct oid_par_priv *poid_par_priv) 359 { 360 struct _adapter *Adapter = (struct _adapter *) 361 (poid_par_priv->adapter_context); 362 u32 tx_pwr_idx; 363 364 if (poid_par_priv->type_of_oid != SET_OID) 365 return RNDIS_STATUS_NOT_ACCEPTED; 366 if (poid_par_priv->information_buf_len != sizeof(u32)) 367 return RNDIS_STATUS_INVALID_LENGTH; 368 tx_pwr_idx = *((u32 *)poid_par_priv->information_buf); 369 if (tx_pwr_idx > MAX_TX_PWR_INDEX_N_MODE) 370 return RNDIS_STATUS_NOT_ACCEPTED; 371 Adapter->mppriv.curr_txpoweridx = (u8)tx_pwr_idx; 372 r8712_SetTxPower(Adapter); 373 return RNDIS_STATUS_SUCCESS; 374 } 375 376 uint oid_rt_pro_query_tx_packet_sent_hdl( 377 struct oid_par_priv *poid_par_priv) 378 { 379 uint status = RNDIS_STATUS_SUCCESS; 380 struct _adapter *Adapter = (struct _adapter *) 381 (poid_par_priv->adapter_context); 382 383 if (poid_par_priv->type_of_oid != QUERY_OID) { 384 status = RNDIS_STATUS_NOT_ACCEPTED; 385 return status; 386 } 387 if (poid_par_priv->information_buf_len == sizeof(u32)) { 388 *(u32 *)poid_par_priv->information_buf = 389 Adapter->mppriv.tx_pktcount; 390 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 391 } else 392 status = RNDIS_STATUS_INVALID_LENGTH; 393 return status; 394 } 395 396 uint oid_rt_pro_query_rx_packet_received_hdl( 397 struct oid_par_priv *poid_par_priv) 398 { 399 uint status = RNDIS_STATUS_SUCCESS; 400 struct _adapter *Adapter = (struct _adapter *) 401 (poid_par_priv->adapter_context); 402 403 if (poid_par_priv->type_of_oid != QUERY_OID) { 404 status = RNDIS_STATUS_NOT_ACCEPTED; 405 return status; 406 } 407 if (poid_par_priv->information_buf_len == sizeof(u32)) { 408 *(u32 *)poid_par_priv->information_buf = 409 Adapter->mppriv.rx_pktcount; 410 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 411 } else 412 status = RNDIS_STATUS_INVALID_LENGTH; 413 return status; 414 } 415 416 uint oid_rt_pro_query_rx_packet_crc32_error_hdl( 417 struct oid_par_priv *poid_par_priv) 418 { 419 uint status = RNDIS_STATUS_SUCCESS; 420 struct _adapter *Adapter = (struct _adapter *) 421 (poid_par_priv->adapter_context); 422 423 if (poid_par_priv->type_of_oid != QUERY_OID) { 424 status = RNDIS_STATUS_NOT_ACCEPTED; 425 return status; 426 } 427 if (poid_par_priv->information_buf_len == sizeof(u32)) { 428 *(u32 *)poid_par_priv->information_buf = 429 Adapter->mppriv.rx_crcerrpktcount; 430 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 431 } else 432 status = RNDIS_STATUS_INVALID_LENGTH; 433 return status; 434 } 435 436 uint oid_rt_pro_reset_tx_packet_sent_hdl(struct oid_par_priv 437 *poid_par_priv) 438 { 439 struct _adapter *Adapter = (struct _adapter *) 440 (poid_par_priv->adapter_context); 441 442 if (poid_par_priv->type_of_oid != SET_OID) 443 return RNDIS_STATUS_NOT_ACCEPTED; 444 Adapter->mppriv.tx_pktcount = 0; 445 return RNDIS_STATUS_SUCCESS; 446 } 447 448 uint oid_rt_pro_reset_rx_packet_received_hdl(struct oid_par_priv 449 *poid_par_priv) 450 { 451 uint status = RNDIS_STATUS_SUCCESS; 452 struct _adapter *Adapter = (struct _adapter *) 453 (poid_par_priv->adapter_context); 454 455 if (poid_par_priv->type_of_oid != SET_OID) 456 return RNDIS_STATUS_NOT_ACCEPTED; 457 if (poid_par_priv->information_buf_len == sizeof(u32)) { 458 Adapter->mppriv.rx_pktcount = 0; 459 Adapter->mppriv.rx_crcerrpktcount = 0; 460 } else 461 status = RNDIS_STATUS_INVALID_LENGTH; 462 return status; 463 } 464 465 uint oid_rt_reset_phy_rx_packet_count_hdl(struct oid_par_priv 466 *poid_par_priv) 467 { 468 struct _adapter *Adapter = (struct _adapter *) 469 (poid_par_priv->adapter_context); 470 471 if (poid_par_priv->type_of_oid != SET_OID) 472 return RNDIS_STATUS_NOT_ACCEPTED; 473 r8712_ResetPhyRxPktCount(Adapter); 474 return RNDIS_STATUS_SUCCESS; 475 } 476 477 uint oid_rt_get_phy_rx_packet_received_hdl(struct oid_par_priv 478 *poid_par_priv) 479 { 480 struct _adapter *Adapter = (struct _adapter *) 481 (poid_par_priv->adapter_context); 482 483 if (poid_par_priv->type_of_oid != QUERY_OID) 484 return RNDIS_STATUS_NOT_ACCEPTED; 485 if (poid_par_priv->information_buf_len != sizeof(u32)) 486 return RNDIS_STATUS_INVALID_LENGTH; 487 *(u32 *)poid_par_priv->information_buf = 488 r8712_GetPhyRxPktReceived(Adapter); 489 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 490 return RNDIS_STATUS_SUCCESS; 491 } 492 493 uint oid_rt_get_phy_rx_packet_crc32_error_hdl(struct oid_par_priv 494 *poid_par_priv) 495 { 496 struct _adapter *Adapter = (struct _adapter *) 497 (poid_par_priv->adapter_context); 498 499 if (poid_par_priv->type_of_oid != QUERY_OID) 500 return RNDIS_STATUS_NOT_ACCEPTED; 501 if (poid_par_priv->information_buf_len != sizeof(u32)) 502 return RNDIS_STATUS_INVALID_LENGTH; 503 *(u32 *)poid_par_priv->information_buf = 504 r8712_GetPhyRxPktCRC32Error(Adapter); 505 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 506 return RNDIS_STATUS_SUCCESS; 507 } 508 509 uint oid_rt_pro_set_modulation_hdl(struct oid_par_priv 510 *poid_par_priv) 511 { 512 struct _adapter *Adapter = (struct _adapter *) 513 (poid_par_priv->adapter_context); 514 515 if (poid_par_priv->type_of_oid != SET_OID) 516 return RNDIS_STATUS_NOT_ACCEPTED; 517 518 Adapter->mppriv.curr_modem = *((u8 *)poid_par_priv->information_buf); 519 return RNDIS_STATUS_SUCCESS; 520 } 521 522 uint oid_rt_pro_set_continuous_tx_hdl(struct oid_par_priv 523 *poid_par_priv) 524 { 525 struct _adapter *Adapter = (struct _adapter *) 526 (poid_par_priv->adapter_context); 527 u32 bStartTest; 528 529 if (poid_par_priv->type_of_oid != SET_OID) 530 return RNDIS_STATUS_NOT_ACCEPTED; 531 bStartTest = *((u32 *)poid_par_priv->information_buf); 532 r8712_SetContinuousTx(Adapter, (u8)bStartTest); 533 return RNDIS_STATUS_SUCCESS; 534 } 535 536 uint oid_rt_pro_set_single_carrier_tx_hdl(struct oid_par_priv 537 *poid_par_priv) 538 { 539 struct _adapter *Adapter = (struct _adapter *) 540 (poid_par_priv->adapter_context); 541 u32 bStartTest; 542 543 if (poid_par_priv->type_of_oid != SET_OID) 544 return RNDIS_STATUS_NOT_ACCEPTED; 545 bStartTest = *((u32 *)poid_par_priv->information_buf); 546 r8712_SetSingleCarrierTx(Adapter, (u8)bStartTest); 547 return RNDIS_STATUS_SUCCESS; 548 } 549 550 uint oid_rt_pro_set_carrier_suppression_tx_hdl(struct oid_par_priv 551 *poid_par_priv) 552 { 553 struct _adapter *Adapter = (struct _adapter *) 554 (poid_par_priv->adapter_context); 555 u32 bStartTest; 556 557 if (poid_par_priv->type_of_oid != SET_OID) 558 return RNDIS_STATUS_NOT_ACCEPTED; 559 bStartTest = *((u32 *)poid_par_priv->information_buf); 560 r8712_SetCarrierSuppressionTx(Adapter, (u8)bStartTest); 561 return RNDIS_STATUS_SUCCESS; 562 } 563 564 uint oid_rt_pro_set_single_tone_tx_hdl(struct oid_par_priv 565 *poid_par_priv) 566 { 567 struct _adapter *Adapter = (struct _adapter *) 568 (poid_par_priv->adapter_context); 569 u32 bStartTest; 570 571 if (poid_par_priv->type_of_oid != SET_OID) 572 return RNDIS_STATUS_NOT_ACCEPTED; 573 bStartTest = *((u32 *)poid_par_priv->information_buf); 574 r8712_SetSingleToneTx(Adapter, (u8)bStartTest); 575 return RNDIS_STATUS_SUCCESS; 576 } 577 578 uint oid_rt_pro8711_join_bss_hdl(struct oid_par_priv *poid_par_priv) 579 { 580 struct _adapter *Adapter = (struct _adapter *) 581 (poid_par_priv->adapter_context); 582 uint status = RNDIS_STATUS_SUCCESS; 583 struct ndis_802_11_ssid *pssid; 584 585 if (poid_par_priv->type_of_oid != SET_OID) 586 return RNDIS_STATUS_NOT_ACCEPTED; 587 *poid_par_priv->bytes_needed = (u32)sizeof(struct ndis_802_11_ssid); 588 *poid_par_priv->bytes_rw = 0; 589 if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed) 590 return RNDIS_STATUS_INVALID_LENGTH; 591 pssid = (struct ndis_802_11_ssid *)poid_par_priv->information_buf; 592 if (mp_start_joinbss(Adapter, pssid) == _FAIL) 593 status = RNDIS_STATUS_NOT_ACCEPTED; 594 *poid_par_priv->bytes_rw = sizeof(struct ndis_802_11_ssid); 595 return status; 596 } 597 598 uint oid_rt_pro_read_register_hdl(struct oid_par_priv 599 *poid_par_priv) 600 { 601 struct _adapter *Adapter = (struct _adapter *) 602 (poid_par_priv->adapter_context); 603 uint status = RNDIS_STATUS_SUCCESS; 604 struct mp_rw_reg *RegRWStruct; 605 u16 offset; 606 607 if (poid_par_priv->type_of_oid != QUERY_OID) 608 return RNDIS_STATUS_NOT_ACCEPTED; 609 RegRWStruct = (struct mp_rw_reg *)poid_par_priv->information_buf; 610 if ((RegRWStruct->offset >= 0x10250800) && 611 (RegRWStruct->offset <= 0x10250FFF)) { 612 /*baseband register*/ 613 /*0ffset :0x800~0xfff*/ 614 offset = (u16)(RegRWStruct->offset) & 0xFFF; 615 RegRWStruct->value = r8712_bb_reg_read(Adapter, offset); 616 } else { 617 switch (RegRWStruct->width) { 618 case 1: 619 RegRWStruct->value = r8712_read8(Adapter, 620 RegRWStruct->offset); 621 break; 622 case 2: 623 RegRWStruct->value = r8712_read16(Adapter, 624 RegRWStruct->offset); 625 break; 626 case 4: 627 RegRWStruct->value = r8712_read32(Adapter, 628 RegRWStruct->offset); 629 break; 630 default: 631 status = RNDIS_STATUS_NOT_ACCEPTED; 632 break; 633 } 634 } 635 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 636 return status; 637 } 638 639 uint oid_rt_pro_write_register_hdl(struct oid_par_priv *poid_par_priv) 640 { 641 struct _adapter *Adapter = (struct _adapter *) 642 (poid_par_priv->adapter_context); 643 uint status = RNDIS_STATUS_SUCCESS; 644 struct mp_rw_reg *RegRWStruct; 645 u16 offset; 646 u32 value; 647 u32 oldValue = 0; 648 649 if (poid_par_priv->type_of_oid != SET_OID) 650 return RNDIS_STATUS_NOT_ACCEPTED; 651 RegRWStruct = (struct mp_rw_reg *)poid_par_priv->information_buf; 652 if ((RegRWStruct->offset >= 0x10250800) && 653 (RegRWStruct->offset <= 0x10250FFF)) { 654 /*baseband register*/ 655 offset = (u16)(RegRWStruct->offset) & 0xFFF; 656 value = RegRWStruct->value; 657 switch (RegRWStruct->width) { 658 case 1: 659 oldValue = r8712_bb_reg_read(Adapter, offset); 660 oldValue &= 0xFFFFFF00; 661 value &= 0x000000FF; 662 value |= oldValue; 663 break; 664 case 2: 665 oldValue = r8712_bb_reg_read(Adapter, offset); 666 oldValue &= 0xFFFF0000; 667 value &= 0x0000FFFF; 668 value |= oldValue; 669 break; 670 } 671 r8712_bb_reg_write(Adapter, offset, value); 672 } else { 673 switch (RegRWStruct->width) { 674 case 1: 675 r8712_write8(Adapter, RegRWStruct->offset, 676 (unsigned char)RegRWStruct->value); 677 break; 678 case 2: 679 r8712_write16(Adapter, RegRWStruct->offset, 680 (unsigned short)RegRWStruct->value); 681 break; 682 case 4: 683 r8712_write32(Adapter, RegRWStruct->offset, 684 (unsigned int)RegRWStruct->value); 685 break; 686 default: 687 status = RNDIS_STATUS_NOT_ACCEPTED; 688 break; 689 } 690 691 if ((status == RNDIS_STATUS_SUCCESS) && 692 (RegRWStruct->offset == HIMR) && 693 (RegRWStruct->width == 4)) 694 Adapter->ImrContent = RegRWStruct->value; 695 } 696 return status; 697 } 698 699 uint oid_rt_pro_burst_read_register_hdl(struct oid_par_priv 700 *poid_par_priv) 701 { 702 struct _adapter *Adapter = (struct _adapter *) 703 (poid_par_priv->adapter_context); 704 struct burst_rw_reg *pBstRwReg; 705 706 if (poid_par_priv->type_of_oid != QUERY_OID) 707 return RNDIS_STATUS_NOT_ACCEPTED; 708 pBstRwReg = (struct burst_rw_reg *)poid_par_priv->information_buf; 709 r8712_read_mem(Adapter, pBstRwReg->offset, (u32)pBstRwReg->len, 710 pBstRwReg->Data); 711 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 712 return RNDIS_STATUS_SUCCESS; 713 } 714 715 uint oid_rt_pro_burst_write_register_hdl(struct oid_par_priv 716 *poid_par_priv) 717 { 718 struct _adapter *Adapter = (struct _adapter *) 719 (poid_par_priv->adapter_context); 720 struct burst_rw_reg *pBstRwReg; 721 722 if (poid_par_priv->type_of_oid != SET_OID) 723 return RNDIS_STATUS_NOT_ACCEPTED; 724 pBstRwReg = (struct burst_rw_reg *)poid_par_priv->information_buf; 725 r8712_write_mem(Adapter, pBstRwReg->offset, (u32)pBstRwReg->len, 726 pBstRwReg->Data); 727 return RNDIS_STATUS_SUCCESS; 728 } 729 730 uint oid_rt_pro_write_txcmd_hdl(struct oid_par_priv *poid_par_priv) 731 { 732 return RNDIS_STATUS_SUCCESS; 733 } 734 735 uint oid_rt_pro_read16_eeprom_hdl(struct oid_par_priv *poid_par_priv) 736 { 737 struct _adapter *Adapter = (struct _adapter *) 738 (poid_par_priv->adapter_context); 739 struct eeprom_rw_param *pEEPROM; 740 741 if (poid_par_priv->type_of_oid != QUERY_OID) 742 return RNDIS_STATUS_NOT_ACCEPTED; 743 pEEPROM = (struct eeprom_rw_param *)poid_par_priv->information_buf; 744 pEEPROM->value = r8712_eeprom_read16(Adapter, 745 (u16)(pEEPROM->offset >> 1)); 746 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 747 return RNDIS_STATUS_SUCCESS; 748 } 749 750 uint oid_rt_pro_write16_eeprom_hdl(struct oid_par_priv *poid_par_priv) 751 { 752 struct _adapter *Adapter = (struct _adapter *) 753 (poid_par_priv->adapter_context); 754 struct eeprom_rw_param *pEEPROM; 755 756 if (poid_par_priv->type_of_oid != SET_OID) 757 return RNDIS_STATUS_NOT_ACCEPTED; 758 pEEPROM = (struct eeprom_rw_param *)poid_par_priv->information_buf; 759 r8712_eeprom_write16(Adapter, (u16)(pEEPROM->offset >> 1), 760 pEEPROM->value); 761 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 762 return RNDIS_STATUS_SUCCESS; 763 } 764 765 uint oid_rt_pro8711_wi_poll_hdl(struct oid_par_priv *poid_par_priv) 766 { 767 struct _adapter *Adapter = (struct _adapter *) 768 (poid_par_priv->adapter_context); 769 struct mp_wiparam *pwi_param; 770 771 if (poid_par_priv->type_of_oid != QUERY_OID) 772 return RNDIS_STATUS_NOT_ACCEPTED; 773 if (poid_par_priv->information_buf_len < sizeof(struct mp_wiparam)) 774 return RNDIS_STATUS_INVALID_LENGTH; 775 if (Adapter->mppriv.workparam.bcompleted == false) 776 return RNDIS_STATUS_NOT_ACCEPTED; 777 pwi_param = (struct mp_wiparam *)poid_par_priv->information_buf; 778 memcpy(pwi_param, &Adapter->mppriv.workparam, 779 sizeof(struct mp_wiparam)); 780 Adapter->mppriv.act_in_progress = false; 781 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 782 return RNDIS_STATUS_SUCCESS; 783 } 784 785 uint oid_rt_pro8711_pkt_loss_hdl(struct oid_par_priv *poid_par_priv) 786 { 787 struct _adapter *Adapter = (struct _adapter *) 788 (poid_par_priv->adapter_context); 789 790 if (poid_par_priv->type_of_oid != QUERY_OID) 791 return RNDIS_STATUS_NOT_ACCEPTED; 792 if (poid_par_priv->information_buf_len < sizeof(uint) * 2) 793 return RNDIS_STATUS_INVALID_LENGTH; 794 if (*(uint *)poid_par_priv->information_buf == 1) 795 Adapter->mppriv.rx_pktloss = 0; 796 *((uint *)poid_par_priv->information_buf+1) = 797 Adapter->mppriv.rx_pktloss; 798 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 799 return RNDIS_STATUS_SUCCESS; 800 } 801 802 uint oid_rt_rd_attrib_mem_hdl(struct oid_par_priv *poid_par_priv) 803 { 804 if (poid_par_priv->type_of_oid != QUERY_OID) 805 return RNDIS_STATUS_NOT_ACCEPTED; 806 return RNDIS_STATUS_SUCCESS; 807 } 808 809 uint oid_rt_wr_attrib_mem_hdl(struct oid_par_priv *poid_par_priv) 810 { 811 if (poid_par_priv->type_of_oid != SET_OID) 812 return RNDIS_STATUS_NOT_ACCEPTED; 813 return RNDIS_STATUS_SUCCESS; 814 } 815 816 uint oid_rt_pro_set_rf_intfs_hdl(struct oid_par_priv *poid_par_priv) 817 { 818 struct _adapter *Adapter = (struct _adapter *) 819 (poid_par_priv->adapter_context); 820 uint status = RNDIS_STATUS_SUCCESS; 821 822 if (poid_par_priv->type_of_oid != SET_OID) 823 return RNDIS_STATUS_NOT_ACCEPTED; 824 if (r8712_setrfintfs_cmd(Adapter, *(unsigned char *) 825 poid_par_priv->information_buf) == _FAIL) 826 status = RNDIS_STATUS_NOT_ACCEPTED; 827 return status; 828 } 829 830 uint oid_rt_poll_rx_status_hdl(struct oid_par_priv *poid_par_priv) 831 { 832 struct _adapter *Adapter = (struct _adapter *) 833 (poid_par_priv->adapter_context); 834 835 if (poid_par_priv->type_of_oid != QUERY_OID) 836 return RNDIS_STATUS_NOT_ACCEPTED; 837 memcpy(poid_par_priv->information_buf, 838 (unsigned char *)&Adapter->mppriv.rxstat, 839 sizeof(struct recv_stat)); 840 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 841 return RNDIS_STATUS_SUCCESS; 842 } 843 844 uint oid_rt_pro_cfg_debug_message_hdl(struct oid_par_priv 845 *poid_par_priv) 846 { 847 return RNDIS_STATUS_SUCCESS; 848 } 849 850 uint oid_rt_pro_set_data_rate_ex_hdl(struct oid_par_priv 851 *poid_par_priv) 852 { 853 struct _adapter *Adapter = (struct _adapter *) 854 (poid_par_priv->adapter_context); 855 uint status = RNDIS_STATUS_SUCCESS; 856 857 if (poid_par_priv->type_of_oid != SET_OID) 858 return RNDIS_STATUS_NOT_ACCEPTED; 859 if (r8712_setdatarate_cmd(Adapter, 860 poid_par_priv->information_buf) != _SUCCESS) 861 status = RNDIS_STATUS_NOT_ACCEPTED; 862 return status; 863 } 864 865 uint oid_rt_get_thermal_meter_hdl(struct oid_par_priv *poid_par_priv) 866 { 867 struct _adapter *Adapter = (struct _adapter *) 868 (poid_par_priv->adapter_context); 869 870 if (poid_par_priv->type_of_oid != QUERY_OID) 871 return RNDIS_STATUS_NOT_ACCEPTED; 872 873 if (Adapter->mppriv.act_in_progress == true) 874 return RNDIS_STATUS_NOT_ACCEPTED; 875 876 if (poid_par_priv->information_buf_len < sizeof(u8)) 877 return RNDIS_STATUS_INVALID_LENGTH; 878 /*init workparam*/ 879 Adapter->mppriv.act_in_progress = true; 880 Adapter->mppriv.workparam.bcompleted = false; 881 Adapter->mppriv.workparam.act_type = MPT_GET_THERMAL_METER; 882 Adapter->mppriv.workparam.io_offset = 0; 883 Adapter->mppriv.workparam.io_value = 0xFFFFFFFF; 884 r8712_GetThermalMeter(Adapter, &Adapter->mppriv.workparam.io_value); 885 Adapter->mppriv.workparam.bcompleted = true; 886 Adapter->mppriv.act_in_progress = false; 887 *(u32 *)poid_par_priv->information_buf = 888 Adapter->mppriv.workparam.io_value; 889 *poid_par_priv->bytes_rw = sizeof(u32); 890 return RNDIS_STATUS_SUCCESS; 891 } 892 893 uint oid_rt_pro_set_power_tracking_hdl(struct oid_par_priv 894 *poid_par_priv) 895 { 896 struct _adapter *Adapter = (struct _adapter *) 897 (poid_par_priv->adapter_context); 898 uint status = RNDIS_STATUS_SUCCESS; 899 900 if (poid_par_priv->type_of_oid != SET_OID) 901 return RNDIS_STATUS_NOT_ACCEPTED; 902 if (poid_par_priv->information_buf_len < sizeof(u8)) 903 return RNDIS_STATUS_INVALID_LENGTH; 904 if (!r8712_setptm_cmd(Adapter, *((u8 *)poid_par_priv->information_buf))) 905 status = RNDIS_STATUS_NOT_ACCEPTED; 906 return status; 907 } 908 909 uint oid_rt_pro_set_basic_rate_hdl(struct oid_par_priv *poid_par_priv) 910 { 911 struct _adapter *Adapter = (struct _adapter *) 912 (poid_par_priv->adapter_context); 913 u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff}; 914 uint status = RNDIS_STATUS_SUCCESS; 915 u32 ratevalue; 916 u8 datarates[NumRates]; 917 int i; 918 919 if (poid_par_priv->type_of_oid != SET_OID) 920 return RNDIS_STATUS_NOT_ACCEPTED; 921 ratevalue = *((u32 *)poid_par_priv->information_buf); 922 for (i = 0; i < NumRates; i++) { 923 if (ratevalue == mpdatarate[i]) 924 datarates[i] = mpdatarate[i]; 925 else 926 datarates[i] = 0xff; 927 } 928 if (r8712_setbasicrate_cmd(Adapter, datarates) != _SUCCESS) 929 status = RNDIS_STATUS_NOT_ACCEPTED; 930 return status; 931 } 932 933 uint oid_rt_pro_qry_pwrstate_hdl(struct oid_par_priv *poid_par_priv) 934 { 935 struct _adapter *Adapter = (struct _adapter *) 936 (poid_par_priv->adapter_context); 937 938 if (poid_par_priv->type_of_oid != QUERY_OID) 939 return RNDIS_STATUS_NOT_ACCEPTED; 940 if (poid_par_priv->information_buf_len < 8) 941 return RNDIS_STATUS_INVALID_LENGTH; 942 *poid_par_priv->bytes_rw = 8; 943 memcpy(poid_par_priv->information_buf, 944 &(Adapter->pwrctrlpriv.pwr_mode), 8); 945 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 946 return RNDIS_STATUS_SUCCESS; 947 } 948 949 uint oid_rt_pro_set_pwrstate_hdl(struct oid_par_priv *poid_par_priv) 950 { 951 struct _adapter *Adapter = (struct _adapter *) 952 (poid_par_priv->adapter_context); 953 uint pwr_mode, smart_ps; 954 955 if (poid_par_priv->type_of_oid != SET_OID) 956 return RNDIS_STATUS_NOT_ACCEPTED; 957 *poid_par_priv->bytes_rw = 0; 958 *poid_par_priv->bytes_needed = 8; 959 if (poid_par_priv->information_buf_len < 8) 960 return RNDIS_STATUS_INVALID_LENGTH; 961 pwr_mode = *(uint *)(poid_par_priv->information_buf); 962 smart_ps = *(uint *)((addr_t)poid_par_priv->information_buf + 4); 963 if (pwr_mode != Adapter->pwrctrlpriv.pwr_mode || smart_ps != 964 Adapter->pwrctrlpriv.smart_ps) 965 r8712_set_ps_mode(Adapter, pwr_mode, smart_ps); 966 *poid_par_priv->bytes_rw = 8; 967 return RNDIS_STATUS_SUCCESS; 968 } 969 970 uint oid_rt_pro_h2c_set_rate_table_hdl(struct oid_par_priv 971 *poid_par_priv) 972 { 973 struct _adapter *Adapter = (struct _adapter *) 974 (poid_par_priv->adapter_context); 975 uint status = RNDIS_STATUS_SUCCESS; 976 struct setratable_parm *prate_table; 977 u8 res; 978 979 if (poid_par_priv->type_of_oid != SET_OID) 980 return RNDIS_STATUS_NOT_ACCEPTED; 981 *poid_par_priv->bytes_needed = sizeof(struct setratable_parm); 982 if (poid_par_priv->information_buf_len < 983 sizeof(struct setratable_parm)) 984 return RNDIS_STATUS_INVALID_LENGTH; 985 prate_table = (struct setratable_parm *)poid_par_priv->information_buf; 986 res = r8712_setrttbl_cmd(Adapter, prate_table); 987 if (res == _FAIL) 988 status = RNDIS_STATUS_FAILURE; 989 return status; 990 } 991 992 uint oid_rt_pro_h2c_get_rate_table_hdl(struct oid_par_priv 993 *poid_par_priv) 994 { 995 if (poid_par_priv->type_of_oid != QUERY_OID) 996 return RNDIS_STATUS_NOT_ACCEPTED; 997 return RNDIS_STATUS_SUCCESS; 998 } 999 1000 uint oid_rt_pro_encryption_ctrl_hdl(struct oid_par_priv 1001 *poid_par_priv) 1002 { 1003 struct _adapter *Adapter = (struct _adapter *) 1004 (poid_par_priv->adapter_context); 1005 struct security_priv *psecuritypriv = &Adapter->securitypriv; 1006 enum ENCRY_CTRL_STATE encry_mode = 0; 1007 1008 *poid_par_priv->bytes_needed = sizeof(u8); 1009 if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed) 1010 return RNDIS_STATUS_INVALID_LENGTH; 1011 1012 if (poid_par_priv->type_of_oid == SET_OID) { 1013 encry_mode = *((u8 *)poid_par_priv->information_buf); 1014 switch (encry_mode) { 1015 case HW_CONTROL: 1016 psecuritypriv->sw_decrypt = false; 1017 psecuritypriv->sw_encrypt = false; 1018 break; 1019 case SW_CONTROL: 1020 psecuritypriv->sw_decrypt = true; 1021 psecuritypriv->sw_encrypt = true; 1022 break; 1023 case HW_ENCRY_SW_DECRY: 1024 psecuritypriv->sw_decrypt = true; 1025 psecuritypriv->sw_encrypt = false; 1026 break; 1027 case SW_ENCRY_HW_DECRY: 1028 psecuritypriv->sw_decrypt = false; 1029 psecuritypriv->sw_encrypt = true; 1030 break; 1031 } 1032 } else { 1033 if ((psecuritypriv->sw_encrypt == false) && 1034 (psecuritypriv->sw_decrypt == false)) 1035 encry_mode = HW_CONTROL; 1036 else if ((psecuritypriv->sw_encrypt == false) && 1037 (psecuritypriv->sw_decrypt == true)) 1038 encry_mode = HW_ENCRY_SW_DECRY; 1039 else if ((psecuritypriv->sw_encrypt == true) && 1040 (psecuritypriv->sw_decrypt == false)) 1041 encry_mode = SW_ENCRY_HW_DECRY; 1042 else if ((psecuritypriv->sw_encrypt == true) && 1043 (psecuritypriv->sw_decrypt == true)) 1044 encry_mode = SW_CONTROL; 1045 *(u8 *)poid_par_priv->information_buf = encry_mode; 1046 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 1047 } 1048 return RNDIS_STATUS_SUCCESS; 1049 } 1050 /*----------------------------------------------------------------------*/ 1051 uint oid_rt_pro_add_sta_info_hdl(struct oid_par_priv *poid_par_priv) 1052 { 1053 struct _adapter *Adapter = (struct _adapter *) 1054 (poid_par_priv->adapter_context); 1055 1056 uint status = RNDIS_STATUS_SUCCESS; 1057 1058 struct sta_info *psta = NULL; 1059 u8 *macaddr; 1060 1061 1062 if (poid_par_priv->type_of_oid != SET_OID) 1063 return RNDIS_STATUS_NOT_ACCEPTED; 1064 1065 *poid_par_priv->bytes_needed = ETH_ALEN; 1066 if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed) 1067 return RNDIS_STATUS_INVALID_LENGTH; 1068 macaddr = (u8 *) poid_par_priv->information_buf; 1069 psta = r8712_get_stainfo(&Adapter->stapriv, macaddr); 1070 if (psta == NULL) { /* the sta in sta_info_queue => do nothing*/ 1071 psta = r8712_alloc_stainfo(&Adapter->stapriv, macaddr); 1072 if (psta == NULL) 1073 status = RNDIS_STATUS_FAILURE; 1074 } 1075 return status; 1076 } 1077 /*-------------------------------------------------------------------------*/ 1078 uint oid_rt_pro_dele_sta_info_hdl(struct oid_par_priv *poid_par_priv) 1079 { 1080 struct _adapter *Adapter = (struct _adapter *) 1081 (poid_par_priv->adapter_context); 1082 1083 unsigned long irqL; 1084 1085 struct sta_info *psta = NULL; 1086 u8 *macaddr; 1087 1088 1089 if (poid_par_priv->type_of_oid != SET_OID) 1090 return RNDIS_STATUS_NOT_ACCEPTED; 1091 1092 *poid_par_priv->bytes_needed = ETH_ALEN; 1093 if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed) 1094 return RNDIS_STATUS_INVALID_LENGTH; 1095 1096 macaddr = (u8 *)poid_par_priv->information_buf; 1097 1098 psta = r8712_get_stainfo(&Adapter->stapriv, macaddr); 1099 if (psta != NULL) { 1100 spin_lock_irqsave(&(Adapter->stapriv.sta_hash_lock), irqL); 1101 r8712_free_stainfo(Adapter, psta); 1102 spin_unlock_irqrestore(&(Adapter->stapriv.sta_hash_lock), irqL); 1103 } 1104 1105 return RNDIS_STATUS_SUCCESS; 1106 } 1107 /*--------------------------------------------------------------------------*/ 1108 static u32 mp_query_drv_var(struct _adapter *padapter, u8 offset, u32 var) 1109 { 1110 return var; 1111 } 1112 1113 uint oid_rt_pro_query_dr_variable_hdl(struct oid_par_priv *poid_par_priv) 1114 { 1115 struct _adapter *Adapter = (struct _adapter *) 1116 (poid_par_priv->adapter_context); 1117 1118 struct DR_VARIABLE_STRUCT *pdrv_var; 1119 1120 if (poid_par_priv->type_of_oid != QUERY_OID) 1121 return RNDIS_STATUS_NOT_ACCEPTED; 1122 *poid_par_priv->bytes_needed = sizeof(struct DR_VARIABLE_STRUCT); 1123 if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed) 1124 return RNDIS_STATUS_INVALID_LENGTH; 1125 pdrv_var = (struct DR_VARIABLE_STRUCT *)poid_par_priv->information_buf; 1126 pdrv_var->variable = mp_query_drv_var(Adapter, pdrv_var->offset, 1127 pdrv_var->variable); 1128 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 1129 return RNDIS_STATUS_SUCCESS; 1130 } 1131 1132 /*--------------------------------------------------------------------------*/ 1133 uint oid_rt_pro_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv) 1134 { 1135 return RNDIS_STATUS_SUCCESS; 1136 } 1137 /*------------------------------------------------------------------------*/ 1138 uint oid_rt_pro_read_efuse_hdl(struct oid_par_priv *poid_par_priv) 1139 { 1140 struct _adapter *Adapter = (struct _adapter *) 1141 (poid_par_priv->adapter_context); 1142 1143 uint status = RNDIS_STATUS_SUCCESS; 1144 1145 struct EFUSE_ACCESS_STRUCT *pefuse; 1146 u8 *data; 1147 u16 addr = 0, cnts = 0; 1148 1149 if (poid_par_priv->type_of_oid != QUERY_OID) 1150 return RNDIS_STATUS_NOT_ACCEPTED; 1151 if (poid_par_priv->information_buf_len < 1152 sizeof(struct EFUSE_ACCESS_STRUCT)) 1153 return RNDIS_STATUS_INVALID_LENGTH; 1154 pefuse = (struct EFUSE_ACCESS_STRUCT *)poid_par_priv->information_buf; 1155 addr = pefuse->start_addr; 1156 cnts = pefuse->cnts; 1157 data = pefuse->data; 1158 memset(data, 0xFF, cnts); 1159 if ((addr > 511) || (cnts < 1) || (cnts > 512) || (addr + cnts) > 1160 EFUSE_MAX_SIZE) 1161 return RNDIS_STATUS_NOT_ACCEPTED; 1162 if (r8712_efuse_access(Adapter, true, addr, cnts, data) == false) 1163 status = RNDIS_STATUS_FAILURE; 1164 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 1165 return status; 1166 } 1167 /*------------------------------------------------------------------------*/ 1168 uint oid_rt_pro_write_efuse_hdl(struct oid_par_priv *poid_par_priv) 1169 { 1170 struct _adapter *Adapter = (struct _adapter *) 1171 (poid_par_priv->adapter_context); 1172 1173 uint status = RNDIS_STATUS_SUCCESS; 1174 1175 struct EFUSE_ACCESS_STRUCT *pefuse; 1176 u8 *data; 1177 u16 addr = 0, cnts = 0; 1178 1179 if (poid_par_priv->type_of_oid != SET_OID) 1180 return RNDIS_STATUS_NOT_ACCEPTED; 1181 1182 pefuse = (struct EFUSE_ACCESS_STRUCT *)poid_par_priv->information_buf; 1183 addr = pefuse->start_addr; 1184 cnts = pefuse->cnts; 1185 data = pefuse->data; 1186 1187 if ((addr > 511) || (cnts < 1) || (cnts > 512) || 1188 (addr + cnts) > r8712_efuse_get_max_size(Adapter)) 1189 return RNDIS_STATUS_NOT_ACCEPTED; 1190 if (r8712_efuse_access(Adapter, false, addr, cnts, data) == false) 1191 status = RNDIS_STATUS_FAILURE; 1192 return status; 1193 } 1194 /*----------------------------------------------------------------------*/ 1195 uint oid_rt_pro_rw_efuse_pgpkt_hdl(struct oid_par_priv *poid_par_priv) 1196 { 1197 struct _adapter *Adapter = (struct _adapter *) 1198 (poid_par_priv->adapter_context); 1199 uint status = RNDIS_STATUS_SUCCESS; 1200 struct PGPKT_STRUCT *ppgpkt; 1201 1202 *poid_par_priv->bytes_rw = 0; 1203 if (poid_par_priv->information_buf_len < sizeof(struct PGPKT_STRUCT)) 1204 return RNDIS_STATUS_INVALID_LENGTH; 1205 ppgpkt = (struct PGPKT_STRUCT *)poid_par_priv->information_buf; 1206 if (poid_par_priv->type_of_oid == QUERY_OID) { 1207 if (r8712_efuse_pg_packet_read(Adapter, ppgpkt->offset, 1208 ppgpkt->data) == true) 1209 *poid_par_priv->bytes_rw = 1210 poid_par_priv->information_buf_len; 1211 else 1212 status = RNDIS_STATUS_FAILURE; 1213 } else { 1214 if (r8712_efuse_reg_init(Adapter) == true) { 1215 if (r8712_efuse_pg_packet_write(Adapter, ppgpkt->offset, 1216 ppgpkt->word_en, ppgpkt->data) == true) 1217 *poid_par_priv->bytes_rw = 1218 poid_par_priv->information_buf_len; 1219 else 1220 status = RNDIS_STATUS_FAILURE; 1221 r8712_efuse_reg_uninit(Adapter); 1222 } else 1223 status = RNDIS_STATUS_FAILURE; 1224 } 1225 return status; 1226 } 1227 1228 uint oid_rt_get_efuse_current_size_hdl(struct oid_par_priv 1229 *poid_par_priv) 1230 { 1231 struct _adapter *Adapter = (struct _adapter *) 1232 (poid_par_priv->adapter_context); 1233 1234 if (poid_par_priv->type_of_oid != QUERY_OID) 1235 return RNDIS_STATUS_NOT_ACCEPTED; 1236 if (poid_par_priv->information_buf_len < sizeof(int)) 1237 return RNDIS_STATUS_INVALID_LENGTH; 1238 r8712_efuse_reg_init(Adapter); 1239 *(int *)poid_par_priv->information_buf = 1240 r8712_efuse_get_current_size(Adapter); 1241 r8712_efuse_reg_uninit(Adapter); 1242 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 1243 return RNDIS_STATUS_SUCCESS; 1244 } 1245 1246 uint oid_rt_get_efuse_max_size_hdl(struct oid_par_priv *poid_par_priv) 1247 { 1248 struct _adapter *Adapter = (struct _adapter *) 1249 (poid_par_priv->adapter_context); 1250 1251 if (poid_par_priv->type_of_oid != QUERY_OID) 1252 return RNDIS_STATUS_NOT_ACCEPTED; 1253 if (poid_par_priv->information_buf_len < sizeof(u32)) 1254 return RNDIS_STATUS_INVALID_LENGTH; 1255 *(int *)poid_par_priv->information_buf = 1256 r8712_efuse_get_max_size(Adapter); 1257 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 1258 return RNDIS_STATUS_SUCCESS; 1259 } 1260 1261 uint oid_rt_pro_efuse_hdl(struct oid_par_priv *poid_par_priv) 1262 { 1263 uint status = RNDIS_STATUS_SUCCESS; 1264 1265 if (poid_par_priv->type_of_oid == QUERY_OID) 1266 status = oid_rt_pro_read_efuse_hdl(poid_par_priv); 1267 else 1268 status = oid_rt_pro_write_efuse_hdl(poid_par_priv); 1269 return status; 1270 } 1271 1272 uint oid_rt_pro_efuse_map_hdl(struct oid_par_priv *poid_par_priv) 1273 { 1274 struct _adapter *Adapter = (struct _adapter *) 1275 (poid_par_priv->adapter_context); 1276 uint status = RNDIS_STATUS_SUCCESS; 1277 u8 *data; 1278 1279 *poid_par_priv->bytes_rw = 0; 1280 if (poid_par_priv->information_buf_len < EFUSE_MAP_MAX_SIZE) 1281 return RNDIS_STATUS_INVALID_LENGTH; 1282 data = (u8 *)poid_par_priv->information_buf; 1283 if (poid_par_priv->type_of_oid == QUERY_OID) { 1284 if (r8712_efuse_map_read(Adapter, 0, EFUSE_MAP_MAX_SIZE, data)) 1285 *poid_par_priv->bytes_rw = EFUSE_MAP_MAX_SIZE; 1286 else 1287 status = RNDIS_STATUS_FAILURE; 1288 } else { 1289 /* SET_OID */ 1290 if (r8712_efuse_reg_init(Adapter) == true) { 1291 if (r8712_efuse_map_write(Adapter, 0, 1292 EFUSE_MAP_MAX_SIZE, data)) 1293 *poid_par_priv->bytes_rw = EFUSE_MAP_MAX_SIZE; 1294 else 1295 status = RNDIS_STATUS_FAILURE; 1296 r8712_efuse_reg_uninit(Adapter); 1297 } else { 1298 status = RNDIS_STATUS_FAILURE; 1299 } 1300 } 1301 return status; 1302 } 1303 1304 uint oid_rt_set_bandwidth_hdl(struct oid_par_priv *poid_par_priv) 1305 { 1306 struct _adapter *Adapter = (struct _adapter *) 1307 (poid_par_priv->adapter_context); 1308 u32 bandwidth; 1309 1310 if (poid_par_priv->type_of_oid != SET_OID) 1311 return RNDIS_STATUS_NOT_ACCEPTED; 1312 if (poid_par_priv->information_buf_len < sizeof(u32)) 1313 return RNDIS_STATUS_INVALID_LENGTH; 1314 bandwidth = *((u32 *)poid_par_priv->information_buf);/*4*/ 1315 if (bandwidth != HT_CHANNEL_WIDTH_20) 1316 bandwidth = HT_CHANNEL_WIDTH_40; 1317 Adapter->mppriv.curr_bandwidth = (u8)bandwidth; 1318 r8712_SwitchBandwidth(Adapter); 1319 return RNDIS_STATUS_SUCCESS; 1320 } 1321 1322 uint oid_rt_set_crystal_cap_hdl(struct oid_par_priv *poid_par_priv) 1323 { 1324 struct _adapter *Adapter = (struct _adapter *) 1325 (poid_par_priv->adapter_context); 1326 u32 crystal_cap = 0; 1327 1328 if (poid_par_priv->type_of_oid != SET_OID) 1329 return RNDIS_STATUS_NOT_ACCEPTED; 1330 if (poid_par_priv->information_buf_len < sizeof(u32)) 1331 return RNDIS_STATUS_INVALID_LENGTH; 1332 crystal_cap = *((u32 *)poid_par_priv->information_buf);/*4*/ 1333 if (crystal_cap > 0xf) 1334 return RNDIS_STATUS_NOT_ACCEPTED; 1335 Adapter->mppriv.curr_crystalcap = crystal_cap; 1336 r8712_SetCrystalCap(Adapter); 1337 return RNDIS_STATUS_SUCCESS; 1338 } 1339 1340 uint oid_rt_set_rx_packet_type_hdl(struct oid_par_priv 1341 *poid_par_priv) 1342 { 1343 struct _adapter *Adapter = (struct _adapter *) 1344 (poid_par_priv->adapter_context); 1345 u8 rx_pkt_type; 1346 u32 rcr_val32; 1347 1348 if (poid_par_priv->type_of_oid != SET_OID) 1349 return RNDIS_STATUS_NOT_ACCEPTED; 1350 if (poid_par_priv->information_buf_len < sizeof(u8)) 1351 return RNDIS_STATUS_INVALID_LENGTH; 1352 rx_pkt_type = *((u8 *)poid_par_priv->information_buf);/*4*/ 1353 rcr_val32 = r8712_read32(Adapter, RCR);/*RCR = 0x10250048*/ 1354 rcr_val32 &= ~(RCR_CBSSID | RCR_AB | RCR_AM | RCR_APM | RCR_AAP); 1355 switch (rx_pkt_type) { 1356 case RX_PKT_BROADCAST: 1357 rcr_val32 |= (RCR_AB | RCR_AM | RCR_APM | RCR_AAP | RCR_ACRC32); 1358 break; 1359 case RX_PKT_DEST_ADDR: 1360 rcr_val32 |= (RCR_AB | RCR_AM | RCR_APM | RCR_AAP | RCR_ACRC32); 1361 break; 1362 case RX_PKT_PHY_MATCH: 1363 rcr_val32 |= (RCR_APM|RCR_ACRC32); 1364 break; 1365 default: 1366 rcr_val32 &= ~(RCR_AAP | 1367 RCR_APM | 1368 RCR_AM | 1369 RCR_AB | 1370 RCR_ACRC32); 1371 break; 1372 } 1373 if (rx_pkt_type == RX_PKT_DEST_ADDR) 1374 Adapter->mppriv.check_mp_pkt = 1; 1375 else 1376 Adapter->mppriv.check_mp_pkt = 0; 1377 r8712_write32(Adapter, RCR, rcr_val32); 1378 return RNDIS_STATUS_SUCCESS; 1379 } 1380 1381 uint oid_rt_pro_set_tx_agc_offset_hdl(struct oid_par_priv 1382 *poid_par_priv) 1383 { 1384 struct _adapter *Adapter = (struct _adapter *) 1385 (poid_par_priv->adapter_context); 1386 u32 txagc; 1387 1388 if (poid_par_priv->type_of_oid != SET_OID) 1389 return RNDIS_STATUS_NOT_ACCEPTED; 1390 if (poid_par_priv->information_buf_len < sizeof(u32)) 1391 return RNDIS_STATUS_INVALID_LENGTH; 1392 txagc = *(u32 *)poid_par_priv->information_buf; 1393 r8712_SetTxAGCOffset(Adapter, txagc); 1394 return RNDIS_STATUS_SUCCESS; 1395 } 1396 1397 uint oid_rt_pro_set_pkt_test_mode_hdl(struct oid_par_priv 1398 *poid_par_priv) 1399 { 1400 struct _adapter *Adapter = (struct _adapter *) 1401 (poid_par_priv->adapter_context); 1402 uint status = RNDIS_STATUS_SUCCESS; 1403 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv; 1404 struct mp_priv *pmppriv = &Adapter->mppriv; 1405 u32 type; 1406 1407 if (poid_par_priv->type_of_oid != SET_OID) 1408 return RNDIS_STATUS_NOT_ACCEPTED; 1409 1410 if (poid_par_priv->information_buf_len < sizeof(u32)) 1411 return RNDIS_STATUS_INVALID_LENGTH; 1412 1413 type = *(u32 *)poid_par_priv->information_buf; 1414 1415 if (_LOOPBOOK_MODE_ == type) { 1416 pmppriv->mode = type; 1417 set_fwstate(pmlmepriv, WIFI_MP_LPBK_STATE); /*append txdesc*/ 1418 } else if (_2MAC_MODE_ == type) { 1419 pmppriv->mode = type; 1420 _clr_fwstate_(pmlmepriv, WIFI_MP_LPBK_STATE); 1421 } else 1422 status = RNDIS_STATUS_NOT_ACCEPTED; 1423 return status; 1424 } 1425 /*--------------------------------------------------------------------------*/ 1426 /*Linux*/ 1427 unsigned int mp_ioctl_xmit_packet_hdl(struct oid_par_priv *poid_par_priv) 1428 { 1429 return _SUCCESS; 1430 } 1431 /*-------------------------------------------------------------------------*/ 1432 uint oid_rt_set_power_down_hdl(struct oid_par_priv *poid_par_priv) 1433 { 1434 if (poid_par_priv->type_of_oid != SET_OID) 1435 return RNDIS_STATUS_NOT_ACCEPTED; 1436 /*CALL the power_down function*/ 1437 return RNDIS_STATUS_SUCCESS; 1438 } 1439 1440 /*-------------------------------------------------------------------------- */ 1441 uint oid_rt_get_power_mode_hdl(struct oid_par_priv *poid_par_priv) 1442 { 1443 struct _adapter *Adapter = (struct _adapter *) 1444 (poid_par_priv->adapter_context); 1445 1446 if (poid_par_priv->type_of_oid != QUERY_OID) 1447 return RNDIS_STATUS_NOT_ACCEPTED; 1448 if (poid_par_priv->information_buf_len < sizeof(u32)) 1449 return RNDIS_STATUS_INVALID_LENGTH; 1450 *(int *)poid_par_priv->information_buf = 1451 Adapter->registrypriv.low_power ? POWER_LOW : POWER_NORMAL; 1452 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len; 1453 return RNDIS_STATUS_SUCCESS; 1454 } 1455