dp_tx_capture.c 40 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517
  1. /*
  2. * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include <htt.h>
  19. #include "qdf_trace.h"
  20. #include "qdf_nbuf.h"
  21. #include "dp_peer.h"
  22. #include "dp_types.h"
  23. #include "dp_internal.h"
  24. #include "dp_rx_mon.h"
  25. #include "htt_ppdu_stats.h"
  26. #include "dp_htt.h"
  27. #include "qdf_mem.h" /* qdf_mem_malloc,free */
  28. #include "cdp_txrx_cmn_struct.h"
  29. #include <enet.h>
  30. #include "dp_tx_capture.h"
  31. #ifdef WLAN_TX_PKT_CAPTURE_ENH
  32. /*
  33. * dp_peer_tid_queue_init() – Initialize ppdu stats queue per TID
  34. * @peer: Datapath peer
  35. *
  36. */
  37. void dp_peer_tid_queue_init(struct dp_peer *peer)
  38. {
  39. int tid;
  40. struct dp_tx_tid *tx_tid;
  41. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  42. tx_tid = &peer->tx_capture.tx_tid[tid];
  43. tx_tid->tid = tid;
  44. qdf_nbuf_queue_init(&tx_tid->msdu_comp_q);
  45. tx_tid->max_ppdu_id = 0;
  46. /* spinlock create */
  47. qdf_spinlock_create(&tx_tid->tid_lock);
  48. }
  49. }
  50. /*
  51. * dp_peer_tid_queue_cleanup() – remove ppdu stats queue per TID
  52. * @peer: Datapath peer
  53. *
  54. */
  55. void dp_peer_tid_queue_cleanup(struct dp_peer *peer)
  56. {
  57. int tid;
  58. struct dp_tx_tid *tx_tid;
  59. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  60. tx_tid = &peer->tx_capture.tx_tid[tid];
  61. /* spinlock destroy */
  62. qdf_spinlock_destroy(&tx_tid->tid_lock);
  63. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  64. tx_tid->max_ppdu_id = 0;
  65. }
  66. }
  67. /*
  68. * dp_peer_update_80211_hdr: update 80211 hdr
  69. * @vdev: DP VDEV
  70. * @peer: DP PEER
  71. *
  72. * return: void
  73. */
  74. void dp_peer_update_80211_hdr(struct dp_vdev *vdev, struct dp_peer *peer)
  75. {
  76. struct ieee80211_frame *ptr_wh;
  77. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  78. /* i_addr1 - Receiver mac address */
  79. /* i_addr2 - Transmitter mac address */
  80. /* i_addr3 - Destination mac address */
  81. qdf_mem_copy(ptr_wh->i_addr1,
  82. peer->mac_addr.raw,
  83. QDF_MAC_ADDR_SIZE);
  84. qdf_mem_copy(ptr_wh->i_addr3,
  85. peer->mac_addr.raw,
  86. QDF_MAC_ADDR_SIZE);
  87. qdf_mem_copy(ptr_wh->i_addr2,
  88. vdev->mac_addr.raw,
  89. QDF_MAC_ADDR_SIZE);
  90. }
  91. /*
  92. * dp_deliver_mgmt_frm: Process
  93. * @pdev: DP PDEV handle
  94. * @nbuf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
  95. *
  96. * return: void
  97. */
  98. void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
  99. {
  100. if (pdev->tx_sniffer_enable || pdev->mcopy_mode) {
  101. dp_wdi_event_handler(WDI_EVENT_TX_MGMT_CTRL, pdev->soc,
  102. nbuf, HTT_INVALID_PEER,
  103. WDI_NO_VAL, pdev->pdev_id);
  104. } else if (pdev->tx_capture_enabled) {
  105. if (pdev->mgmtctrl_frm_info.last_nbuf)
  106. qdf_nbuf_free(pdev->mgmtctrl_frm_info.last_nbuf);
  107. /* pull ppdu_id from the packet */
  108. qdf_nbuf_pull_head(nbuf, sizeof(uint32_t));
  109. pdev->mgmtctrl_frm_info.last_nbuf = nbuf;
  110. }
  111. }
  112. /**
  113. * dp_tx_ppdu_stats_attach - Initialize Tx PPDU stats and enhanced capture
  114. * @pdev: DP PDEV
  115. *
  116. * Return: none
  117. */
  118. void dp_tx_ppdu_stats_attach(struct dp_pdev *pdev)
  119. {
  120. /* Work queue setup for HTT stats and tx capture handling */
  121. qdf_create_work(0, &pdev->tx_capture.ppdu_stats_work,
  122. dp_tx_ppdu_stats_process,
  123. pdev);
  124. pdev->tx_capture.ppdu_stats_workqueue =
  125. qdf_alloc_unbound_workqueue("ppdu_stats_work_queue");
  126. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_queue);
  127. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_defer_queue);
  128. qdf_spinlock_create(&pdev->tx_capture.ppdu_stats_lock);
  129. pdev->tx_capture.ppdu_stats_queue_depth = 0;
  130. pdev->tx_capture.ppdu_stats_next_sched = 0;
  131. }
  132. /**
  133. * dp_tx_ppdu_stats_detach - Cleanup Tx PPDU stats and enhanced capture
  134. * @pdev: DP PDEV
  135. *
  136. * Return: none
  137. */
  138. void dp_tx_ppdu_stats_detach(struct dp_pdev *pdev)
  139. {
  140. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  141. if (!pdev || !pdev->tx_capture.ppdu_stats_workqueue)
  142. return;
  143. qdf_flush_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  144. qdf_destroy_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  145. qdf_spinlock_destroy(&pdev->tx_capture.ppdu_stats_lock);
  146. STAILQ_FOREACH_SAFE(ppdu_info,
  147. &pdev->tx_capture.ppdu_stats_queue,
  148. ppdu_info_queue_elem, tmp_ppdu_info) {
  149. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_queue,
  150. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  151. qdf_nbuf_free(ppdu_info->nbuf);
  152. qdf_mem_free(ppdu_info);
  153. }
  154. STAILQ_FOREACH_SAFE(ppdu_info,
  155. &pdev->tx_capture.ppdu_stats_defer_queue,
  156. ppdu_info_queue_elem, tmp_ppdu_info) {
  157. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_defer_queue,
  158. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  159. qdf_nbuf_free(ppdu_info->nbuf);
  160. qdf_mem_free(ppdu_info);
  161. }
  162. }
  163. /**
  164. * dp_update_msdu_to_list(): Function to queue msdu from wbm
  165. * @pdev: dp_pdev
  166. * @peer: dp_peer
  167. * @ts: hal tx completion status
  168. * @netbuf: msdu
  169. *
  170. * return: status
  171. */
  172. QDF_STATUS
  173. dp_update_msdu_to_list(struct dp_soc *soc,
  174. struct dp_pdev *pdev,
  175. struct dp_peer *peer,
  176. struct hal_tx_completion_status *ts,
  177. qdf_nbuf_t netbuf)
  178. {
  179. struct dp_tx_tid *tx_tid;
  180. struct msdu_completion_info *msdu_comp_info;
  181. if (!peer) {
  182. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  183. "%s: %d peer NULL !", __func__, __LINE__);
  184. return QDF_STATUS_E_FAILURE;
  185. }
  186. if (ts->tid > DP_NON_QOS_TID) {
  187. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  188. "%s: %d peer_id %d, tid %d > NON_QOS_TID!",
  189. __func__, __LINE__, ts->peer_id, ts->tid);
  190. return QDF_STATUS_E_FAILURE;
  191. }
  192. tx_tid = &peer->tx_capture.tx_tid[ts->tid];
  193. if (!tx_tid) {
  194. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  195. "%s: %d tid[%d] NULL !", __func__, __LINE__, ts->tid);
  196. return QDF_STATUS_E_FAILURE;
  197. }
  198. qdf_nbuf_unmap(soc->osdev, netbuf, QDF_DMA_TO_DEVICE);
  199. if (!qdf_nbuf_push_head(netbuf, sizeof(struct msdu_completion_info))) {
  200. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  201. FL("No headroom"));
  202. return QDF_STATUS_E_NOMEM;
  203. }
  204. msdu_comp_info = (struct msdu_completion_info *)qdf_nbuf_data(netbuf);
  205. /* copy msdu_completion_info to control buffer */
  206. msdu_comp_info->ppdu_id = ts->ppdu_id;
  207. msdu_comp_info->peer_id = ts->peer_id;
  208. msdu_comp_info->tid = ts->tid;
  209. msdu_comp_info->first_msdu = ts->first_msdu;
  210. msdu_comp_info->last_msdu = ts->last_msdu;
  211. msdu_comp_info->msdu_part_of_amsdu = ts->msdu_part_of_amsdu;
  212. msdu_comp_info->transmit_cnt = ts->transmit_cnt;
  213. msdu_comp_info->tsf = ts->tsf;
  214. /* update max ppdu_id */
  215. tx_tid->max_ppdu_id = ts->ppdu_id;
  216. pdev->tx_capture.last_msdu_id = ts->ppdu_id;
  217. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  218. "msdu_completion: ppdu_id[%d] peer_id[%d] tid[%d] rel_src[%d] status[%d] tsf[%u] A[%d] CNT[%d]",
  219. ts->ppdu_id, ts->peer_id, ts->tid, ts->release_src,
  220. ts->status, ts->tsf, ts->msdu_part_of_amsdu,
  221. ts->transmit_cnt);
  222. /* lock here */
  223. qdf_spin_lock(&tx_tid->tid_lock);
  224. /* add nbuf to tail queue per peer tid */
  225. qdf_nbuf_queue_add(&tx_tid->msdu_comp_q, netbuf);
  226. qdf_spin_unlock(&tx_tid->tid_lock);
  227. return QDF_STATUS_SUCCESS;
  228. }
  229. /**
  230. * dp_tx_add_to_comp_queue() - add completion msdu to queue
  231. * @soc: DP Soc handle
  232. * @tx_desc: software Tx descriptor
  233. * @ts : Tx completion status from HAL/HTT descriptor
  234. * @peer: DP peer
  235. *
  236. * Return: none
  237. */
  238. QDF_STATUS dp_tx_add_to_comp_queue(struct dp_soc *soc,
  239. struct dp_tx_desc_s *desc,
  240. struct hal_tx_completion_status *ts,
  241. struct dp_peer *peer)
  242. {
  243. int ret = QDF_STATUS_E_FAILURE;
  244. if (desc->pdev->tx_capture_enabled == 1 &&
  245. (ts->status == HAL_TX_TQM_RR_REM_CMD_TX ||
  246. ts->status == HAL_TX_TQM_RR_FRAME_ACKED)) {
  247. ret = dp_update_msdu_to_list(soc, desc->pdev,
  248. peer, ts, desc->nbuf);
  249. }
  250. return ret;
  251. }
  252. /**
  253. * dp_process_ppdu_stats_update_failed_bitmap(): update failed bitmap
  254. * @pdev: dp_pdev
  255. * @data: tx completion ppdu desc
  256. * @ppdu_id: ppdu id
  257. * @size: size of bitmap
  258. *
  259. * return: status
  260. */
  261. void dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
  262. void *data,
  263. uint32_t ppdu_id,
  264. uint32_t size)
  265. {
  266. struct cdp_tx_completion_ppdu_user *user;
  267. uint32_t mpdu_tried;
  268. uint32_t ba_seq_no;
  269. uint32_t start_seq;
  270. uint32_t num_mpdu;
  271. uint32_t diff;
  272. uint32_t carry = 0;
  273. uint32_t bitmask = 0;
  274. uint32_t i;
  275. uint32_t k;
  276. uint32_t ba_bitmap = 0;
  277. user = (struct cdp_tx_completion_ppdu_user *)data;
  278. /* get number of mpdu from ppdu_desc */
  279. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  280. ba_seq_no = user->ba_seq_no;
  281. start_seq = user->start_seq;
  282. num_mpdu = user->num_mpdu;
  283. /* assumption: number of mpdu will be less than 32 */
  284. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  285. "ppdu_id[%d] ba_seq_no[%d] start_seq_no[%d] mpdu_tried[%d]",
  286. ppdu_id, ba_seq_no, start_seq, mpdu_tried);
  287. for (i = 0; i < size; i++) {
  288. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  289. "ppdu_id[%d] ba_bitmap[%x] enqueue_bitmap[%x]",
  290. ppdu_id, user->ba_bitmap[i], user->enq_bitmap[i]);
  291. }
  292. if (start_seq <= ba_seq_no) {
  293. diff = ba_seq_no - start_seq;
  294. bitmask = (1 << diff) - 1;
  295. for (i = 0; i < size; i++) {
  296. ba_bitmap = user->ba_bitmap[i];
  297. user->failed_bitmap[i] = (ba_bitmap << diff);
  298. user->failed_bitmap[i] |= (bitmask & carry);
  299. carry = ((ba_bitmap & (bitmask << (32 - diff))) >>
  300. (32 - diff));
  301. user->failed_bitmap[i] = user->enq_bitmap[i] &
  302. user->failed_bitmap[i];
  303. }
  304. } else {
  305. diff = start_seq - ba_seq_no;
  306. /* array index */
  307. k = diff >> 5;
  308. diff = diff & 0x1F;
  309. bitmask = (1 << diff) - 1;
  310. for (i = 0; i < size; i++, k++) {
  311. ba_bitmap = user->ba_bitmap[k];
  312. user->failed_bitmap[i] = ba_bitmap >> diff;
  313. /* get next ba_bitmap */
  314. ba_bitmap = user->ba_bitmap[k + 1];
  315. carry = (ba_bitmap & bitmask);
  316. user->failed_bitmap[i] |=
  317. ((carry & bitmask) << (32 - diff));
  318. user->failed_bitmap[i] = user->enq_bitmap[i] &
  319. user->failed_bitmap[i];
  320. }
  321. }
  322. }
  323. /*
  324. * dp_soc_set_txrx_ring_map_single()
  325. * @dp_soc: DP handler for soc
  326. *
  327. * Return: Void
  328. */
  329. static void dp_soc_set_txrx_ring_map_single(struct dp_soc *soc)
  330. {
  331. uint32_t i;
  332. for (i = 0; i < WLAN_CFG_INT_NUM_CONTEXTS; i++) {
  333. soc->tx_ring_map[i] =
  334. dp_cpu_ring_map[DP_SINGLE_TX_RING_MAP][i];
  335. }
  336. }
  337. /*
  338. * dp_iterate_free_peer_msdu_q()- API to free msdu queue
  339. * @pdev_handle: DP_PDEV handle
  340. *
  341. * Return: void
  342. */
  343. static void dp_iterate_free_peer_msdu_q(void *pdev_hdl)
  344. {
  345. struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
  346. struct dp_soc *soc = pdev->soc;
  347. struct dp_vdev *vdev = NULL;
  348. struct dp_peer *peer = NULL;
  349. qdf_spin_lock_bh(&soc->peer_ref_mutex);
  350. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  351. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  352. DP_VDEV_ITERATE_PEER_LIST(vdev, peer) {
  353. int tid;
  354. struct dp_tx_tid *tx_tid;
  355. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  356. tx_tid = &peer->tx_capture.tx_tid[tid];
  357. /* spinlock hold */
  358. qdf_spin_lock(&tx_tid->tid_lock);
  359. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  360. qdf_spin_unlock(&tx_tid->tid_lock);
  361. }
  362. }
  363. }
  364. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  365. qdf_spin_unlock_bh(&soc->peer_ref_mutex);
  366. }
  367. /*
  368. * dp_config_enh_tx_capture()- API to enable/disable enhanced tx capture
  369. * @pdev_handle: DP_PDEV handle
  370. * @val: user provided value
  371. *
  372. * Return: QDF_STATUS
  373. */
  374. QDF_STATUS
  375. dp_config_enh_tx_capture(struct cdp_pdev *pdev_handle, int val)
  376. {
  377. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  378. pdev->tx_capture_enabled = val;
  379. if (pdev->tx_capture_enabled) {
  380. dp_soc_set_txrx_ring_map_single(pdev->soc);
  381. if (!pdev->pktlog_ppdu_stats)
  382. dp_h2t_cfg_stats_msg_send(pdev,
  383. DP_PPDU_STATS_CFG_SNIFFER,
  384. pdev->pdev_id);
  385. } else {
  386. dp_soc_set_txrx_ring_map(pdev->soc);
  387. dp_h2t_cfg_stats_msg_send(pdev,
  388. DP_PPDU_STATS_CFG_ENH_STATS,
  389. pdev->pdev_id);
  390. dp_iterate_free_peer_msdu_q(pdev);
  391. }
  392. return QDF_STATUS_SUCCESS;
  393. }
  394. /**
  395. * get_number_of_1s(): Function to get number of 1s
  396. * @value: value to find
  397. *
  398. * return: number of 1s
  399. */
  400. static
  401. inline uint32_t get_number_of_1s(uint32_t value)
  402. {
  403. uint32_t shift[] = {1, 2, 4, 8, 16};
  404. uint32_t magic_number[] = { 0x55555555, 0x33333333, 0x0F0F0F0F,
  405. 0x00FF00FF, 0x0000FFFF};
  406. uint8_t k = 0;
  407. for (; k <= 4; k++) {
  408. value = (value & magic_number[k]) +
  409. ((value >> shift[k]) & magic_number[k]);
  410. }
  411. return value;
  412. }
  413. /**
  414. * dp_tx_print_bitmap(): Function to print bitmap
  415. * @pdev: dp_pdev
  416. * @ppdu_desc: ppdu completion descriptor
  417. * @user_inder: user index
  418. * @ppdu_id: ppdu id
  419. *
  420. * return: status
  421. */
  422. static
  423. QDF_STATUS dp_tx_print_bitmap(struct dp_pdev *pdev,
  424. struct cdp_tx_completion_ppdu *ppdu_desc,
  425. uint32_t user_index,
  426. uint32_t ppdu_id)
  427. {
  428. struct cdp_tx_completion_ppdu_user *user;
  429. uint8_t i;
  430. uint32_t mpdu_tried;
  431. uint32_t ba_seq_no;
  432. uint32_t start_seq;
  433. uint32_t num_mpdu;
  434. uint32_t fail_num_mpdu = 0;
  435. user = &ppdu_desc->user[user_index];
  436. /* get number of mpdu from ppdu_desc */
  437. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  438. ba_seq_no = user->ba_seq_no;
  439. start_seq = user->start_seq;
  440. num_mpdu = user->mpdu_success;
  441. if (user->tid > DP_NON_QOS_TID) {
  442. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  443. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  444. __func__, ppdu_id, user->peer_id, user->tid);
  445. return QDF_STATUS_E_FAILURE;
  446. }
  447. if (mpdu_tried != num_mpdu) {
  448. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  449. "%s: ppdu[%d] peer[%d] tid[%d] ba[%d] start[%d] mpdu_tri[%d] num_mpdu[%d] is_mcast[%d]",
  450. __func__, ppdu_id, user->peer_id, user->tid,
  451. ba_seq_no, start_seq, mpdu_tried,
  452. num_mpdu, user->is_mcast);
  453. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++) {
  454. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  455. QDF_TRACE_LEVEL_ERROR,
  456. "ppdu_id[%d] ba_bitmap[0x%x] enqueue_bitmap[0x%x] failed_bitmap[0x%x]",
  457. ppdu_id, user->ba_bitmap[i],
  458. user->enq_bitmap[i],
  459. user->failed_bitmap[i]);
  460. fail_num_mpdu +=
  461. get_number_of_1s(user->failed_bitmap[i]);
  462. }
  463. }
  464. if (fail_num_mpdu == num_mpdu && num_mpdu)
  465. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  466. "%s: %d ppdu_id[%d] num_mpdu[%d, %d]",
  467. __func__, __LINE__, ppdu_id, num_mpdu, fail_num_mpdu);
  468. return QDF_STATUS_SUCCESS;
  469. }
  470. static uint32_t dp_tx_update_80211_hdr(struct dp_pdev *pdev,
  471. struct dp_peer *peer,
  472. void *data,
  473. qdf_nbuf_t nbuf)
  474. {
  475. struct cdp_tx_completion_ppdu *ppdu_desc;
  476. struct ieee80211_frame *ptr_wh;
  477. struct ieee80211_qoscntl *ptr_qoscntl;
  478. uint32_t mpdu_buf_len;
  479. uint8_t *ptr_hdr;
  480. ppdu_desc = (struct cdp_tx_completion_ppdu *)data;
  481. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  482. ptr_qoscntl = &peer->tx_capture.tx_qoscntl;
  483. /*
  484. * update framectrl only for first ppdu_id
  485. * rest of mpdu will have same frame ctrl
  486. * mac address and duration
  487. */
  488. if (ppdu_desc->ppdu_id != peer->tx_capture.tx_wifi_ppdu_id) {
  489. ptr_wh->i_fc[1] = (ppdu_desc->frame_ctrl & 0xFF00) >> 8;
  490. ptr_wh->i_fc[0] = (ppdu_desc->frame_ctrl & 0xFF);
  491. ptr_wh->i_dur[1] = (ppdu_desc->tx_duration & 0xFF00) >> 8;
  492. ptr_wh->i_dur[0] = (ppdu_desc->tx_duration & 0xFF);
  493. ptr_qoscntl->i_qos[1] = (ppdu_desc->user[0].qos_ctrl &
  494. 0xFF00) >> 8;
  495. ptr_qoscntl->i_qos[0] = (ppdu_desc->user[0].qos_ctrl & 0xFF);
  496. peer->tx_capture.tx_wifi_ppdu_id = ppdu_desc->ppdu_id;
  497. }
  498. mpdu_buf_len = sizeof(struct ieee80211_frame) + LLC_SNAP_HDR_LEN;
  499. mpdu_buf_len += sizeof(struct ieee80211_qoscntl);
  500. nbuf->protocol = qdf_htons(ETH_P_802_2);
  501. /* update ieee80211_frame header */
  502. if (!qdf_nbuf_push_head(nbuf, mpdu_buf_len)) {
  503. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  504. FL("No headroom"));
  505. return QDF_STATUS_E_NOMEM;
  506. }
  507. ptr_hdr = (void *)qdf_nbuf_data(nbuf);
  508. qdf_mem_copy(ptr_hdr, ptr_wh, sizeof(struct ieee80211_frame));
  509. ptr_hdr = ptr_hdr + (sizeof(struct ieee80211_frame));
  510. /* update qoscntl header */
  511. qdf_mem_copy(ptr_hdr, ptr_qoscntl, sizeof(struct ieee80211_qoscntl));
  512. ptr_hdr = ptr_hdr + sizeof(struct ieee80211_qoscntl);
  513. /* update LLC */
  514. *ptr_hdr = LLC_SNAP_LSAP;
  515. *(ptr_hdr + 1) = LLC_SNAP_LSAP;
  516. *(ptr_hdr + 2) = LLC_UI;
  517. *(ptr_hdr + 3) = 0x00;
  518. *(ptr_hdr + 4) = 0x00;
  519. *(ptr_hdr + 5) = 0x00;
  520. /* TYPE: IPV4 ?? */
  521. *(ptr_hdr + 6) = (ETHERTYPE_IPV4 & 0xFF00) >> 8;
  522. *(ptr_hdr + 7) = (ETHERTYPE_IPV4 & 0xFF);
  523. qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - mpdu_buf_len);
  524. return 0;
  525. }
  526. #define MAX_MONITOR_HEADER (512)
  527. /**
  528. * dp_tx_mon_restitch_mpdu_from_msdus(): Function to restitch msdu to mpdu
  529. * @pdev: dp_pdev
  530. * @peer: dp_peer
  531. * @head_msdu: head msdu queue
  532. *
  533. * return: status
  534. */
  535. static uint32_t
  536. dp_tx_mon_restitch_mpdu_from_msdus(struct dp_pdev *pdev,
  537. struct dp_peer *peer,
  538. struct cdp_tx_completion_ppdu *ppdu_desc,
  539. qdf_nbuf_queue_t *head_msdu)
  540. {
  541. qdf_nbuf_t curr_nbuf = NULL;
  542. qdf_nbuf_t first_nbuf = NULL;
  543. qdf_nbuf_t prev_nbuf = NULL;
  544. qdf_nbuf_t mpdu_nbuf = NULL;
  545. qdf_nbuf_queue_t *mpdu = NULL;
  546. uint32_t num_mpdu = 0;
  547. struct msdu_completion_info *ptr_msdu_info = NULL;
  548. uint8_t first_msdu = 0;
  549. uint8_t last_msdu = 0;
  550. uint32_t frag_list_sum_len = 0;
  551. uint8_t first_msdu_not_seen = 1;
  552. num_mpdu = ppdu_desc->num_mpdu;
  553. mpdu = &ppdu_desc->mpdu_q;
  554. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  555. while (curr_nbuf) {
  556. ptr_msdu_info =
  557. (struct msdu_completion_info *)qdf_nbuf_data(curr_nbuf);
  558. first_msdu = ptr_msdu_info->first_msdu;
  559. last_msdu = ptr_msdu_info->last_msdu;
  560. /* pull msdu_completion_info added in pre header */
  561. /* pull ethernet header from header */
  562. qdf_nbuf_pull_head(curr_nbuf,
  563. sizeof(struct msdu_completion_info) +
  564. sizeof(qdf_ether_header_t));
  565. if (first_msdu && first_msdu_not_seen) {
  566. first_nbuf = curr_nbuf;
  567. frag_list_sum_len = 0;
  568. first_msdu_not_seen = 0;
  569. mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  570. MAX_MONITOR_HEADER,
  571. MAX_MONITOR_HEADER,
  572. 4, FALSE);
  573. if (!mpdu_nbuf) {
  574. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  575. QDF_TRACE_LEVEL_FATAL,
  576. "MPDU head allocation failed !!!");
  577. QDF_BUG(0);
  578. }
  579. dp_tx_update_80211_hdr(pdev, peer,
  580. ppdu_desc, mpdu_nbuf);
  581. /* update first buffer to previous buffer */
  582. prev_nbuf = curr_nbuf;
  583. } else if (first_msdu && !first_msdu_not_seen) {
  584. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  585. QDF_TRACE_LEVEL_FATAL,
  586. "!!!!! NO LAST MSDU\n");
  587. /*
  588. * no last msdu in a mpdu
  589. * handle this case
  590. */
  591. qdf_nbuf_free(curr_nbuf);
  592. /* assert here if no last msdu found */
  593. QDF_BUG(0);
  594. } else if (!first_msdu && first_msdu_not_seen) {
  595. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  596. QDF_TRACE_LEVEL_FATAL,
  597. "!!!!! NO FIRST MSDU\n");
  598. /*
  599. * no first msdu in a mpdu
  600. * handle this case
  601. */
  602. qdf_nbuf_free(curr_nbuf);
  603. /* assert here if no first msdu found */
  604. QDF_BUG(0);
  605. } else {
  606. /* update current buffer to previous buffer next */
  607. prev_nbuf->next = curr_nbuf;
  608. /* move the previous buffer to next buffer */
  609. prev_nbuf = prev_nbuf->next;
  610. }
  611. frag_list_sum_len += qdf_nbuf_len(curr_nbuf);
  612. if (last_msdu) {
  613. /*
  614. * first nbuf will hold list of msdu
  615. * stored in prev_nbuf
  616. */
  617. qdf_nbuf_append_ext_list(mpdu_nbuf,
  618. first_nbuf,
  619. frag_list_sum_len);
  620. /* add mpdu to mpdu queue */
  621. qdf_nbuf_queue_add(mpdu, mpdu_nbuf);
  622. first_nbuf = NULL;
  623. /* next msdu will start with first msdu */
  624. first_msdu_not_seen = 1;
  625. goto check_for_next_msdu;
  626. }
  627. /* get next msdu from the head_msdu */
  628. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  629. if (!curr_nbuf) {
  630. /* msdu missed in list */
  631. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  632. QDF_TRACE_LEVEL_FATAL,
  633. "!!!! WAITING for msdu but list empty !!!!");
  634. }
  635. continue;
  636. check_for_next_msdu:
  637. if (qdf_nbuf_is_queue_empty(head_msdu))
  638. return 0;
  639. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  640. }
  641. return 0;
  642. }
  643. /**
  644. * dp_tx_msdu_dequeue(): Function to dequeue msdu from peer based tid
  645. * @peer: dp_peer
  646. * @ppdu_id: ppdu_id
  647. * @tid: tid
  648. * @num_msdu: number of msdu
  649. * @head: head queue
  650. * @start_tsf: start tsf from ppdu_desc
  651. * @end_tsf: end tsf from ppdu_desc
  652. *
  653. * return: status
  654. */
  655. static
  656. uint32_t dp_tx_msdu_dequeue(struct dp_peer *peer, uint32_t ppdu_id,
  657. uint16_t tid, uint32_t num_msdu,
  658. qdf_nbuf_queue_t *head,
  659. uint32_t start_tsf, uint32_t end_tsf)
  660. {
  661. struct dp_tx_tid *tx_tid = NULL;
  662. uint32_t msdu_ppdu_id;
  663. qdf_nbuf_t curr_msdu = NULL;
  664. qdf_nbuf_t prev_msdu = NULL;
  665. qdf_nbuf_t nbuf = NULL;
  666. struct msdu_completion_info *ptr_msdu_info = NULL;
  667. uint32_t wbm_tsf;
  668. uint32_t matched = 0;
  669. if (qdf_unlikely(!peer))
  670. return 0;
  671. tx_tid = &peer->tx_capture.tx_tid[tid];
  672. if (qdf_unlikely(!tx_tid))
  673. return 0;
  674. if (qdf_nbuf_is_queue_empty(&tx_tid->msdu_comp_q))
  675. return 0;
  676. curr_msdu = qdf_nbuf_queue_first(&tx_tid->msdu_comp_q);
  677. while (curr_msdu) {
  678. if (qdf_nbuf_queue_len(head) == num_msdu)
  679. break;
  680. ptr_msdu_info =
  681. (struct msdu_completion_info *)qdf_nbuf_data(curr_msdu);
  682. msdu_ppdu_id = ptr_msdu_info->ppdu_id;
  683. wbm_tsf = ptr_msdu_info->tsf;
  684. if (msdu_ppdu_id == ppdu_id) {
  685. matched = 1;
  686. if (wbm_tsf > start_tsf && wbm_tsf < end_tsf) {
  687. /*packet found */
  688. } else if (wbm_tsf < start_tsf) {
  689. /* lock here */
  690. qdf_spin_lock_bh(&tx_tid->tid_lock);
  691. /* remove the aged packet */
  692. nbuf = qdf_nbuf_queue_remove(
  693. &tx_tid->msdu_comp_q);
  694. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  695. qdf_nbuf_free(nbuf);
  696. curr_msdu = qdf_nbuf_queue_first(
  697. &tx_tid->msdu_comp_q);
  698. prev_msdu = NULL;
  699. continue;
  700. } else if (wbm_tsf > end_tsf) {
  701. /*
  702. * Do we need delta in above case.
  703. * for searching ppdu out of ppdu tsf
  704. */
  705. break;
  706. }
  707. if (qdf_likely(!prev_msdu)) {
  708. /* lock here */
  709. qdf_spin_lock_bh(&tx_tid->tid_lock);
  710. /* remove head */
  711. curr_msdu = qdf_nbuf_queue_remove(
  712. &tx_tid->msdu_comp_q);
  713. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  714. /* add msdu to head queue */
  715. qdf_nbuf_queue_add(head, curr_msdu);
  716. /* get next msdu from msdu_comp_q */
  717. curr_msdu = qdf_nbuf_queue_first(
  718. &tx_tid->msdu_comp_q);
  719. continue;
  720. } else {
  721. /* lock here */
  722. qdf_spin_lock_bh(&tx_tid->tid_lock);
  723. /* update prev_msdu next to current msdu next */
  724. prev_msdu->next = curr_msdu->next;
  725. /* set current msdu next as NULL */
  726. curr_msdu->next = NULL;
  727. /* decrement length */
  728. ((qdf_nbuf_queue_t *)(
  729. &tx_tid->msdu_comp_q))->qlen--;
  730. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  731. /* add msdu to head queue */
  732. qdf_nbuf_queue_add(head, curr_msdu);
  733. /* set previous msdu to current msdu */
  734. curr_msdu = prev_msdu->next;
  735. continue;
  736. }
  737. }
  738. prev_msdu = curr_msdu;
  739. curr_msdu = prev_msdu->next;
  740. }
  741. if (qdf_nbuf_queue_len(head) != num_msdu)
  742. matched = 0;
  743. return matched;
  744. }
  745. /**
  746. * get_mpdu_clone_from_next_ppdu(): Function to clone missing mpdu from
  747. * next ppdu
  748. * @nbuf_ppdu_desc_list: nbuf list
  749. * @ppdu_desc_cnt: ppdu_desc_cnt
  750. * @missed_seq_no:
  751. * @ppdu_id: ppdu_id
  752. * @mpdu_info: cdp_tx_indication_mpdu_info
  753. *
  754. * return: void
  755. */
  756. static
  757. qdf_nbuf_t get_mpdu_clone_from_next_ppdu(qdf_nbuf_t nbuf_ppdu_desc_list[],
  758. uint32_t ppdu_desc_cnt,
  759. uint32_t missed_seq_no,
  760. uint32_t ppdu_id)
  761. {
  762. uint32_t i = 0;
  763. uint32_t k = 0;
  764. uint32_t mpdu_tried = 0;
  765. uint32_t found = 0;
  766. uint32_t seq_no = 0;
  767. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  768. qdf_nbuf_t mpdu = NULL;
  769. for (i = 1; i < ppdu_desc_cnt; i++) {
  770. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  771. qdf_nbuf_data(nbuf_ppdu_desc_list[i]);
  772. mpdu_tried = ppdu_desc->user[0].mpdu_tried_ucast +
  773. ppdu_desc->user[0].mpdu_tried_mcast;
  774. /* check if seq number is between the range */
  775. if ((missed_seq_no >= ppdu_desc->user[0].start_seq) &&
  776. (missed_seq_no <= ppdu_desc->user[0].start_seq +
  777. mpdu_tried)) {
  778. seq_no = ppdu_desc->user[0].start_seq;
  779. if (ppdu_desc->user[0].failed_bitmap[k] &
  780. (1 << (missed_seq_no - seq_no))) {
  781. found = 1;
  782. break;
  783. }
  784. }
  785. }
  786. if (found == 0) {
  787. /* mpdu not found in sched cmd id */
  788. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  789. "%s: missed seq_no[%d] ppdu_id[%d] [%d] not found!!!",
  790. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  791. return NULL;
  792. }
  793. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  794. "%s: seq_no[%d] missed ppdu_id[%d] m[%d] found in ppdu_id[%d]!!",
  795. __func__,
  796. missed_seq_no, ppdu_id,
  797. (missed_seq_no - seq_no), ppdu_desc->ppdu_id);
  798. mpdu = qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
  799. if (!mpdu) {
  800. /* bitmap shows it found sequence number, but queue empty */
  801. /* do we need to allocate skb and send instead of NULL ? */
  802. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  803. "%s: missed seq_no[%d] ppdu_id[%d] [%d] found but queue empty!!!",
  804. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  805. return NULL;
  806. }
  807. for (i = 0; i < (missed_seq_no - seq_no); i++) {
  808. mpdu = mpdu->next;
  809. if (!mpdu) {
  810. /*
  811. * bitmap shows it found sequence number,
  812. * but queue empty, do we need to allocate
  813. * skb and send instead of NULL ?
  814. * add counter here:
  815. */
  816. return NULL;
  817. }
  818. }
  819. return skb_copy_expand(mpdu, MAX_MONITOR_HEADER, 0, GFP_ATOMIC);
  820. }
  821. /**
  822. * dp_tx_update_user_mpdu_info(): Function to update mpdu info
  823. * from ppdu_desc
  824. * @ppdu_id: ppdu_id
  825. * @mpdu_info: cdp_tx_indication_mpdu_info
  826. * @user: cdp_tx_completion_ppdu_user
  827. *
  828. * return: void
  829. */
  830. static void
  831. dp_tx_update_user_mpdu_info(uint32_t ppdu_id,
  832. struct cdp_tx_indication_mpdu_info *mpdu_info,
  833. struct cdp_tx_completion_ppdu_user *user)
  834. {
  835. mpdu_info->ppdu_id = ppdu_id;
  836. mpdu_info->frame_ctrl = user->frame_ctrl;
  837. mpdu_info->qos_ctrl = user->qos_ctrl;
  838. mpdu_info->tid = user->tid;
  839. mpdu_info->ltf_size = user->ltf_size;
  840. mpdu_info->he_re = user->he_re;
  841. mpdu_info->txbf = user->txbf;
  842. mpdu_info->bw = user->bw;
  843. mpdu_info->nss = user->nss;
  844. mpdu_info->mcs = user->mcs;
  845. mpdu_info->preamble = user->preamble;
  846. mpdu_info->gi = user->gi;
  847. mpdu_info->ack_rssi = user->ack_rssi[0];
  848. mpdu_info->tx_rate = user->tx_rate;
  849. mpdu_info->ldpc = user->ldpc;
  850. mpdu_info->ppdu_cookie = user->ppdu_cookie;
  851. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, 6);
  852. mpdu_info->ba_start_seq = user->ba_seq_no;
  853. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  854. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  855. }
  856. static inline
  857. void dp_tx_update_sequence_number(qdf_nbuf_t nbuf, uint32_t seq_no)
  858. {
  859. struct ieee80211_frame *ptr_wh = NULL;
  860. uint16_t wh_seq = 0;
  861. if (!nbuf)
  862. return;
  863. /* update sequence number in frame header */
  864. ptr_wh = (struct ieee80211_frame *)qdf_nbuf_data(nbuf);
  865. wh_seq = (seq_no & 0xFFF) << 4;
  866. qdf_mem_copy(ptr_wh->i_seq, &wh_seq, sizeof(uint16_t));
  867. }
  868. /**
  869. * dp_send_mpdu_info_to_stack(): Function to deliver mpdu info to stack
  870. * to upper layer
  871. * @pdev: DP pdev handle
  872. * @nbuf_ppdu_desc_list: ppdu_desc_list per sched cmd id
  873. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  874. *
  875. * return: status
  876. */
  877. static
  878. QDF_STATUS dp_send_mpdu_info_to_stack(struct dp_pdev *pdev,
  879. qdf_nbuf_t nbuf_ppdu_desc_list[],
  880. uint32_t ppdu_desc_cnt)
  881. {
  882. uint32_t ppdu_id;
  883. uint32_t desc_cnt;
  884. for (desc_cnt = 0; desc_cnt < ppdu_desc_cnt; desc_cnt++) {
  885. struct cdp_tx_completion_ppdu *ppdu_desc;
  886. uint32_t mpdu_tried;
  887. uint32_t num_mpdu;
  888. uint32_t k;
  889. uint32_t i;
  890. uint32_t seq_no = 0;
  891. uint32_t len;
  892. qdf_nbuf_t mpdu_nbuf;
  893. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  894. qdf_nbuf_data(nbuf_ppdu_desc_list[desc_cnt]);
  895. if (!ppdu_desc)
  896. continue;
  897. ppdu_id = ppdu_desc->ppdu_id;
  898. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_CTRL) {
  899. struct cdp_tx_indication_info tx_capture_info;
  900. struct cdp_tx_indication_mpdu_info *mpdu_info;
  901. mpdu_info = &tx_capture_info.mpdu_info;
  902. mpdu_info->channel = ppdu_desc->channel;
  903. mpdu_info->frame_type = ppdu_desc->frame_type;
  904. mpdu_info->ppdu_start_timestamp =
  905. ppdu_desc->ppdu_start_timestamp;
  906. mpdu_info->ppdu_end_timestamp =
  907. ppdu_desc->ppdu_end_timestamp;
  908. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  909. mpdu_info->seq_no = seq_no;
  910. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  911. /* update cdp_tx_indication_mpdu_info */
  912. dp_tx_update_user_mpdu_info(ppdu_desc->ppdu_id,
  913. &tx_capture_info.mpdu_info,
  914. &ppdu_desc->user[0]);
  915. tx_capture_info.mpdu_info.channel_num =
  916. pdev->operating_channel;
  917. if (qdf_nbuf_is_queue_empty(&ppdu_desc->mpdu_q))
  918. continue;
  919. tx_capture_info.mpdu_nbuf =
  920. qdf_nbuf_queue_remove(&ppdu_desc->mpdu_q);
  921. /*
  922. * send MPDU to osif layer
  923. * do we need to update mpdu_info before tranmit
  924. * get current mpdu_nbuf
  925. */
  926. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  927. &tx_capture_info, HTT_INVALID_PEER,
  928. WDI_NO_VAL, pdev->pdev_id);
  929. continue;
  930. }
  931. ppdu_id = ppdu_desc->ppdu_id;
  932. /* find mpdu tried is same as success mpdu */
  933. mpdu_tried = ppdu_desc->user[0].mpdu_tried_ucast +
  934. ppdu_desc->user[0].mpdu_tried_mcast;
  935. num_mpdu = ppdu_desc->user[0].mpdu_success;
  936. /* get length */
  937. len = qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);
  938. /* find list of missing sequence */
  939. for (i = 0, k = 0; i < mpdu_tried; i++) {
  940. struct cdp_tx_indication_info tx_capture_info;
  941. struct cdp_tx_indication_mpdu_info *mpdu_info;
  942. mpdu_info = &tx_capture_info.mpdu_info;
  943. /* missed seq number */
  944. seq_no = ppdu_desc->user[0].start_seq + i;
  945. if (!(ppdu_desc->user[0].failed_bitmap[k] & 1 << i)) {
  946. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  947. QDF_TRACE_LEVEL_ERROR,
  948. "%s: finding missing seq no: %d in other ppdu list cnt[%d]",
  949. __func__, seq_no, ppdu_desc_cnt);
  950. /* send rest of ppdu_desc list */
  951. mpdu_nbuf = get_mpdu_clone_from_next_ppdu(
  952. nbuf_ppdu_desc_list + desc_cnt,
  953. ppdu_desc_cnt - desc_cnt,
  954. seq_no,
  955. ppdu_desc->ppdu_id);
  956. /* check mpdu_nbuf NULL */
  957. if (!mpdu_nbuf)
  958. continue;
  959. qdf_nbuf_queue_add(&ppdu_desc->mpdu_q,
  960. mpdu_nbuf);
  961. } else {
  962. /* any error case we need to handle */
  963. }
  964. /* k need to be increase, if i increased more than 32 */
  965. tx_capture_info.mpdu_nbuf =
  966. qdf_nbuf_queue_remove(&ppdu_desc->mpdu_q);
  967. if (!tx_capture_info.mpdu_nbuf)
  968. continue;
  969. mpdu_info->channel = ppdu_desc->channel;
  970. mpdu_info->frame_type = ppdu_desc->frame_type;
  971. mpdu_info->ppdu_start_timestamp =
  972. ppdu_desc->ppdu_start_timestamp;
  973. mpdu_info->ppdu_end_timestamp =
  974. ppdu_desc->ppdu_end_timestamp;
  975. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  976. mpdu_info->seq_no = seq_no;
  977. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  978. /* update cdp_tx_indication_mpdu_info */
  979. dp_tx_update_user_mpdu_info(ppdu_id,
  980. &tx_capture_info.mpdu_info,
  981. &ppdu_desc->user[0]);
  982. tx_capture_info.mpdu_info.channel_num =
  983. pdev->operating_channel;
  984. dp_tx_update_sequence_number(tx_capture_info.mpdu_nbuf,
  985. seq_no);
  986. /*
  987. * send MPDU to osif layer
  988. * do we need to update mpdu_info before tranmit
  989. * get current mpdu_nbuf
  990. */
  991. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  992. &tx_capture_info,
  993. HTT_INVALID_PEER,
  994. WDI_NO_VAL, pdev->pdev_id);
  995. }
  996. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  997. qdf_nbuf_free(nbuf_ppdu_desc_list[desc_cnt]);
  998. }
  999. return QDF_STATUS_SUCCESS;
  1000. }
  1001. /*
  1002. * number of data PPDU scheduled in a burst is 10
  1003. * which doesn't include BAR and other non data frame
  1004. * ~50 is maximum scheduled ppdu count
  1005. */
  1006. #define SCHED_MAX_PPDU_CNT 50
  1007. /**
  1008. * dp_tx_ppdu_stats_process - Deferred PPDU stats handler
  1009. * @context: Opaque work context (PDEV)
  1010. *
  1011. * Return: none
  1012. */
  1013. void dp_tx_ppdu_stats_process(void *context)
  1014. {
  1015. uint32_t curr_sched_cmdid;
  1016. uint32_t last_ppdu_id;
  1017. uint32_t ppdu_cnt;
  1018. uint32_t ppdu_desc_cnt = 0;
  1019. uint32_t j;
  1020. struct dp_pdev *pdev = (struct dp_pdev *)context;
  1021. struct ppdu_info *ppdu_info, *tmp_ppdu_info;
  1022. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  1023. struct ppdu_info *sched_ppdu_list[SCHED_MAX_PPDU_CNT];
  1024. qdf_nbuf_t nbuf_ppdu_desc_list[SCHED_MAX_PPDU_CNT];
  1025. struct dp_pdev_tx_capture *ptr_tx_cap;
  1026. ptr_tx_cap = &pdev->tx_capture;
  1027. /* Move the PPDU entries to defer list */
  1028. qdf_spin_lock_bh(&ptr_tx_cap->ppdu_stats_lock);
  1029. STAILQ_CONCAT(&ptr_tx_cap->ppdu_stats_defer_queue,
  1030. &ptr_tx_cap->ppdu_stats_queue);
  1031. ptr_tx_cap->ppdu_stats_queue_depth = 0;
  1032. qdf_spin_unlock_bh(&ptr_tx_cap->ppdu_stats_lock);
  1033. while (!STAILQ_EMPTY(&ptr_tx_cap->ppdu_stats_defer_queue)) {
  1034. ppdu_info =
  1035. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  1036. curr_sched_cmdid = ppdu_info->sched_cmdid;
  1037. ppdu_cnt = 0;
  1038. STAILQ_FOREACH_SAFE(ppdu_info,
  1039. &ptr_tx_cap->ppdu_stats_defer_queue,
  1040. ppdu_info_queue_elem, tmp_ppdu_info) {
  1041. if (curr_sched_cmdid != ppdu_info->sched_cmdid)
  1042. break;
  1043. sched_ppdu_list[ppdu_cnt++] = ppdu_info;
  1044. qdf_assert_always(ppdu_cnt <= SCHED_MAX_PPDU_CNT);
  1045. }
  1046. if (ppdu_info && (curr_sched_cmdid == ppdu_info->sched_cmdid) &&
  1047. ptr_tx_cap->ppdu_stats_next_sched < now_ms)
  1048. break;
  1049. last_ppdu_id = sched_ppdu_list[ppdu_cnt - 1]->ppdu_id;
  1050. STAILQ_REMOVE_HEAD_UNTIL(&ptr_tx_cap->ppdu_stats_defer_queue,
  1051. sched_ppdu_list[ppdu_cnt - 1],
  1052. ppdu_info_queue_elem);
  1053. ppdu_desc_cnt = 0;
  1054. /* Process tx buffer list based on last_ppdu_id stored above */
  1055. for (j = 0; j < ppdu_cnt; j++) {
  1056. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  1057. struct dp_peer *peer = NULL;
  1058. qdf_nbuf_t nbuf;
  1059. uint32_t retries = 0;
  1060. uint32_t ret = 0;
  1061. qdf_nbuf_queue_t head_msdu;
  1062. uint32_t start_tsf = 0;
  1063. uint32_t end_tsf = 0;
  1064. uint16_t tid = 0;
  1065. uint32_t num_msdu = 0;
  1066. uint32_t qlen = 0;
  1067. qdf_nbuf_queue_init(&head_msdu);
  1068. ppdu_info = sched_ppdu_list[j];
  1069. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1070. qdf_nbuf_data(ppdu_info->nbuf);
  1071. pdev->tx_ppdu_proc++;
  1072. dp_ppdu_desc_user_stats_update(pdev, ppdu_info);
  1073. /*
  1074. * While processing/corelating Tx buffers, we should
  1075. * hold the entire PPDU list for the give sched_cmdid
  1076. * instead of freeing below.
  1077. */
  1078. nbuf = ppdu_info->nbuf;
  1079. qdf_mem_free(ppdu_info);
  1080. qdf_assert_always(nbuf);
  1081. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1082. qdf_nbuf_data(nbuf);
  1083. /* send WDI event */
  1084. if (!pdev->tx_capture_enabled) {
  1085. /**
  1086. * Deliver PPDU stats only for valid (acked)
  1087. * data frames if sniffer mode is not enabled.
  1088. * If sniffer mode is enabled,
  1089. * PPDU stats for all frames including
  1090. * mgmt/control frames should be delivered
  1091. * to upper layer
  1092. */
  1093. if (pdev->tx_sniffer_enable ||
  1094. pdev->mcopy_mode) {
  1095. dp_wdi_event_handler(
  1096. WDI_EVENT_TX_PPDU_DESC,
  1097. pdev->soc,
  1098. nbuf,
  1099. HTT_INVALID_PEER,
  1100. WDI_NO_VAL,
  1101. pdev->pdev_id);
  1102. } else {
  1103. if (ppdu_desc->num_mpdu != 0 &&
  1104. ppdu_desc->num_users != 0 &&
  1105. (ppdu_desc->frame_ctrl &
  1106. HTT_FRAMECTRL_DATATYPE)) {
  1107. dp_wdi_event_handler(
  1108. WDI_EVENT_TX_PPDU_DESC,
  1109. pdev->soc,
  1110. nbuf,
  1111. HTT_INVALID_PEER,
  1112. WDI_NO_VAL,
  1113. pdev->pdev_id);
  1114. } else {
  1115. qdf_nbuf_free(nbuf);
  1116. }
  1117. }
  1118. continue;
  1119. }
  1120. peer = dp_peer_find_by_id(pdev->soc,
  1121. ppdu_desc->user[0].peer_id);
  1122. /*
  1123. * peer can be NULL
  1124. */
  1125. if (!peer) {
  1126. qdf_nbuf_free(nbuf);
  1127. continue;
  1128. }
  1129. /*
  1130. * check whether it is bss peer,
  1131. * if bss_peer no need to process further
  1132. */
  1133. if (!peer->bss_peer &&
  1134. pdev->tx_capture_enabled &&
  1135. (ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA) &&
  1136. (!ppdu_desc->user[0].completion_status)) {
  1137. /* print the bit map */
  1138. dp_tx_print_bitmap(pdev, ppdu_desc,
  1139. 0, ppdu_desc->ppdu_id);
  1140. if (ppdu_desc->user[0].tid > DP_NON_QOS_TID) {
  1141. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1142. QDF_TRACE_LEVEL_ERROR,
  1143. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  1144. __func__,
  1145. ppdu_desc->ppdu_id,
  1146. ppdu_desc->user[0].peer_id,
  1147. ppdu_desc->user[0].tid);
  1148. dp_peer_unref_del_find_by_id(peer);
  1149. qdf_nbuf_free(nbuf);
  1150. continue;
  1151. }
  1152. dequeue_msdu_again:
  1153. tid = ppdu_desc->user[0].tid;
  1154. num_msdu = ppdu_desc->user[0].num_msdu;
  1155. start_tsf = ppdu_desc->ppdu_start_timestamp;
  1156. end_tsf = ppdu_desc->ppdu_end_timestamp;
  1157. /*
  1158. * retrieve msdu buffer based on ppdu_id & tid
  1159. * based msdu queue and store it in local queue
  1160. * sometimes, wbm comes late than per ppdu
  1161. * stats. Assumption: all packets are SU,
  1162. * and packets comes in order
  1163. */
  1164. ret = dp_tx_msdu_dequeue(peer,
  1165. ppdu_desc->ppdu_id,
  1166. tid, num_msdu,
  1167. &head_msdu, start_tsf,
  1168. end_tsf);
  1169. if (!ret && (++retries < 3)) {
  1170. /* wait for wbm to complete */
  1171. qdf_sleep(100);
  1172. goto dequeue_msdu_again;
  1173. }
  1174. if (qdf_nbuf_is_queue_empty(&head_msdu)) {
  1175. dp_peer_unref_del_find_by_id(peer);
  1176. /*
  1177. * head msdu is NULL
  1178. * free nbuf as no processing required
  1179. */
  1180. qdf_nbuf_free(nbuf);
  1181. continue;
  1182. }
  1183. /*
  1184. * now head_msdu hold - msdu list for that
  1185. * particular ppdu_id, restitch mpdu from
  1186. * msdu and create a mpdu queue
  1187. */
  1188. dp_tx_mon_restitch_mpdu_from_msdus(pdev,
  1189. peer,
  1190. ppdu_desc,
  1191. &head_msdu);
  1192. /*
  1193. * sanity: free local head msdu queue
  1194. * do we need this ?
  1195. */
  1196. qdf_nbuf_queue_free(&head_msdu);
  1197. nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
  1198. qlen = qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);
  1199. /* print ppdu_desc info for debugging purpose */
  1200. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1201. QDF_TRACE_LEVEL_INFO,
  1202. "%s: ppdu[%d], p_id[%d], tid[%d], n_mpdu[%d %d] n_msdu[%d] retr[%d] qlen[%d] s_tsf[%u] dur[%u] seq[%d] [%d %d]",
  1203. __func__, ppdu_desc->ppdu_id,
  1204. ppdu_desc->user[0].peer_id,
  1205. ppdu_desc->user[0].tid,
  1206. ppdu_desc->num_mpdu,
  1207. ppdu_desc->user[0].mpdu_success,
  1208. ppdu_desc->num_msdu, retries,
  1209. qlen,
  1210. ppdu_desc->ppdu_start_timestamp,
  1211. ppdu_desc->tx_duration,
  1212. ppdu_desc->user[0].start_seq,
  1213. ppdu_cnt,
  1214. ppdu_desc_cnt);
  1215. nbuf->next =
  1216. qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
  1217. } else if (ppdu_desc->frame_type ==
  1218. CDP_PPDU_FTYPE_CTRL &&
  1219. pdev->tx_capture_enabled) {
  1220. nbuf->next =
  1221. qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
  1222. nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
  1223. } else {
  1224. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1225. qdf_nbuf_free(nbuf);
  1226. }
  1227. dp_peer_unref_del_find_by_id(peer);
  1228. }
  1229. /*
  1230. * At this point we have mpdu queued per ppdu_desc
  1231. * based on packet capture flags send mpdu info to upper stack
  1232. */
  1233. if (pdev->tx_capture_enabled)
  1234. dp_send_mpdu_info_to_stack(pdev,
  1235. nbuf_ppdu_desc_list,
  1236. ppdu_desc_cnt);
  1237. }
  1238. }
  1239. /**
  1240. * dp_ppdu_desc_deliver(): Function to deliver Tx PPDU status descriptor
  1241. * to upper layer
  1242. * @pdev: DP pdev handle
  1243. * @ppdu_info: per PPDU TLV descriptor
  1244. *
  1245. * return: void
  1246. */
  1247. void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
  1248. struct ppdu_info *ppdu_info)
  1249. {
  1250. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  1251. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  1252. TAILQ_REMOVE(&pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
  1253. pdev->list_depth--;
  1254. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1255. qdf_nbuf_data(ppdu_info->nbuf);
  1256. /*
  1257. * before schdeuling, for management frame
  1258. * copy last mgmt nbuf to ppdu_desc
  1259. */
  1260. if (ppdu_info->ppdu_id == pdev->mgmtctrl_frm_info.ppdu_id &&
  1261. pdev->mgmtctrl_frm_info.last_nbuf) {
  1262. qdf_nbuf_queue_add(&ppdu_desc->mpdu_q,
  1263. pdev->mgmtctrl_frm_info.last_nbuf);
  1264. pdev->mgmtctrl_frm_info.last_nbuf = NULL;
  1265. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  1266. ppdu_desc->ppdu_id = ppdu_info->ppdu_id;
  1267. }
  1268. qdf_spin_lock_bh(&pdev->tx_capture.ppdu_stats_lock);
  1269. STAILQ_INSERT_TAIL(&pdev->tx_capture.ppdu_stats_queue,
  1270. ppdu_info, ppdu_info_queue_elem);
  1271. pdev->tx_capture.ppdu_stats_queue_depth++;
  1272. qdf_spin_unlock_bh(&pdev->tx_capture.ppdu_stats_lock);
  1273. if ((pdev->tx_capture.ppdu_stats_queue_depth >
  1274. DP_TX_PPDU_PROC_THRESHOLD) ||
  1275. (pdev->tx_capture.ppdu_stats_next_sched > now_ms)) {
  1276. qdf_queue_work(0, pdev->tx_capture.ppdu_stats_workqueue,
  1277. &pdev->tx_capture.ppdu_stats_work);
  1278. pdev->tx_capture.ppdu_stats_next_sched =
  1279. now_ms + DP_TX_PPDU_PROC_TIMEOUT;
  1280. }
  1281. }
  1282. #endif