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