← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/staging/rtl8712/rtl871x_mp_ioctl.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/rtl8712/rtl871x_mp_ioctl.c
 
1
/******************************************************************************
 
2
 * rtl871x_mp_ioctl.c
 
3
 *
 
4
 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
 
5
 * Linux device driver for RTL8192SU
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify it
 
8
 * under the terms of version 2 of the GNU General Public License as
 
9
 * published by the Free Software Foundation.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful, but WITHOUT
 
12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 
14
 * more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License along with
 
17
 * this program; if not, write to the Free Software Foundation, Inc.,
 
18
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 
19
 *
 
20
 * Modifications for inclusion into the Linux staging tree are
 
21
 * Copyright(c) 2010 Larry Finger. All rights reserved.
 
22
 *
 
23
 * Contact information:
 
24
 * WLAN FAE <wlanfae@realtek.com>
 
25
 * Larry Finger <Larry.Finger@lwfinger.net>
 
26
 *
 
27
 ******************************************************************************/
 
28
 
 
29
#include "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
 
 
35
uint oid_null_function(struct oid_par_priv *poid_par_priv)
 
36
{
 
37
        return NDIS_STATUS_SUCCESS;
 
38
}
 
39
 
 
40
uint 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
 
 
66
uint 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; /*0ffset :0x800~0xfff*/
 
81
        if (offset < BB_REG_BASE_ADDR)
 
82
                offset |= BB_REG_BASE_ADDR;
 
83
        value = pbbreg->value;
 
84
        r8712_bb_reg_write(Adapter, offset, value);
 
85
        return status;
 
86
}
 
87
 
 
88
uint 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; /*0ffset :0x800~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
 
 
111
uint 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
 
 
135
uint 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) /* 1T2R  path_a /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
/*This function initializes the DUT to the MP test mode*/
 
161
static 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
        /* 3 1. initialize a new struct ndis_wlan_bssid_ex */
 
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
                /*round up to multiple of 4 bytes.*/
 
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
        /*init mp_start_test status*/
 
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); /*append txdesc*/
 
194
        set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
 
195
        /* 3 2. create a new psta for mp driver */
 
196
        /* clear psta in the cur_network, if any */
 
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
        /* 3 3. join psudo AdHoc */
 
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
        /* Set to LINKED STATE for MP TRX Testing */
 
213
        set_fwstate(pmlmepriv, _FW_LINKED);
 
214
end_of_mp_start_test:
 
215
        spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
 
216
        return res;
 
217
}
 
218
 
 
219
/*This function change the DUT from the MP test mode into normal mode */
 
220
static 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
        /* 3 1. disconnect psudo AdHoc */
 
232
        r8712_os_indicate_disconnect(padapter);
 
233
        /* 3 2. clear psta used in mp test mode. */
 
234
        psta = r8712_get_stainfo(&padapter->stapriv,
 
235
                                 tgt_network->network.MacAddress);
 
236
        if (psta)
 
237
                r8712_free_stainfo(padapter, psta);
 
238
        /* 3 3. return to normal state (default:station mode) */
 
239
        pmlmepriv->fw_state = pmppriv->prev_fw_state; /* WIFI_STATION_STATE;*/
 
240
        /*flush the cur_network*/
 
241
        memset(tgt_network, 0, sizeof(struct wlan_network));
 
242
end_of_mp_stop_test:
 
243
        spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
 
244
        return _SUCCESS;
 
245
}
 
246
 
 
247
int 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
 
 
263
uint 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
 
 
283
uint 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;/* 1 for loopback*/
 
295
        if (mp_start_test(Adapter) == _FAIL)
 
296
                status = NDIS_STATUS_NOT_ACCEPTED;
 
297
        r8712_write8(Adapter, MSR, 1); /* Link in ad hoc network, 0x1025004C */
 
298
        r8712_write8(Adapter, RCR, 0); /* RCR : disable all pkt, 0x10250048 */
 
299
        /* RCR disable Check BSSID, 0x1025004a */
 
300
        r8712_write8(Adapter, RCR+2, 0x57);
 
301
        /* disable RX filter map , mgt frames will put in RX FIFO 0 */
 
302
        r8712_write16(Adapter, RXFLTMAP0, 0x0);
 
303
        val8 = r8712_read8(Adapter, EE_9346CR);
 
304
        if (!(val8 & _9356SEL)) { /*boot from EFUSE*/
 
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
 
 
312
uint 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
 
 
325
uint 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
 
 
345
uint 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
 
 
363
uint 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
 
 
383
uint 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
 
 
403
uint 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
 
 
423
uint 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
 
 
443
uint 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
 
 
455
uint 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
 
 
472
uint 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
 
 
484
uint 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
 
 
500
uint 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
 
 
516
uint 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
 
 
529
uint 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
 
 
543
uint 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
 
 
557
uint 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
 
 
571
uint 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
 
 
585
uint 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
 
 
605
uint 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
                /*baseband register*/
 
620
                /*0ffset :0x800~0xfff*/
 
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
 
 
646
uint 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
                /*baseband register*/
 
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
 
 
706
uint 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
 
 
722
uint 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
 
 
737
uint oid_rt_pro_write_txcmd_hdl(struct oid_par_priv *poid_par_priv)
 
738
{
 
739
        return NDIS_STATUS_SUCCESS;
 
740
}
 
741
 
 
742
uint 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
 
 
757
uint 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
 
 
772
uint 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
 
 
792
uint 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
 
 
809
uint 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
 
 
816
uint 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
 
 
823
uint 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
 
 
837
uint 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
 
 
852
uint oid_rt_pro_cfg_debug_message_hdl(struct oid_par_priv
 
853
                                             *poid_par_priv)
 
854
{
 
855
        return NDIS_STATUS_SUCCESS;
 
856
}
 
857
 
 
858
uint 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
 
 
873
uint 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
        /*init workparam*/
 
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
 
 
902
uint 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
 
 
918
uint 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
 
 
942
uint 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
 
 
958
uint 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
 
 
979
uint 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
 
 
1001
uint 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
 
 
1009
uint 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
/*----------------------------------------------------------------------*/
 
1060
uint 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) { /* the sta in sta_info_queue => do nothing*/
 
1080
                psta = r8712_alloc_stainfo(&Adapter->stapriv, macaddr);
 
1081
                if (psta == NULL)
 
1082
                        status = NDIS_STATUS_FAILURE;
 
1083
        }
 
1084
        return status;
 
1085
}
 
1086
/*-------------------------------------------------------------------------*/
 
1087
uint 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
/*--------------------------------------------------------------------------*/
 
1118
static u32 mp_query_drv_var(struct _adapter *padapter, u8 offset, u32 var)
 
1119
{
 
1120
        return var;
 
1121
}
 
1122
 
 
1123
uint 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
/*--------------------------------------------------------------------------*/
 
1145
uint oid_rt_pro_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv)
 
1146
{
 
1147
        return NDIS_STATUS_SUCCESS;
 
1148
}
 
1149
/*------------------------------------------------------------------------*/
 
1150
uint 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
/*------------------------------------------------------------------------*/
 
1180
uint 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
/*----------------------------------------------------------------------*/
 
1207
uint 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
 
 
1240
uint 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
 
 
1259
uint 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
 
 
1275
uint 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
 
 
1286
uint 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
                /* SET_OID */
 
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
 
 
1318
uint 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);/*4*/
 
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
 
 
1337
uint 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);/*4*/
 
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
 
 
1356
uint 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);/*4*/
 
1369
        rcr_val32 = r8712_read32(Adapter, RCR);/*RCR = 0x10250048*/
 
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
 
 
1397
uint 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
 
 
1413
uint 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); /*append txdesc*/
 
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
/*Linux*/
 
1443
unsigned int mp_ioctl_xmit_packet_hdl(struct oid_par_priv *poid_par_priv)
 
1444
{
 
1445
        return _SUCCESS;
 
1446
}
 
1447
/*-------------------------------------------------------------------------*/
 
1448
uint 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
        /*CALL  the power_down function*/
 
1456
        return NDIS_STATUS_SUCCESS;
 
1457
}
 
1458
 
 
1459
/*-------------------------------------------------------------------------- */
 
1460
uint 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
}