projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge 3.12-rc3 into char-misc-next
[deliverable/linux.git] / drivers / staging / rtl8188eu / core / rtw_mp.c
CommitLineData
7b464c9f
LF		 1/******************************************************************************
2 *
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 *published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20#define _RTW_MP_C_
21
22#include <drv_types.h>
23
24#include "odm_precomp.h"
25#include "rtl8188e_hal.h"
26
27u32 read_macreg(struct adapter *padapter, u32 addr, u32 sz)
28{
29 u32 val = 0;
30
31 switch (sz) {
32 case 1:
33 val = rtw_read8(padapter, addr);
34 break;
35 case 2:
36 val = rtw_read16(padapter, addr);
37 break;
38 case 4:
39 val = rtw_read32(padapter, addr);
40 break;
41 default:
42 val = 0xffffffff;
43 break;
44 }
45
46 return val;
47}
48
49void write_macreg(struct adapter *padapter, u32 addr, u32 val, u32 sz)
50{
51 switch (sz) {
52 case 1:
53 rtw_write8(padapter, addr, (u8)val);
54 break;
55 case 2:
56 rtw_write16(padapter, addr, (u16)val);
57 break;
58 case 4:
59 rtw_write32(padapter, addr, val);
60 break;
61 default:
62 break;
63 }
64}
65
66u32 read_bbreg(struct adapter *padapter, u32 addr, u32 bitmask)
67{
68 return rtw_hal_read_bbreg(padapter, addr, bitmask);
69}
70
71void write_bbreg(struct adapter *padapter, u32 addr, u32 bitmask, u32 val)
72{
73 rtw_hal_write_bbreg(padapter, addr, bitmask, val);
74}
75
76u32 _read_rfreg(struct adapter *padapter, u8 rfpath, u32 addr, u32 bitmask)
77{
78 return rtw_hal_read_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bitmask);
79}
80
81void _write_rfreg(struct adapter *padapter, u8 rfpath, u32 addr, u32 bitmask, u32 val)
82{
83 rtw_hal_write_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bitmask, val);
84}
85
86u32 read_rfreg(struct adapter *padapter, u8 rfpath, u32 addr)
87{
88 return _read_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bRFRegOffsetMask);
89}
90
91void write_rfreg(struct adapter *padapter, u8 rfpath, u32 addr, u32 val)
92{
93 _write_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bRFRegOffsetMask, val);
94}
95
96static void _init_mp_priv_(struct mp_priv *pmp_priv)
97{
98 struct wlan_bssid_ex *pnetwork;
99
100 _rtw_memset(pmp_priv, 0, sizeof(struct mp_priv));
101
102 pmp_priv->mode = MP_OFF;
103
104 pmp_priv->channel = 1;
105 pmp_priv->bandwidth = HT_CHANNEL_WIDTH_20;
106 pmp_priv->prime_channel_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
107 pmp_priv->rateidx = MPT_RATE_1M;
108 pmp_priv->txpoweridx = 0x2A;
109
110 pmp_priv->antenna_tx = ANTENNA_A;
111 pmp_priv->antenna_rx = ANTENNA_AB;
112
113 pmp_priv->check_mp_pkt = 0;
114
115 pmp_priv->tx_pktcount = 0;
116
117 pmp_priv->rx_pktcount = 0;
118 pmp_priv->rx_crcerrpktcount = 0;
119
120 pmp_priv->network_macaddr[0] = 0x00;
121 pmp_priv->network_macaddr[1] = 0xE0;
122 pmp_priv->network_macaddr[2] = 0x4C;
123 pmp_priv->network_macaddr[3] = 0x87;
124 pmp_priv->network_macaddr[4] = 0x66;
125 pmp_priv->network_macaddr[5] = 0x55;
126
127 pnetwork = &pmp_priv->mp_network.network;
128 memcpy(pnetwork->MacAddress, pmp_priv->network_macaddr, ETH_ALEN);
129
130 pnetwork->Ssid.SsidLength = 8;
131 memcpy(pnetwork->Ssid.Ssid, "mp_871x", pnetwork->Ssid.SsidLength);
132}
133
134static void mp_init_xmit_attrib(struct mp_tx *pmptx, struct adapter *padapter)
135{
136 struct pkt_attrib *pattrib;
137 struct tx_desc *desc;
138
139 /* init xmitframe attribute */
140 pattrib = &pmptx->attrib;
141 _rtw_memset(pattrib, 0, sizeof(struct pkt_attrib));
142 desc = &pmptx->desc;
143 _rtw_memset(desc, 0, TXDESC_SIZE);
144
145 pattrib->ether_type = 0x8712;
146 _rtw_memset(pattrib->dst, 0xFF, ETH_ALEN);
147 pattrib->ack_policy = 0;
148 pattrib->hdrlen = WLAN_HDR_A3_LEN;
149 pattrib->subtype = WIFI_DATA;
150 pattrib->priority = 0;
151 pattrib->qsel = pattrib->priority;
152 pattrib->nr_frags = 1;
153 pattrib->encrypt = 0;
154 pattrib->bswenc = false;
155 pattrib->qos_en = false;
156}
157
158s32 init_mp_priv(struct adapter *padapter)
159{
160 struct mp_priv *pmppriv = &padapter->mppriv;
161
162 _init_mp_priv_(pmppriv);
163 pmppriv->papdater = padapter;
164
165 pmppriv->tx.stop = 1;
166 mp_init_xmit_attrib(&pmppriv->tx, padapter);
167
168 switch (padapter->registrypriv.rf_config) {
169 case RF_1T1R:
170 pmppriv->antenna_tx = ANTENNA_A;
171 pmppriv->antenna_rx = ANTENNA_A;
172 break;
173 case RF_1T2R:
174 default:
175 pmppriv->antenna_tx = ANTENNA_A;
176 pmppriv->antenna_rx = ANTENNA_AB;
177 break;
178 case RF_2T2R:
179 case RF_2T2R_GREEN:
180 pmppriv->antenna_tx = ANTENNA_AB;
181 pmppriv->antenna_rx = ANTENNA_AB;
182 break;
183 case RF_2T4R:
184 pmppriv->antenna_tx = ANTENNA_AB;
185 pmppriv->antenna_rx = ANTENNA_ABCD;
186 break;
187 }
188
189 return _SUCCESS;
190}
191
192void free_mp_priv(struct mp_priv *pmp_priv)
193{
194 kfree(pmp_priv->pallocated_mp_xmitframe_buf);
195 pmp_priv->pallocated_mp_xmitframe_buf = NULL;
196 pmp_priv->pmp_xmtframe_buf = NULL;
197}
198
199#define PHY_IQCalibrate(a, b) PHY_IQCalibrate_8188E(a, b)
200#define PHY_LCCalibrate(a) PHY_LCCalibrate_8188E(a)
201#define PHY_SetRFPathSwitch(a, b) PHY_SetRFPathSwitch_8188E(a, b)
202
203s32 MPT_InitializeAdapter(struct adapter *pAdapter, u8 Channel)
204{
205 struct hal_data_8188e *pHalData = GET_HAL_DATA(pAdapter);
206 s32 rtStatus = _SUCCESS;
207 struct mpt_context *pMptCtx = &pAdapter->mppriv.MptCtx;
208 struct mlme_priv *pmlmepriv = &pAdapter->mlmepriv;
209
210 /* HW Initialization for 8190 MPT. */
211 /* SW Initialization for 8190 MP. */
212 pMptCtx->bMptDrvUnload = false;
213 pMptCtx->bMassProdTest = false;
214 pMptCtx->bMptIndexEven = true; /* default gain index is -6.0db */
215 pMptCtx->h2cReqNum = 0x0;
216 /* Init mpt event. */
217 /* init for BT MP */
218
219 pMptCtx->bMptWorkItemInProgress = false;
220 pMptCtx->CurrMptAct = NULL;
221 /* */
222
223 /* Don't accept any packets */
224 rtw_write32(pAdapter, REG_RCR, 0);
225
226 PHY_IQCalibrate(pAdapter, false);
227 dm_CheckTXPowerTracking(&pHalData->odmpriv); /* trigger thermal meter */
228 PHY_LCCalibrate(pAdapter);
229
230 pMptCtx->backup0xc50 = (u8)PHY_QueryBBReg(pAdapter, rOFDM0_XAAGCCore1, bMaskByte0);
231 pMptCtx->backup0xc58 = (u8)PHY_QueryBBReg(pAdapter, rOFDM0_XBAGCCore1, bMaskByte0);
232 pMptCtx->backup0xc30 = (u8)PHY_QueryBBReg(pAdapter, rOFDM0_RxDetector1, bMaskByte0);
233 pMptCtx->backup0x52_RF_A = (u8)PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_0x52, 0x000F0);
234 pMptCtx->backup0x52_RF_B = (u8)PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_0x52, 0x000F0);
235
236 /* set ant to wifi side in mp mode */
237 rtw_write16(pAdapter, 0x870, 0x300);
238 rtw_write16(pAdapter, 0x860, 0x110);
239
240 if (pAdapter->registrypriv.mp_mode == 1)
241 pmlmepriv->fw_state = WIFI_MP_STATE;
242
243 return rtStatus;
244}
245
246/*-----------------------------------------------------------------------------
247 * Function: MPT_DeInitAdapter()
248 *
249 * Overview: Extra DeInitialization for Mass Production Test.
250 *
251 * Input: struct adapter * pAdapter
252 *
253 * Output: NONE
254 *
255 * Return: NONE
256 *
257 * Revised History:
258 * When Who Remark
259 * 05/08/2007 MHC Create Version 0.
260 * 05/18/2007 MHC Add normal driver MPHalt code.
261 *
262 *---------------------------------------------------------------------------*/
263void MPT_DeInitAdapter(struct adapter *pAdapter)
264{
265 struct mpt_context *pMptCtx = &pAdapter->mppriv.MptCtx;
266
267 pMptCtx->bMptDrvUnload = true;
268}
269
270static u8 mpt_ProStartTest(struct adapter *padapter)
271{
272 struct mpt_context *pMptCtx = &padapter->mppriv.MptCtx;
273
274 pMptCtx->bMassProdTest = true;
275 pMptCtx->bStartContTx = false;
276 pMptCtx->bCckContTx = false;
277 pMptCtx->bOfdmContTx = false;
278 pMptCtx->bSingleCarrier = false;
279 pMptCtx->bCarrierSuppression = false;
280 pMptCtx->bSingleTone = false;
281
282 return _SUCCESS;
283}
284
285/*
286 * General use
287 */
288s32 SetPowerTracking(struct adapter *padapter, u8 enable)
289{
290 Hal_SetPowerTracking(padapter, enable);
291 return 0;
292}
293
294void GetPowerTracking(struct adapter *padapter, u8 *enable)
295{
296 Hal_GetPowerTracking(padapter, enable);
297}
298
299static void disable_dm(struct adapter *padapter)
300{
301 u8 v8;
302
303 /* 3 1. disable firmware dynamic mechanism */
304 /* disable Power Training, Rate Adaptive */
305 v8 = rtw_read8(padapter, REG_BCN_CTRL);
306 v8 &= ~EN_BCN_FUNCTION;
307 rtw_write8(padapter, REG_BCN_CTRL, v8);
308
309 /* 3 2. disable driver dynamic mechanism */
310 /* disable Dynamic Initial Gain */
311 /* disable High Power */
312 /* disable Power Tracking */
313 Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, false);
314
315 /* enable APK, LCK and IQK but disable power tracking */
316 Switch_DM_Func(padapter, DYNAMIC_RF_CALIBRATION, true);
317}
318
319/* This function initializes the DUT to the MP test mode */
320s32 mp_start_test(struct adapter *padapter)
321{
322 struct wlan_bssid_ex bssid;
323 struct sta_info *psta;
324 u32 length;
325 u8 val8;
326
327 unsigned long irqL;
328 s32 res = _SUCCESS;
329
330 struct mp_priv *pmppriv = &padapter->mppriv;
331 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
332 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
333
334 padapter->registrypriv.mp_mode = 1;
335 pmppriv->bSetTxPower = 0; /* for manually set tx power */
336
337 /* 3 disable dynamic mechanism */
338 disable_dm(padapter);
339
340 /* 3 0. update mp_priv */
341
342 if (padapter->registrypriv.rf_config == RF_819X_MAX_TYPE) {
343 switch (GET_RF_TYPE(padapter)) {
344 case RF_1T1R:
345 pmppriv->antenna_tx = ANTENNA_A;
346 pmppriv->antenna_rx = ANTENNA_A;
347 break;
348 case RF_1T2R:
349 default:
350 pmppriv->antenna_tx = ANTENNA_A;
351 pmppriv->antenna_rx = ANTENNA_AB;
352 break;
353 case RF_2T2R:
354 case RF_2T2R_GREEN:
355 pmppriv->antenna_tx = ANTENNA_AB;
356 pmppriv->antenna_rx = ANTENNA_AB;
357 break;
358 case RF_2T4R:
359 pmppriv->antenna_tx = ANTENNA_AB;
360 pmppriv->antenna_rx = ANTENNA_ABCD;
361 break;
362 }
363 }
364
365 mpt_ProStartTest(padapter);
366
367 /* 3 1. initialize a new struct wlan_bssid_ex */
368/* _rtw_memset(&bssid, 0, sizeof(struct wlan_bssid_ex)); */
369 memcpy(bssid.MacAddress, pmppriv->network_macaddr, ETH_ALEN);
370 bssid.Ssid.SsidLength = strlen("mp_pseudo_adhoc");
371 memcpy(bssid.Ssid.Ssid, (u8 *)"mp_pseudo_adhoc", bssid.Ssid.SsidLength);
372 bssid.InfrastructureMode = Ndis802_11IBSS;
373 bssid.NetworkTypeInUse = Ndis802_11DS;
374 bssid.IELength = 0;
375
376 length = get_wlan_bssid_ex_sz(&bssid);
377 if (length % 4)
378 bssid.Length = ((length >> 2) + 1) << 2; /* round up to multiple of 4 bytes. */
379 else
380 bssid.Length = length;
381
382 _enter_critical_bh(&pmlmepriv->lock, &irqL);
383
384 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == true)
385 goto end_of_mp_start_test;
386
387 /* init mp_start_test status */
388 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
389 rtw_disassoc_cmd(padapter, 500, true);
390 rtw_indicate_disconnect(padapter);
391 rtw_free_assoc_resources(padapter, 1);
392 }
393 pmppriv->prev_fw_state = get_fwstate(pmlmepriv);
394 if (padapter->registrypriv.mp_mode == 1)
395 pmlmepriv->fw_state = WIFI_MP_STATE;
396 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
397
398 /* 3 2. create a new psta for mp driver */
399 /* clear psta in the cur_network, if any */
400 psta = rtw_get_stainfo(&padapter->stapriv, tgt_network->network.MacAddress);
401 if (psta)
402 rtw_free_stainfo(padapter, psta);
403
404 psta = rtw_alloc_stainfo(&padapter->stapriv, bssid.MacAddress);
405 if (psta == NULL) {
406 RT_TRACE(_module_mp_, _drv_err_, ("mp_start_test: Can't alloc sta_info!\n"));
407 pmlmepriv->fw_state = pmppriv->prev_fw_state;
408 res = _FAIL;
409 goto end_of_mp_start_test;
410 }
411
412 /* 3 3. join psudo AdHoc */
413 tgt_network->join_res = 1;
414 tgt_network->aid = 1;
415 psta->aid = 1;
416 memcpy(&tgt_network->network, &bssid, length);
417
418 rtw_indicate_connect(padapter);
419 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
420
421end_of_mp_start_test:
422
423 _exit_critical_bh(&pmlmepriv->lock, &irqL);
424
425 if (res == _SUCCESS) {
426 /* set MSR to WIFI_FW_ADHOC_STATE */
427 val8 = rtw_read8(padapter, MSR) & 0xFC; /* 0x0102 */
428 val8 |= WIFI_FW_ADHOC_STATE;
429 rtw_write8(padapter, MSR, val8); /* Link in ad hoc network */
430 }
431 return res;
432}
433/* */
434/* This function change the DUT from the MP test mode into normal mode */
435void mp_stop_test(struct adapter *padapter)
436{
437 struct mp_priv *pmppriv = &padapter->mppriv;
438 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
439 struct wlan_network *tgt_network = &pmlmepriv->cur_network;
440 struct sta_info *psta;
441
442 unsigned long irqL;
443
444 if (pmppriv->mode == MP_ON) {
445 pmppriv->bSetTxPower = 0;
446 _enter_critical_bh(&pmlmepriv->lock, &irqL);
447 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)
448 goto end_of_mp_stop_test;
449
450 /* 3 1. disconnect psudo AdHoc */
451 rtw_indicate_disconnect(padapter);
452
453 /* 3 2. clear psta used in mp test mode. */
454 psta = rtw_get_stainfo(&padapter->stapriv, tgt_network->network.MacAddress);
455 if (psta)
456 rtw_free_stainfo(padapter, psta);
457
458 /* 3 3. return to normal state (default:station mode) */
459 pmlmepriv->fw_state = pmppriv->prev_fw_state; /* WIFI_STATION_STATE; */
460
461 /* flush the cur_network */
462 _rtw_memset(tgt_network, 0, sizeof(struct wlan_network));
463
464 _clr_fwstate_(pmlmepriv, WIFI_MP_STATE);
465
466end_of_mp_stop_test:
467
468 _exit_critical_bh(&pmlmepriv->lock, &irqL);
469 }
470}
471
472/*---------------------------hal\rtl8192c\MPT_HelperFunc.c---------------------------*/
473/*
474 * SetChannel
475 * Description
476 * Use H2C command to change channel,
477 * not only modify rf register, but also other setting need to be done.
478 */
479void SetChannel(struct adapter *pAdapter)
480{
481 Hal_SetChannel(pAdapter);
482}
483
484/*
485 * Notice
486 * Switch bandwitdth may change center frequency(channel)
487 */
488void SetBandwidth(struct adapter *pAdapter)
489{
490 Hal_SetBandwidth(pAdapter);
491}
492
493void SetAntenna(struct adapter *pAdapter)
494{
495 Hal_SetAntenna(pAdapter);
496}
497
498void SetAntennaPathPower(struct adapter *pAdapter)
499{
500 Hal_SetAntennaPathPower(pAdapter);
501}
502
503void SetTxPower(struct adapter *pAdapter)
504{
505 Hal_SetTxPower(pAdapter);
506 }
507
508void SetDataRate(struct adapter *pAdapter)
509{
510 Hal_SetDataRate(pAdapter);
511}
512
513void MP_PHY_SetRFPathSwitch(struct adapter *pAdapter , bool bMain)
514{
515 PHY_SetRFPathSwitch(pAdapter, bMain);
516}
517
518s32 SetThermalMeter(struct adapter *pAdapter, u8 target_ther)
519{
520 return Hal_SetThermalMeter(pAdapter, target_ther);
521}
522
523void GetThermalMeter(struct adapter *pAdapter, u8 *value)
524{
525 Hal_GetThermalMeter(pAdapter, value);
526}
527
528void SetSingleCarrierTx(struct adapter *pAdapter, u8 bStart)
529{
530 PhySetTxPowerLevel(pAdapter);
531 Hal_SetSingleCarrierTx(pAdapter, bStart);
532}
533
534void SetSingleToneTx(struct adapter *pAdapter, u8 bStart)
535{
536 PhySetTxPowerLevel(pAdapter);
537 Hal_SetSingleToneTx(pAdapter, bStart);
538}
539
540void SetCarrierSuppressionTx(struct adapter *pAdapter, u8 bStart)
541{
542 PhySetTxPowerLevel(pAdapter);
543 Hal_SetCarrierSuppressionTx(pAdapter, bStart);
544}
545
546void SetContinuousTx(struct adapter *pAdapter, u8 bStart)
547{
548 PhySetTxPowerLevel(pAdapter);
549 Hal_SetContinuousTx(pAdapter, bStart);
550}
551
552
553void PhySetTxPowerLevel(struct adapter *pAdapter)
554{
555 struct mp_priv *pmp_priv = &pAdapter->mppriv;
556
557 if (pmp_priv->bSetTxPower == 0) /* for NO manually set power index */
558 PHY_SetTxPowerLevel8188E(pAdapter, pmp_priv->channel);
559}
560
561/* */
562static void dump_mpframe(struct adapter *padapter, struct xmit_frame *pmpframe)
563{
564 rtw_hal_mgnt_xmit(padapter, pmpframe);
565}
566
567static struct xmit_frame *alloc_mp_xmitframe(struct xmit_priv *pxmitpriv)
568{
569 struct xmit_frame *pmpframe;
570 struct xmit_buf *pxmitbuf;
571
572 pmpframe = rtw_alloc_xmitframe(pxmitpriv);
573 if (pmpframe == NULL)
574 return NULL;
575
576 pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
577 if (pxmitbuf == NULL) {
578 rtw_free_xmitframe(pxmitpriv, pmpframe);
579 return NULL;
580 }
581
582 pmpframe->frame_tag = MP_FRAMETAG;
583
584 pmpframe->pxmitbuf = pxmitbuf;
585
586 pmpframe->buf_addr = pxmitbuf->pbuf;
587
588 pxmitbuf->priv_data = pmpframe;
589
590 return pmpframe;
591}
592
593static int mp_xmit_packet_thread(void *context)
594{
595 struct xmit_frame *pxmitframe;
596 struct mp_tx *pmptx;
597 struct mp_priv *pmp_priv;
598 struct xmit_priv *pxmitpriv;
599 struct adapter *padapter;
600
601 pmp_priv = (struct mp_priv *)context;
602 pmptx = &pmp_priv->tx;
603 padapter = pmp_priv->papdater;
604 pxmitpriv = &(padapter->xmitpriv);
605
606 thread_enter("RTW_MP_THREAD");
607
608 /* DBG_88E("%s:pkTx Start\n", __func__); */
609 while (1) {
610 pxmitframe = alloc_mp_xmitframe(pxmitpriv);
611 if (pxmitframe == NULL) {
612 if (pmptx->stop ||
613 padapter->bSurpriseRemoved ||
614 padapter->bDriverStopped) {
615 goto exit;
616 } else {
617 rtw_msleep_os(1);
618 continue;
619 }
620 }
621
622 memcpy((u8 *)(pxmitframe->buf_addr+TXDESC_OFFSET), pmptx->buf, pmptx->write_size);
623 memcpy(&(pxmitframe->attrib), &(pmptx->attrib), sizeof(struct pkt_attrib));
624
625 dump_mpframe(padapter, pxmitframe);
626
627 pmptx->sended++;
628 pmp_priv->tx_pktcount++;
629
630 if (pmptx->stop ||
631 padapter->bSurpriseRemoved ||
632 padapter->bDriverStopped)
633 goto exit;
634 if ((pmptx->count != 0) &&
635 (pmptx->count == pmptx->sended))
636 goto exit;
637
638 flush_signals_thread();
639 }
640
641exit:
642 kfree(pmptx->pallocated_buf);
643 pmptx->pallocated_buf = NULL;
644 pmptx->stop = 1;
645
646 thread_exit();
647}
648
649void fill_txdesc_for_mp(struct adapter *padapter, struct tx_desc *ptxdesc)
650{
651 struct mp_priv *pmp_priv = &padapter->mppriv;
652 memcpy(ptxdesc, &(pmp_priv->tx.desc), TXDESC_SIZE);
653}
654
655void SetPacketTx(struct adapter *padapter)
656{
657 u8 *ptr, *pkt_start, *pkt_end;
658 u32 pkt_size;
659 struct tx_desc *desc;
660 struct rtw_ieee80211_hdr *hdr;
661 u8 payload;
662 s32 bmcast;
663 struct pkt_attrib *pattrib;
664 struct mp_priv *pmp_priv;
665
666
667 pmp_priv = &padapter->mppriv;
668 if (pmp_priv->tx.stop)
669 return;
670 pmp_priv->tx.sended = 0;
671 pmp_priv->tx.stop = 0;
672 pmp_priv->tx_pktcount = 0;
673
674 /* 3 1. update_attrib() */
675 pattrib = &pmp_priv->tx.attrib;
676 memcpy(pattrib->src, padapter->eeprompriv.mac_addr, ETH_ALEN);
677 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
678 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
679 bmcast = IS_MCAST(pattrib->ra);
680 if (bmcast) {
681 pattrib->mac_id = 1;
682 pattrib->psta = rtw_get_bcmc_stainfo(padapter);
683 } else {
684 pattrib->mac_id = 0;
685 pattrib->psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
686 }
687
688 pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->pktlen;
689
690 /* 3 2. allocate xmit buffer */
691 pkt_size = pattrib->last_txcmdsz;
692
693 kfree(pmp_priv->tx.pallocated_buf);
694 pmp_priv->tx.write_size = pkt_size;
695 pmp_priv->tx.buf_size = pkt_size + XMITBUF_ALIGN_SZ;
696 pmp_priv->tx.pallocated_buf = rtw_zmalloc(pmp_priv->tx.buf_size);
697 if (pmp_priv->tx.pallocated_buf == NULL) {
698 DBG_88E("%s: malloc(%d) fail!!\n", __func__, pmp_priv->tx.buf_size);
699 return;
700 }
701 pmp_priv->tx.buf = (u8 *)N_BYTE_ALIGMENT((size_t)(pmp_priv->tx.pallocated_buf), XMITBUF_ALIGN_SZ);
702 ptr = pmp_priv->tx.buf;
703
704 desc = &(pmp_priv->tx.desc);
705 _rtw_memset(desc, 0, TXDESC_SIZE);
706 pkt_start = ptr;
707 pkt_end = pkt_start + pkt_size;
708
709 /* 3 3. init TX descriptor */
710 /* offset 0 */
711 desc->txdw0 |= cpu_to_le32(OWN | FSG | LSG);
712 desc->txdw0 |= cpu_to_le32(pkt_size & 0x0000FFFF); /* packet size */
713 desc->txdw0 |= cpu_to_le32(((TXDESC_SIZE + OFFSET_SZ) << OFFSET_SHT) & 0x00FF0000); /* 32 bytes for TX Desc */
714 if (bmcast)
715 desc->txdw0 |= cpu_to_le32(BMC); /* broadcast packet */
716
717 desc->txdw1 |= cpu_to_le32((0x01 << 26) & 0xff000000);
718 /* offset 4 */
719 desc->txdw1 |= cpu_to_le32((pattrib->mac_id) & 0x3F); /* CAM_ID(MAC_ID) */
720 desc->txdw1 |= cpu_to_le32((pattrib->qsel << QSEL_SHT) & 0x00001F00); /* Queue Select, TID */
721
722 desc->txdw1 |= cpu_to_le32((pattrib->raid << RATE_ID_SHT) & 0x000F0000); /* Rate Adaptive ID */
723 /* offset 8 */
724 /* offset 12 */
725
726 desc->txdw3 |= cpu_to_le32((pattrib->seqnum<<16)&0x0fff0000);
727
728 /* offset 16 */
729 desc->txdw4 |= cpu_to_le32(HW_SSN);
730 desc->txdw4 |= cpu_to_le32(USERATE);
731 desc->txdw4 |= cpu_to_le32(DISDATAFB);
732
733 if (pmp_priv->preamble) {
734 if (pmp_priv->rateidx <= MPT_RATE_54M)
735 desc->txdw4 |= cpu_to_le32(DATA_SHORT); /* CCK Short Preamble */
736 }
737 if (pmp_priv->bandwidth == HT_CHANNEL_WIDTH_40)
738 desc->txdw4 |= cpu_to_le32(DATA_BW);
739
740 /* offset 20 */
741 desc->txdw5 |= cpu_to_le32(pmp_priv->rateidx & 0x0000001F);
742
743 if (pmp_priv->preamble) {
744 if (pmp_priv->rateidx > MPT_RATE_54M)
745 desc->txdw5 |= cpu_to_le32(SGI); /* MCS Short Guard Interval */
746 }
747 desc->txdw5 |= cpu_to_le32(RTY_LMT_EN); /* retry limit enable */
748 desc->txdw5 |= cpu_to_le32(0x00180000); /* DATA/RTS Rate Fallback Limit */
749
750 /* 3 4. make wlan header, make_wlanhdr() */
751 hdr = (struct rtw_ieee80211_hdr *)pkt_start;
752 SetFrameSubType(&hdr->frame_ctl, pattrib->subtype);
753 memcpy(hdr->addr1, pattrib->dst, ETH_ALEN); /* DA */
754 memcpy(hdr->addr2, pattrib->src, ETH_ALEN); /* SA */
755 memcpy(hdr->addr3, get_bssid(&padapter->mlmepriv), ETH_ALEN); /* RA, BSSID */
756
757 /* 3 5. make payload */
758 ptr = pkt_start + pattrib->hdrlen;
759
760 switch (pmp_priv->tx.payload) {
761 case 0:
762 payload = 0x00;
763 break;
764 case 1:
765 payload = 0x5a;
766 break;
767 case 2:
768 payload = 0xa5;
769 break;
770 case 3:
771 payload = 0xff;
772 break;
773 default:
774 payload = 0x00;
775 break;
776 }
777
778 _rtw_memset(ptr, payload, pkt_end - ptr);
779
780 /* 3 6. start thread */
781 pmp_priv->tx.PktTxThread = kthread_run(mp_xmit_packet_thread, pmp_priv, "RTW_MP_THREAD");
782 if (IS_ERR(pmp_priv->tx.PktTxThread))
783 DBG_88E("Create PktTx Thread Fail !!!!!\n");
784}
785
786void SetPacketRx(struct adapter *pAdapter, u8 bStartRx)
787{
788 struct hal_data_8188e *pHalData = GET_HAL_DATA(pAdapter);
789
790 if (bStartRx) {
791 /* Accept CRC error and destination address */
792 pHalData->ReceiveConfig = AAP | APM | AM | AB | APP_ICV | ADF | AMF | HTC_LOC_CTRL | APP_MIC | APP_PHYSTS;
793
794 pHalData->ReceiveConfig |= ACRC32;
795
796 rtw_write32(pAdapter, REG_RCR, pHalData->ReceiveConfig);
797
798 /* Accept all data frames */
799 rtw_write16(pAdapter, REG_RXFLTMAP2, 0xFFFF);
800 } else {
801 rtw_write32(pAdapter, REG_RCR, 0);
802 }
803}
804
805void ResetPhyRxPktCount(struct adapter *pAdapter)
806{
807 u32 i, phyrx_set = 0;
808
809 for (i = 0; i <= 0xF; i++) {
810 phyrx_set = 0;
811 phyrx_set |= _RXERR_RPT_SEL(i); /* select */
812 phyrx_set |= RXERR_RPT_RST; /* set counter to zero */
813 rtw_write32(pAdapter, REG_RXERR_RPT, phyrx_set);
814 }
815}
816
817static u32 GetPhyRxPktCounts(struct adapter *pAdapter, u32 selbit)
818{
819 /* selection */
820 u32 phyrx_set = 0, count = 0;
821
822 phyrx_set = _RXERR_RPT_SEL(selbit & 0xF);
823 rtw_write32(pAdapter, REG_RXERR_RPT, phyrx_set);
824
825 /* Read packet count */
826 count = rtw_read32(pAdapter, REG_RXERR_RPT) & RXERR_COUNTER_MASK;
827
828 return count;
829}
830
831u32 GetPhyRxPktReceived(struct adapter *pAdapter)
832{
833 u32 OFDM_cnt = 0, CCK_cnt = 0, HT_cnt = 0;
834
835 OFDM_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_OFDM_MPDU_OK);
836 CCK_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_CCK_MPDU_OK);
837 HT_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_HT_MPDU_OK);
838
839 return OFDM_cnt + CCK_cnt + HT_cnt;
840}
841
842u32 GetPhyRxPktCRC32Error(struct adapter *pAdapter)
843{
844 u32 OFDM_cnt = 0, CCK_cnt = 0, HT_cnt = 0;
845
846 OFDM_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_OFDM_MPDU_FAIL);
847 CCK_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_CCK_MPDU_FAIL);
848 HT_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_HT_MPDU_FAIL);
849
850 return OFDM_cnt + CCK_cnt + HT_cnt;
851}
852
853/* reg 0x808[9:0]: FFT data x */
854/* reg 0x808[22]: 0 --> 1 to get 1 FFT data y */
855/* reg 0x8B4[15:0]: FFT data y report */
856static u32 rtw_GetPSDData(struct adapter *pAdapter, u32 point)
857{
858 int psd_val;
859
860
861 psd_val = rtw_read32(pAdapter, 0x808);
862 psd_val &= 0xFFBFFC00;
863 psd_val |= point;
864
865 rtw_write32(pAdapter, 0x808, psd_val);
866 rtw_mdelay_os(1);
867 psd_val |= 0x00400000;
868
869 rtw_write32(pAdapter, 0x808, psd_val);
870 rtw_mdelay_os(1);
871 psd_val = rtw_read32(pAdapter, 0x8B4);
872
873 psd_val &= 0x0000FFFF;
874
875 return psd_val;
876}
877
878/*
879 *pts start_point_min stop_point_max
880 * 128 64 64 + 128 = 192
881 * 256 128 128 + 256 = 384
882 * 512 256 256 + 512 = 768
883 * 1024 512 512 + 1024 = 1536
884 *
885 */
886u32 mp_query_psd(struct adapter *pAdapter, u8 *data)
887{
888 u32 i, psd_pts = 0, psd_start = 0, psd_stop = 0;
889 u32 psd_data = 0;
890
891
892 if (!netif_running(pAdapter->pnetdev)) {
893 RT_TRACE(_module_mp_, _drv_warning_, ("mp_query_psd: Fail! interface not opened!\n"));
894 return 0;
895 }
896
897 if (check_fwstate(&pAdapter->mlmepriv, WIFI_MP_STATE) == false) {
898 RT_TRACE(_module_mp_, _drv_warning_, ("mp_query_psd: Fail! not in MP mode!\n"));
899 return 0;
900 }
901
902 if (strlen(data) == 0) { /* default value */
903 psd_pts = 128;
904 psd_start = 64;
905 psd_stop = 128;
906 } else {
907 sscanf(data, "pts =%d, start =%d, stop =%d", &psd_pts, &psd_start, &psd_stop);
908 }
909
ffceff44 910 _rtw_memset(data, '\0', sizeof(*data));
7b464c9f
LF		 911
912 i = psd_start;
913 while (i < psd_stop) {
914 if (i >= psd_pts) {
915 psd_data = rtw_GetPSDData(pAdapter, i-psd_pts);
916 } else {
917 psd_data = rtw_GetPSDData(pAdapter, i);
918 }
919 sprintf(data, "%s%x ", data, psd_data);
920 i++;
921 }
922
923 rtw_msleep_os(100);
924 return strlen(data)+1;
925}
926
927void _rtw_mp_xmit_priv(struct xmit_priv *pxmitpriv)
928{
929 int i, res;
930 struct adapter *padapter = pxmitpriv->adapter;
931 struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
932
933 u32 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
934 u32 num_xmit_extbuf = NR_XMIT_EXTBUFF;
935 if (padapter->registrypriv.mp_mode == 0) {
936 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
937 num_xmit_extbuf = NR_XMIT_EXTBUFF;
938 } else {
939 max_xmit_extbuf_size = 20000;
940 num_xmit_extbuf = 1;
941 }
942
943 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
944 for (i = 0; i < num_xmit_extbuf; i++) {
945 rtw_os_xmit_resource_free(padapter, pxmitbuf, (max_xmit_extbuf_size + XMITBUF_ALIGN_SZ));
946
947 pxmitbuf++;
948 }
949
950 if (pxmitpriv->pallocated_xmit_extbuf)
951 rtw_vmfree(pxmitpriv->pallocated_xmit_extbuf, num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
952
953 if (padapter->registrypriv.mp_mode == 0) {
954 max_xmit_extbuf_size = 20000;
955 num_xmit_extbuf = 1;
956 } else {
957 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
958 num_xmit_extbuf = NR_XMIT_EXTBUFF;
959 }
960
961 /* Init xmit extension buff */
962 _rtw_init_queue(&pxmitpriv->free_xmit_extbuf_queue);
963
964 pxmitpriv->pallocated_xmit_extbuf = rtw_zvmalloc(num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
965
966 if (pxmitpriv->pallocated_xmit_extbuf == NULL) {
967 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("alloc xmit_extbuf fail!\n"));
968 res = _FAIL;
969 goto exit;
970 }
971
972 pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((size_t)(pxmitpriv->pallocated_xmit_extbuf), 4);
973
974 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
975
976 for (i = 0; i < num_xmit_extbuf; i++) {
977 _rtw_init_listhead(&pxmitbuf->list);
978
979 pxmitbuf->priv_data = NULL;
980 pxmitbuf->padapter = padapter;
981 pxmitbuf->ext_tag = true;
982
983 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, max_xmit_extbuf_size + XMITBUF_ALIGN_SZ);
984 if (res == _FAIL) {
985 res = _FAIL;
986 goto exit;
987 }
988
989 rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmit_extbuf_queue.queue));
990 pxmitbuf++;
991 }
992
993 pxmitpriv->free_xmit_extbuf_cnt = num_xmit_extbuf;
994
995exit:
996 ;
997}
Linux kernel - Deliverables
This page took 0.072662 seconds and 5 git commands to generate.