dp_rx_desc.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535
  1. /*
  2. * Copyright (c) 2016-2020 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 "dp_types.h"
  19. #include "dp_rx.h"
  20. #include "dp_ipa.h"
  21. #ifdef RX_DESC_MULTI_PAGE_ALLOC
  22. A_COMPILE_TIME_ASSERT(cookie_size_check,
  23. PAGE_SIZE / sizeof(union dp_rx_desc_list_elem_t) <=
  24. 1 << DP_RX_DESC_PAGE_ID_SHIFT);
  25. /*
  26. * dp_rx_desc_pool_is_allocated() - check if memory is allocated for the
  27. * rx descriptor pool
  28. *
  29. * @rx_desc_pool: rx descriptor pool pointer
  30. * Return: QDF_STATUS QDF_STATUS_SUCCESS
  31. * QDF_STATUS_E_NOMEM
  32. */
  33. QDF_STATUS dp_rx_desc_pool_is_allocated(struct rx_desc_pool *rx_desc_pool)
  34. {
  35. if (!rx_desc_pool->desc_pages.num_pages) {
  36. dp_err("Multi page alloc fail, size=%d, elem=%d",
  37. rx_desc_pool->elem_size, rx_desc_pool->pool_size);
  38. return QDF_STATUS_E_NOMEM;
  39. }
  40. return QDF_STATUS_SUCCESS;
  41. }
  42. /*
  43. * dp_rx_desc_pool_alloc() - Allocate a memory pool for software rx
  44. * descriptors
  45. *
  46. * @soc: core txrx main context
  47. * @num_elem: number of rx descriptors (size of the pool)
  48. * @rx_desc_pool: rx descriptor pool pointer
  49. *
  50. * Return: QDF_STATUS QDF_STATUS_SUCCESS
  51. * QDF_STATUS_E_NOMEM
  52. * QDF_STATUS_E_FAULT
  53. */
  54. QDF_STATUS dp_rx_desc_pool_alloc(struct dp_soc *soc,
  55. uint32_t num_elem,
  56. struct rx_desc_pool *rx_desc_pool)
  57. {
  58. uint32_t desc_size;
  59. union dp_rx_desc_list_elem_t *rx_desc_elem;
  60. desc_size = sizeof(*rx_desc_elem);
  61. rx_desc_pool->elem_size = desc_size;
  62. dp_desc_multi_pages_mem_alloc(soc, rx_desc_pool->desc_type,
  63. &rx_desc_pool->desc_pages,
  64. desc_size, num_elem, 0, true);
  65. if (!rx_desc_pool->desc_pages.num_pages) {
  66. qdf_err("Multi page alloc fail,size=%d, elem=%d",
  67. desc_size, num_elem);
  68. return QDF_STATUS_E_NOMEM;
  69. }
  70. if (qdf_mem_multi_page_link(soc->osdev,
  71. &rx_desc_pool->desc_pages,
  72. desc_size, num_elem, true)) {
  73. qdf_err("overflow num link,size=%d, elem=%d",
  74. desc_size, num_elem);
  75. goto free_rx_desc_pool;
  76. }
  77. return QDF_STATUS_SUCCESS;
  78. free_rx_desc_pool:
  79. dp_rx_desc_pool_free(soc, rx_desc_pool);
  80. return QDF_STATUS_E_FAULT;
  81. }
  82. /*
  83. * dp_rx_desc_pool_init() - Initialize the software RX descriptor pool
  84. * convert the pool of memory into a list of
  85. * rx descriptors and create locks to access this
  86. * list of rx descriptors.
  87. *
  88. * @soc: core txrx main context
  89. * @pool_id: pool_id which is one of 3 mac_ids
  90. * @pool_size: size of the rx descriptor pool
  91. * @rx_desc_pool: rx descriptor pool pointer
  92. */
  93. void dp_rx_desc_pool_init(struct dp_soc *soc, uint32_t pool_id,
  94. uint32_t pool_size, struct rx_desc_pool *rx_desc_pool)
  95. {
  96. uint32_t id, page_id, offset, num_desc_per_page;
  97. uint32_t count = 0;
  98. union dp_rx_desc_list_elem_t *rx_desc_elem;
  99. /* Initialize the lock */
  100. qdf_spinlock_create(&rx_desc_pool->lock);
  101. qdf_spin_lock_bh(&rx_desc_pool->lock);
  102. rx_desc_pool->pool_size = pool_size;
  103. num_desc_per_page = rx_desc_pool->desc_pages.num_element_per_page;
  104. rx_desc_pool->freelist = (union dp_rx_desc_list_elem_t *)
  105. *rx_desc_pool->desc_pages.cacheable_pages;
  106. rx_desc_elem = rx_desc_pool->freelist;
  107. while (rx_desc_elem) {
  108. page_id = count / num_desc_per_page;
  109. offset = count % num_desc_per_page;
  110. /*
  111. * Below cookie size is from REO destination ring
  112. * reo_destination_ring -> buffer_addr_info -> sw_buffer_cookie
  113. * cookie size = 21 bits
  114. * 8 bits - offset
  115. * 8 bits - page ID
  116. * 4 bits - pool ID
  117. */
  118. id = ((pool_id << DP_RX_DESC_POOL_ID_SHIFT) |
  119. (page_id << DP_RX_DESC_PAGE_ID_SHIFT) |
  120. offset);
  121. rx_desc_elem->rx_desc.cookie = id;
  122. rx_desc_elem->rx_desc.pool_id = pool_id;
  123. rx_desc_elem->rx_desc.in_use = 0;
  124. rx_desc_elem = rx_desc_elem->next;
  125. count++;
  126. }
  127. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  128. }
  129. union dp_rx_desc_list_elem_t *dp_rx_desc_find(uint16_t page_id, uint16_t offset,
  130. struct rx_desc_pool *rx_desc_pool)
  131. {
  132. return rx_desc_pool->desc_pages.cacheable_pages[page_id] +
  133. rx_desc_pool->elem_size * offset;
  134. }
  135. static QDF_STATUS dp_rx_desc_nbuf_collect(struct dp_soc *soc,
  136. struct rx_desc_pool *rx_desc_pool,
  137. qdf_nbuf_t *nbuf_unmap_list,
  138. qdf_nbuf_t *nbuf_free_list)
  139. {
  140. uint32_t i, num_desc, page_id, offset, num_desc_per_page;
  141. union dp_rx_desc_list_elem_t *rx_desc_elem;
  142. struct dp_rx_desc *rx_desc;
  143. if (qdf_unlikely(!(rx_desc_pool->desc_pages.cacheable_pages))) {
  144. qdf_err("No pages found on this desc pool");
  145. return QDF_STATUS_E_INVAL;
  146. }
  147. num_desc = rx_desc_pool->pool_size;
  148. num_desc_per_page = rx_desc_pool->desc_pages.num_element_per_page;
  149. for (i = 0; i < num_desc; i++) {
  150. page_id = i / num_desc_per_page;
  151. offset = i % num_desc_per_page;
  152. rx_desc_elem = dp_rx_desc_find(page_id, offset, rx_desc_pool);
  153. rx_desc = &rx_desc_elem->rx_desc;
  154. dp_rx_desc_free_dbg_info(rx_desc);
  155. if (rx_desc->in_use) {
  156. if (!rx_desc->unmapped) {
  157. DP_RX_HEAD_APPEND(*nbuf_unmap_list,
  158. rx_desc->nbuf);
  159. rx_desc->unmapped = 1;
  160. } else {
  161. DP_RX_HEAD_APPEND(*nbuf_free_list,
  162. rx_desc->nbuf);
  163. }
  164. }
  165. }
  166. return QDF_STATUS_SUCCESS;
  167. }
  168. static void dp_rx_desc_nbuf_cleanup(struct dp_soc *soc,
  169. qdf_nbuf_t nbuf_unmap_list,
  170. qdf_nbuf_t nbuf_free_list,
  171. uint16_t buf_size)
  172. {
  173. qdf_nbuf_t nbuf = nbuf_unmap_list;
  174. qdf_nbuf_t next;
  175. while (nbuf) {
  176. next = nbuf->next;
  177. if (dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf, buf_size,
  178. false))
  179. dp_info_rl("Unable to unmap nbuf: %pK", nbuf);
  180. qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf,
  181. QDF_DMA_BIDIRECTIONAL, buf_size);
  182. qdf_nbuf_free(nbuf);
  183. nbuf = next;
  184. }
  185. nbuf = nbuf_free_list;
  186. while (nbuf) {
  187. next = nbuf->next;
  188. qdf_nbuf_free(nbuf);
  189. nbuf = next;
  190. }
  191. }
  192. void dp_rx_desc_nbuf_and_pool_free(struct dp_soc *soc, uint32_t pool_id,
  193. struct rx_desc_pool *rx_desc_pool)
  194. {
  195. qdf_nbuf_t nbuf_unmap_list = NULL;
  196. qdf_nbuf_t nbuf_free_list = NULL;
  197. qdf_spin_lock_bh(&rx_desc_pool->lock);
  198. dp_rx_desc_nbuf_collect(soc, rx_desc_pool,
  199. &nbuf_unmap_list, &nbuf_free_list);
  200. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  201. dp_rx_desc_nbuf_cleanup(soc, nbuf_unmap_list, nbuf_free_list,
  202. rx_desc_pool->buf_size);
  203. qdf_spinlock_destroy(&rx_desc_pool->lock);
  204. }
  205. void dp_rx_desc_nbuf_free(struct dp_soc *soc,
  206. struct rx_desc_pool *rx_desc_pool)
  207. {
  208. qdf_nbuf_t nbuf_unmap_list = NULL;
  209. qdf_nbuf_t nbuf_free_list = NULL;
  210. qdf_spin_lock_bh(&rx_desc_pool->lock);
  211. dp_rx_desc_nbuf_collect(soc, rx_desc_pool,
  212. &nbuf_unmap_list, &nbuf_free_list);
  213. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  214. dp_rx_desc_nbuf_cleanup(soc, nbuf_unmap_list, nbuf_free_list,
  215. rx_desc_pool->buf_size);
  216. }
  217. void dp_rx_desc_pool_free(struct dp_soc *soc,
  218. struct rx_desc_pool *rx_desc_pool)
  219. {
  220. if (qdf_unlikely(!(rx_desc_pool->desc_pages.cacheable_pages)))
  221. return;
  222. dp_desc_multi_pages_mem_free(soc, rx_desc_pool->desc_type,
  223. &rx_desc_pool->desc_pages, 0, true);
  224. }
  225. void dp_rx_desc_pool_deinit(struct dp_soc *soc,
  226. struct rx_desc_pool *rx_desc_pool)
  227. {
  228. qdf_spin_lock_bh(&rx_desc_pool->lock);
  229. rx_desc_pool->freelist = NULL;
  230. rx_desc_pool->pool_size = 0;
  231. /* Deinitialize rx mon desr frag flag */
  232. rx_desc_pool->rx_mon_dest_frag_enable = false;
  233. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  234. qdf_spinlock_destroy(&rx_desc_pool->lock);
  235. }
  236. #else
  237. /*
  238. * dp_rx_desc_pool_is_allocated() - check if memory is allocated for the
  239. * rx descriptor pool
  240. *
  241. * @rx_desc_pool: rx descriptor pool pointer
  242. *
  243. * Return: QDF_STATUS QDF_STATUS_SUCCESS
  244. * QDF_STATUS_E_NOMEM
  245. */
  246. QDF_STATUS dp_rx_desc_pool_is_allocated(struct rx_desc_pool *rx_desc_pool)
  247. {
  248. if (!rx_desc_pool->array) {
  249. dp_err("nss-wifi<4> skip Rx refil");
  250. return QDF_STATUS_E_NOMEM;
  251. }
  252. return QDF_STATUS_SUCCESS;
  253. }
  254. /*
  255. * dp_rx_desc_pool_alloc() - Allocate a memory pool for software rx
  256. * descriptors
  257. *
  258. * @soc: core txrx main context
  259. * @num_elem: number of rx descriptors (size of the pool)
  260. * @rx_desc_pool: rx descriptor pool pointer
  261. *
  262. * Return: QDF_STATUS QDF_STATUS_SUCCESS
  263. * QDF_STATUS_E_NOMEM
  264. * QDF_STATUS_E_FAULT
  265. */
  266. QDF_STATUS dp_rx_desc_pool_alloc(struct dp_soc *soc,
  267. uint32_t pool_size,
  268. struct rx_desc_pool *rx_desc_pool)
  269. {
  270. rx_desc_pool->array = qdf_mem_malloc(pool_size *
  271. sizeof(union dp_rx_desc_list_elem_t));
  272. if (!(rx_desc_pool->array)) {
  273. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,
  274. "RX Desc Pool allocation failed");
  275. return QDF_STATUS_E_NOMEM;
  276. }
  277. return QDF_STATUS_SUCCESS;
  278. }
  279. /*
  280. * dp_rx_desc_pool_init() - Initialize the software RX descriptor pool
  281. * convert the pool of memory into a list of
  282. * rx descriptors and create locks to access this
  283. * list of rx descriptors.
  284. *
  285. * @soc: core txrx main context
  286. * @pool_id: pool_id which is one of 3 mac_ids
  287. * @pool_size: size of the rx descriptor pool
  288. * @rx_desc_pool: rx descriptor pool pointer
  289. */
  290. void dp_rx_desc_pool_init(struct dp_soc *soc, uint32_t pool_id,
  291. uint32_t pool_size, struct rx_desc_pool *rx_desc_pool)
  292. {
  293. int i;
  294. /* Initialize the lock */
  295. qdf_spinlock_create(&rx_desc_pool->lock);
  296. qdf_spin_lock_bh(&rx_desc_pool->lock);
  297. rx_desc_pool->pool_size = pool_size;
  298. /* link SW rx descs into a freelist */
  299. rx_desc_pool->freelist = &rx_desc_pool->array[0];
  300. qdf_mem_zero(rx_desc_pool->freelist, rx_desc_pool->pool_size);
  301. for (i = 0; i <= rx_desc_pool->pool_size - 1; i++) {
  302. if (i == rx_desc_pool->pool_size - 1)
  303. rx_desc_pool->array[i].next = NULL;
  304. else
  305. rx_desc_pool->array[i].next =
  306. &rx_desc_pool->array[i + 1];
  307. rx_desc_pool->array[i].rx_desc.cookie = i | (pool_id << 18);
  308. rx_desc_pool->array[i].rx_desc.pool_id = pool_id;
  309. rx_desc_pool->array[i].rx_desc.in_use = 0;
  310. }
  311. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  312. }
  313. void dp_rx_desc_nbuf_and_pool_free(struct dp_soc *soc, uint32_t pool_id,
  314. struct rx_desc_pool *rx_desc_pool)
  315. {
  316. qdf_nbuf_t nbuf;
  317. int i;
  318. qdf_spin_lock_bh(&rx_desc_pool->lock);
  319. for (i = 0; i < rx_desc_pool->pool_size; i++) {
  320. if (rx_desc_pool->array[i].rx_desc.in_use) {
  321. nbuf = rx_desc_pool->array[i].rx_desc.nbuf;
  322. if (!(rx_desc_pool->array[i].rx_desc.unmapped)) {
  323. dp_ipa_handle_rx_buf_smmu_mapping(
  324. soc, nbuf,
  325. rx_desc_pool->buf_size,
  326. false);
  327. qdf_nbuf_unmap_nbytes_single(
  328. soc->osdev, nbuf,
  329. QDF_DMA_FROM_DEVICE,
  330. rx_desc_pool->buf_size);
  331. rx_desc_pool->array[i].rx_desc.unmapped = 1;
  332. }
  333. qdf_nbuf_free(nbuf);
  334. }
  335. }
  336. qdf_mem_free(rx_desc_pool->array);
  337. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  338. qdf_spinlock_destroy(&rx_desc_pool->lock);
  339. }
  340. void dp_rx_desc_nbuf_free(struct dp_soc *soc,
  341. struct rx_desc_pool *rx_desc_pool)
  342. {
  343. qdf_nbuf_t nbuf;
  344. int i;
  345. qdf_spin_lock_bh(&rx_desc_pool->lock);
  346. for (i = 0; i < rx_desc_pool->pool_size; i++) {
  347. if (rx_desc_pool->array[i].rx_desc.in_use) {
  348. nbuf = rx_desc_pool->array[i].rx_desc.nbuf;
  349. if (!(rx_desc_pool->array[i].rx_desc.unmapped)) {
  350. dp_ipa_handle_rx_buf_smmu_mapping(
  351. soc, nbuf,
  352. rx_desc_pool->buf_size,
  353. false);
  354. qdf_nbuf_unmap_nbytes_single(
  355. soc->osdev, nbuf,
  356. QDF_DMA_FROM_DEVICE,
  357. rx_desc_pool->buf_size);
  358. rx_desc_pool->array[i].rx_desc.unmapped = 1;
  359. }
  360. qdf_nbuf_free(nbuf);
  361. }
  362. }
  363. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  364. }
  365. /**
  366. * dp_rx_desc_frag_free() - Free desc frag buffer
  367. *
  368. * @soc: core txrx main context
  369. * @rx_desc_pool: rx descriptor pool pointer
  370. *
  371. * Return: None
  372. */
  373. #ifdef DP_RX_MON_MEM_FRAG
  374. void dp_rx_desc_frag_free(struct dp_soc *soc,
  375. struct rx_desc_pool *rx_desc_pool)
  376. {
  377. qdf_dma_addr_t paddr;
  378. qdf_frag_t vaddr;
  379. int i;
  380. qdf_spin_lock_bh(&rx_desc_pool->lock);
  381. for (i = 0; i < rx_desc_pool->pool_size; i++) {
  382. if (rx_desc_pool->array[i].rx_desc.in_use) {
  383. paddr = rx_desc_pool->array[i].rx_desc.paddr_buf_start;
  384. vaddr = rx_desc_pool->array[i].rx_desc.rx_buf_start;
  385. if (!(rx_desc_pool->array[i].rx_desc.unmapped)) {
  386. qdf_mem_unmap_page(soc->osdev, paddr,
  387. rx_desc_pool->buf_size,
  388. QDF_DMA_FROM_DEVICE);
  389. rx_desc_pool->array[i].rx_desc.unmapped = 1;
  390. }
  391. qdf_frag_free(vaddr);
  392. }
  393. }
  394. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  395. }
  396. #endif
  397. void dp_rx_desc_pool_free(struct dp_soc *soc,
  398. struct rx_desc_pool *rx_desc_pool)
  399. {
  400. qdf_mem_free(rx_desc_pool->array);
  401. }
  402. void dp_rx_desc_pool_deinit(struct dp_soc *soc,
  403. struct rx_desc_pool *rx_desc_pool)
  404. {
  405. qdf_spin_lock_bh(&rx_desc_pool->lock);
  406. rx_desc_pool->freelist = NULL;
  407. rx_desc_pool->pool_size = 0;
  408. /* Deinitialize rx mon desr frag flag */
  409. rx_desc_pool->rx_mon_dest_frag_enable = false;
  410. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  411. qdf_spinlock_destroy(&rx_desc_pool->lock);
  412. }
  413. #endif /* RX_DESC_MULTI_PAGE_ALLOC */
  414. /*
  415. * dp_rx_get_free_desc_list() - provide a list of descriptors from
  416. * the free rx desc pool.
  417. *
  418. * @soc: core txrx main context
  419. * @pool_id: pool_id which is one of 3 mac_ids
  420. * @rx_desc_pool: rx descriptor pool pointer
  421. * @num_descs: number of descs requested from freelist
  422. * @desc_list: attach the descs to this list (output parameter)
  423. * @tail: attach the point to last desc of free list (output parameter)
  424. *
  425. * Return: number of descs allocated from free list.
  426. */
  427. uint16_t dp_rx_get_free_desc_list(struct dp_soc *soc, uint32_t pool_id,
  428. struct rx_desc_pool *rx_desc_pool,
  429. uint16_t num_descs,
  430. union dp_rx_desc_list_elem_t **desc_list,
  431. union dp_rx_desc_list_elem_t **tail)
  432. {
  433. uint16_t count;
  434. qdf_spin_lock_bh(&rx_desc_pool->lock);
  435. *desc_list = *tail = rx_desc_pool->freelist;
  436. for (count = 0; count < num_descs; count++) {
  437. if (qdf_unlikely(!rx_desc_pool->freelist)) {
  438. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  439. return count;
  440. }
  441. *tail = rx_desc_pool->freelist;
  442. rx_desc_pool->freelist = rx_desc_pool->freelist->next;
  443. }
  444. (*tail)->next = NULL;
  445. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  446. return count;
  447. }
  448. /*
  449. * dp_rx_add_desc_list_to_free_list() - append unused desc_list back to
  450. * freelist.
  451. *
  452. * @soc: core txrx main context
  453. * @local_desc_list: local desc list provided by the caller
  454. * @tail: attach the point to last desc of local desc list
  455. * @pool_id: pool_id which is one of 3 mac_ids
  456. * @rx_desc_pool: rx descriptor pool pointer
  457. */
  458. void dp_rx_add_desc_list_to_free_list(struct dp_soc *soc,
  459. union dp_rx_desc_list_elem_t **local_desc_list,
  460. union dp_rx_desc_list_elem_t **tail,
  461. uint16_t pool_id,
  462. struct rx_desc_pool *rx_desc_pool)
  463. {
  464. union dp_rx_desc_list_elem_t *temp_list = NULL;
  465. qdf_spin_lock_bh(&rx_desc_pool->lock);
  466. temp_list = rx_desc_pool->freelist;
  467. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
  468. "temp_list: %pK, *local_desc_list: %pK, *tail: %pK (*tail)->next: %pK",
  469. temp_list, *local_desc_list, *tail, (*tail)->next);
  470. rx_desc_pool->freelist = *local_desc_list;
  471. (*tail)->next = temp_list;
  472. *tail = NULL;
  473. *local_desc_list = NULL;
  474. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  475. }