dp_rx_desc.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450
  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. qdf_mem_multi_pages_alloc(soc->osdev, &rx_desc_pool->desc_pages,
  63. desc_size, num_elem, 0, true);
  64. if (!rx_desc_pool->desc_pages.num_pages) {
  65. qdf_err("Multi page alloc fail,size=%d, elem=%d",
  66. desc_size, num_elem);
  67. return QDF_STATUS_E_NOMEM;
  68. }
  69. if (qdf_mem_multi_page_link(soc->osdev,
  70. &rx_desc_pool->desc_pages,
  71. desc_size, num_elem, true)) {
  72. qdf_err("overflow num link,size=%d, elem=%d",
  73. desc_size, num_elem);
  74. goto free_rx_desc_pool;
  75. }
  76. return QDF_STATUS_SUCCESS;
  77. free_rx_desc_pool:
  78. dp_rx_desc_pool_free(soc, rx_desc_pool);
  79. return QDF_STATUS_E_FAULT;
  80. }
  81. /*
  82. * dp_rx_desc_pool_init() - Initialize the software RX descriptor pool
  83. * convert the pool of memory into a list of
  84. * rx descriptors and create locks to access this
  85. * list of rx descriptors.
  86. *
  87. * @soc: core txrx main context
  88. * @pool_id: pool_id which is one of 3 mac_ids
  89. * @pool_size: size of the rx descriptor pool
  90. * @rx_desc_pool: rx descriptor pool pointer
  91. */
  92. void dp_rx_desc_pool_init(struct dp_soc *soc, uint32_t pool_id,
  93. uint32_t pool_size, struct rx_desc_pool *rx_desc_pool)
  94. {
  95. uint32_t id, page_id, offset, num_desc_per_page;
  96. uint32_t count = 0;
  97. union dp_rx_desc_list_elem_t *rx_desc_elem;
  98. /* Initialize the lock */
  99. qdf_spinlock_create(&rx_desc_pool->lock);
  100. qdf_spin_lock_bh(&rx_desc_pool->lock);
  101. rx_desc_pool->pool_size = pool_size;
  102. num_desc_per_page = rx_desc_pool->desc_pages.num_element_per_page;
  103. rx_desc_pool->freelist = (union dp_rx_desc_list_elem_t *)
  104. *rx_desc_pool->desc_pages.cacheable_pages;
  105. rx_desc_elem = rx_desc_pool->freelist;
  106. while (rx_desc_elem) {
  107. page_id = count / num_desc_per_page;
  108. offset = count % num_desc_per_page;
  109. /*
  110. * Below cookie size is from REO destination ring
  111. * reo_destination_ring -> buffer_addr_info -> sw_buffer_cookie
  112. * cookie size = 21 bits
  113. * 8 bits - offset
  114. * 8 bits - page ID
  115. * 4 bits - pool ID
  116. */
  117. id = ((pool_id << DP_RX_DESC_POOL_ID_SHIFT) |
  118. (page_id << DP_RX_DESC_PAGE_ID_SHIFT) |
  119. offset);
  120. rx_desc_elem->rx_desc.cookie = id;
  121. rx_desc_elem->rx_desc.pool_id = pool_id;
  122. rx_desc_elem->rx_desc.in_use = 0;
  123. rx_desc_elem = rx_desc_elem->next;
  124. count++;
  125. }
  126. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  127. }
  128. union dp_rx_desc_list_elem_t *dp_rx_desc_find(uint16_t page_id, uint16_t offset,
  129. struct rx_desc_pool *rx_desc_pool)
  130. {
  131. return rx_desc_pool->desc_pages.cacheable_pages[page_id] +
  132. rx_desc_pool->elem_size * offset;
  133. }
  134. static QDF_STATUS __dp_rx_desc_nbuf_free(struct dp_soc *soc,
  135. struct rx_desc_pool *rx_desc_pool)
  136. {
  137. uint32_t i, num_desc, page_id, offset, num_desc_per_page;
  138. union dp_rx_desc_list_elem_t *rx_desc_elem;
  139. struct dp_rx_desc *rx_desc;
  140. qdf_nbuf_t nbuf;
  141. if (qdf_unlikely(!(rx_desc_pool->
  142. desc_pages.cacheable_pages))) {
  143. qdf_err("No pages found on this desc pool");
  144. return QDF_STATUS_E_INVAL;
  145. }
  146. num_desc = rx_desc_pool->pool_size;
  147. num_desc_per_page =
  148. 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. if (rx_desc->in_use) {
  155. nbuf = rx_desc->nbuf;
  156. if (!rx_desc->unmapped) {
  157. dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
  158. false);
  159. qdf_nbuf_unmap_single(soc->osdev, nbuf,
  160. QDF_DMA_BIDIRECTIONAL);
  161. }
  162. qdf_nbuf_free(nbuf);
  163. }
  164. }
  165. return QDF_STATUS_SUCCESS;
  166. }
  167. void dp_rx_desc_nbuf_and_pool_free(struct dp_soc *soc, uint32_t pool_id,
  168. struct rx_desc_pool *rx_desc_pool)
  169. {
  170. QDF_STATUS qdf_status;
  171. qdf_spin_lock_bh(&rx_desc_pool->lock);
  172. qdf_status = __dp_rx_desc_nbuf_free(soc, rx_desc_pool);
  173. if (QDF_IS_STATUS_SUCCESS(qdf_status))
  174. dp_rx_desc_pool_free(soc, rx_desc_pool);
  175. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  176. qdf_spinlock_destroy(&rx_desc_pool->lock);
  177. }
  178. void dp_rx_desc_nbuf_free(struct dp_soc *soc,
  179. struct rx_desc_pool *rx_desc_pool)
  180. {
  181. qdf_spin_lock_bh(&rx_desc_pool->lock);
  182. __dp_rx_desc_nbuf_free(soc, rx_desc_pool);
  183. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  184. }
  185. void dp_rx_desc_pool_free(struct dp_soc *soc,
  186. struct rx_desc_pool *rx_desc_pool)
  187. {
  188. if (qdf_unlikely(!(rx_desc_pool->desc_pages.cacheable_pages)))
  189. return;
  190. qdf_mem_multi_pages_free(soc->osdev,
  191. &rx_desc_pool->desc_pages, 0, true);
  192. }
  193. void dp_rx_desc_pool_deinit(struct dp_soc *soc,
  194. struct rx_desc_pool *rx_desc_pool)
  195. {
  196. qdf_spin_lock_bh(&rx_desc_pool->lock);
  197. rx_desc_pool->freelist = NULL;
  198. rx_desc_pool->pool_size = 0;
  199. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  200. qdf_spinlock_destroy(&rx_desc_pool->lock);
  201. }
  202. #else
  203. /*
  204. * dp_rx_desc_pool_is_allocated() - check if memory is allocated for the
  205. * rx descriptor pool
  206. *
  207. * @rx_desc_pool: rx descriptor pool pointer
  208. *
  209. * Return: QDF_STATUS QDF_STATUS_SUCCESS
  210. * QDF_STATUS_E_NOMEM
  211. */
  212. QDF_STATUS dp_rx_desc_pool_is_allocated(struct rx_desc_pool *rx_desc_pool)
  213. {
  214. if (!rx_desc_pool->array) {
  215. dp_err("nss-wifi<4> skip Rx refil");
  216. return QDF_STATUS_E_NOMEM;
  217. }
  218. return QDF_STATUS_SUCCESS;
  219. }
  220. /*
  221. * dp_rx_desc_pool_alloc() - Allocate a memory pool for software rx
  222. * descriptors
  223. *
  224. * @soc: core txrx main context
  225. * @num_elem: number of rx descriptors (size of the pool)
  226. * @rx_desc_pool: rx descriptor pool pointer
  227. *
  228. * Return: QDF_STATUS QDF_STATUS_SUCCESS
  229. * QDF_STATUS_E_NOMEM
  230. * QDF_STATUS_E_FAULT
  231. */
  232. QDF_STATUS dp_rx_desc_pool_alloc(struct dp_soc *soc,
  233. uint32_t pool_size,
  234. struct rx_desc_pool *rx_desc_pool)
  235. {
  236. rx_desc_pool->array = qdf_mem_malloc(pool_size *
  237. sizeof(union dp_rx_desc_list_elem_t));
  238. if (!(rx_desc_pool->array)) {
  239. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,
  240. "RX Desc Pool allocation failed");
  241. return QDF_STATUS_E_NOMEM;
  242. }
  243. return QDF_STATUS_SUCCESS;
  244. }
  245. /*
  246. * dp_rx_desc_pool_init() - Initialize the software RX descriptor pool
  247. * convert the pool of memory into a list of
  248. * rx descriptors and create locks to access this
  249. * list of rx descriptors.
  250. *
  251. * @soc: core txrx main context
  252. * @pool_id: pool_id which is one of 3 mac_ids
  253. * @pool_size: size of the rx descriptor pool
  254. * @rx_desc_pool: rx descriptor pool pointer
  255. */
  256. void dp_rx_desc_pool_init(struct dp_soc *soc, uint32_t pool_id,
  257. uint32_t pool_size, struct rx_desc_pool *rx_desc_pool)
  258. {
  259. int i;
  260. /* Initialize the lock */
  261. qdf_spinlock_create(&rx_desc_pool->lock);
  262. qdf_spin_lock_bh(&rx_desc_pool->lock);
  263. rx_desc_pool->pool_size = pool_size;
  264. /* link SW rx descs into a freelist */
  265. rx_desc_pool->freelist = &rx_desc_pool->array[0];
  266. qdf_mem_zero(rx_desc_pool->freelist, rx_desc_pool->pool_size);
  267. for (i = 0; i <= rx_desc_pool->pool_size - 1; i++) {
  268. if (i == rx_desc_pool->pool_size - 1)
  269. rx_desc_pool->array[i].next = NULL;
  270. else
  271. rx_desc_pool->array[i].next =
  272. &rx_desc_pool->array[i + 1];
  273. rx_desc_pool->array[i].rx_desc.cookie = i | (pool_id << 18);
  274. rx_desc_pool->array[i].rx_desc.pool_id = pool_id;
  275. rx_desc_pool->array[i].rx_desc.in_use = 0;
  276. }
  277. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  278. }
  279. void dp_rx_desc_nbuf_and_pool_free(struct dp_soc *soc, uint32_t pool_id,
  280. struct rx_desc_pool *rx_desc_pool)
  281. {
  282. qdf_nbuf_t nbuf;
  283. int i;
  284. qdf_spin_lock_bh(&rx_desc_pool->lock);
  285. for (i = 0; i < rx_desc_pool->pool_size; i++) {
  286. if (rx_desc_pool->array[i].rx_desc.in_use) {
  287. nbuf = rx_desc_pool->array[i].rx_desc.nbuf;
  288. if (!(rx_desc_pool->array[i].rx_desc.unmapped)) {
  289. dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
  290. false);
  291. qdf_nbuf_unmap_single(soc->osdev, nbuf,
  292. QDF_DMA_FROM_DEVICE);
  293. }
  294. qdf_nbuf_free(nbuf);
  295. }
  296. }
  297. qdf_mem_free(rx_desc_pool->array);
  298. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  299. qdf_spinlock_destroy(&rx_desc_pool->lock);
  300. }
  301. void dp_rx_desc_nbuf_free(struct dp_soc *soc,
  302. struct rx_desc_pool *rx_desc_pool)
  303. {
  304. qdf_nbuf_t nbuf;
  305. int i;
  306. qdf_spin_lock_bh(&rx_desc_pool->lock);
  307. for (i = 0; i < rx_desc_pool->pool_size; i++) {
  308. if (rx_desc_pool->array[i].rx_desc.in_use) {
  309. nbuf = rx_desc_pool->array[i].rx_desc.nbuf;
  310. if (!(rx_desc_pool->array[i].rx_desc.unmapped)) {
  311. dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
  312. false);
  313. qdf_nbuf_unmap_single(soc->osdev, nbuf,
  314. QDF_DMA_FROM_DEVICE);
  315. }
  316. qdf_nbuf_free(nbuf);
  317. }
  318. }
  319. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  320. }
  321. void dp_rx_desc_pool_free(struct dp_soc *soc,
  322. struct rx_desc_pool *rx_desc_pool)
  323. {
  324. qdf_mem_free(rx_desc_pool->array);
  325. }
  326. void dp_rx_desc_pool_deinit(struct dp_soc *soc,
  327. struct rx_desc_pool *rx_desc_pool)
  328. {
  329. qdf_spin_lock_bh(&rx_desc_pool->lock);
  330. rx_desc_pool->freelist = NULL;
  331. rx_desc_pool->pool_size = 0;
  332. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  333. qdf_spinlock_destroy(&rx_desc_pool->lock);
  334. }
  335. #endif /* RX_DESC_MULTI_PAGE_ALLOC */
  336. /*
  337. * dp_rx_get_free_desc_list() - provide a list of descriptors from
  338. * the free rx desc pool.
  339. *
  340. * @soc: core txrx main context
  341. * @pool_id: pool_id which is one of 3 mac_ids
  342. * @rx_desc_pool: rx descriptor pool pointer
  343. * @num_descs: number of descs requested from freelist
  344. * @desc_list: attach the descs to this list (output parameter)
  345. * @tail: attach the point to last desc of free list (output parameter)
  346. *
  347. * Return: number of descs allocated from free list.
  348. */
  349. uint16_t dp_rx_get_free_desc_list(struct dp_soc *soc, uint32_t pool_id,
  350. struct rx_desc_pool *rx_desc_pool,
  351. uint16_t num_descs,
  352. union dp_rx_desc_list_elem_t **desc_list,
  353. union dp_rx_desc_list_elem_t **tail)
  354. {
  355. uint16_t count;
  356. qdf_spin_lock_bh(&rx_desc_pool->lock);
  357. *desc_list = *tail = rx_desc_pool->freelist;
  358. for (count = 0; count < num_descs; count++) {
  359. if (qdf_unlikely(!rx_desc_pool->freelist)) {
  360. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  361. return count;
  362. }
  363. *tail = rx_desc_pool->freelist;
  364. rx_desc_pool->freelist = rx_desc_pool->freelist->next;
  365. }
  366. (*tail)->next = NULL;
  367. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  368. return count;
  369. }
  370. /*
  371. * dp_rx_add_desc_list_to_free_list() - append unused desc_list back to
  372. * freelist.
  373. *
  374. * @soc: core txrx main context
  375. * @local_desc_list: local desc list provided by the caller
  376. * @tail: attach the point to last desc of local desc list
  377. * @pool_id: pool_id which is one of 3 mac_ids
  378. * @rx_desc_pool: rx descriptor pool pointer
  379. */
  380. void dp_rx_add_desc_list_to_free_list(struct dp_soc *soc,
  381. union dp_rx_desc_list_elem_t **local_desc_list,
  382. union dp_rx_desc_list_elem_t **tail,
  383. uint16_t pool_id,
  384. struct rx_desc_pool *rx_desc_pool)
  385. {
  386. union dp_rx_desc_list_elem_t *temp_list = NULL;
  387. qdf_spin_lock_bh(&rx_desc_pool->lock);
  388. temp_list = rx_desc_pool->freelist;
  389. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
  390. "temp_list: %pK, *local_desc_list: %pK, *tail: %pK (*tail)->next: %pK",
  391. temp_list, *local_desc_list, *tail, (*tail)->next);
  392. rx_desc_pool->freelist = *local_desc_list;
  393. (*tail)->next = temp_list;
  394. *tail = NULL;
  395. qdf_spin_unlock_bh(&rx_desc_pool->lock);
  396. }