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