dp_reo.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220
  1. /*
  2. * Copyright (c) 2016-2021 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 "hal_reo.h"
  20. #include "dp_internal.h"
  21. #include <qdf_time.h>
  22. #define dp_reo_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP_REO, params)
  23. #define dp_reo_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP_REO, params)
  24. #define dp_reo_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP_REO, params)
  25. #define dp_reo_info(params...) \
  26. __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP_REO, ## params)
  27. #define dp_reo_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP_REO, params)
  28. #ifdef WLAN_FEATURE_DP_EVENT_HISTORY
  29. /**
  30. * dp_reo_cmd_srng_event_record() - Record reo cmds posted
  31. * to the reo cmd ring
  32. * @soc: dp soc handle
  33. * @type: reo cmd type
  34. * @post_status: command error status
  35. *
  36. * Return: None
  37. */
  38. static
  39. void dp_reo_cmd_srng_event_record(struct dp_soc *soc,
  40. enum hal_reo_cmd_type type,
  41. int post_status)
  42. {
  43. struct reo_cmd_event_history *cmd_event_history =
  44. &soc->stats.cmd_event_history;
  45. struct reo_cmd_event_record *record = cmd_event_history->cmd_record;
  46. int record_index;
  47. record_index = (qdf_atomic_inc_return(&cmd_event_history->index)) &
  48. (REO_CMD_EVENT_HIST_MAX - 1);
  49. record[record_index].cmd_type = type;
  50. record[record_index].cmd_return_status = post_status;
  51. record[record_index].timestamp = qdf_get_log_timestamp();
  52. }
  53. #else
  54. static inline
  55. void dp_reo_cmd_srng_event_record(struct dp_soc *soc,
  56. enum hal_reo_cmd_type type,
  57. int post_status)
  58. {
  59. }
  60. #endif /*WLAN_FEATURE_DP_EVENT_HISTORY */
  61. QDF_STATUS dp_reo_send_cmd(struct dp_soc *soc, enum hal_reo_cmd_type type,
  62. struct hal_reo_cmd_params *params,
  63. void (*callback_fn), void *data)
  64. {
  65. struct dp_reo_cmd_info *reo_cmd;
  66. int num;
  67. num = hal_reo_send_cmd(soc->hal_soc, soc->reo_cmd_ring.hal_srng, type,
  68. params);
  69. if (num < 0)
  70. return QDF_STATUS_E_INVAL;
  71. dp_reo_cmd_srng_event_record(soc, type, num);
  72. if (num < 0) {
  73. return QDF_STATUS_E_FAILURE;
  74. }
  75. if (callback_fn) {
  76. reo_cmd = qdf_mem_malloc(sizeof(*reo_cmd));
  77. if (!reo_cmd) {
  78. dp_err_log("alloc failed for REO cmd:%d!!",
  79. type);
  80. return QDF_STATUS_E_NOMEM;
  81. }
  82. reo_cmd->cmd = num;
  83. reo_cmd->cmd_type = type;
  84. reo_cmd->handler = callback_fn;
  85. reo_cmd->data = data;
  86. qdf_spin_lock_bh(&soc->rx.reo_cmd_lock);
  87. TAILQ_INSERT_TAIL(&soc->rx.reo_cmd_list, reo_cmd,
  88. reo_cmd_list_elem);
  89. qdf_spin_unlock_bh(&soc->rx.reo_cmd_lock);
  90. }
  91. return QDF_STATUS_SUCCESS;
  92. }
  93. uint32_t dp_reo_status_ring_handler(struct dp_intr *int_ctx, struct dp_soc *soc)
  94. {
  95. hal_ring_desc_t reo_desc;
  96. struct dp_reo_cmd_info *reo_cmd = NULL;
  97. union hal_reo_status reo_status;
  98. int num;
  99. int processed_count = 0;
  100. if (dp_srng_access_start(int_ctx, soc, soc->reo_status_ring.hal_srng)) {
  101. return processed_count;
  102. }
  103. reo_desc = hal_srng_dst_get_next(soc->hal_soc,
  104. soc->reo_status_ring.hal_srng);
  105. while (reo_desc) {
  106. uint16_t tlv = HAL_GET_TLV(reo_desc);
  107. processed_count++;
  108. switch (tlv) {
  109. case HAL_REO_QUEUE_STATS_STATUS_TLV:
  110. hal_reo_queue_stats_status(reo_desc,
  111. &reo_status.queue_status,
  112. soc->hal_soc);
  113. num = reo_status.queue_status.header.cmd_num;
  114. break;
  115. case HAL_REO_FLUSH_QUEUE_STATUS_TLV:
  116. hal_reo_flush_queue_status(reo_desc,
  117. &reo_status.fl_queue_status,
  118. soc->hal_soc);
  119. num = reo_status.fl_queue_status.header.cmd_num;
  120. break;
  121. case HAL_REO_FLUSH_CACHE_STATUS_TLV:
  122. hal_reo_flush_cache_status(reo_desc,
  123. &reo_status.fl_cache_status,
  124. soc->hal_soc);
  125. num = reo_status.fl_cache_status.header.cmd_num;
  126. break;
  127. case HAL_REO_UNBLK_CACHE_STATUS_TLV:
  128. hal_reo_unblock_cache_status(reo_desc, soc->hal_soc,
  129. &reo_status.unblk_cache_status);
  130. num = reo_status.unblk_cache_status.header.cmd_num;
  131. break;
  132. case HAL_REO_TIMOUT_LIST_STATUS_TLV:
  133. hal_reo_flush_timeout_list_status(reo_desc,
  134. &reo_status.fl_timeout_status,
  135. soc->hal_soc);
  136. num = reo_status.fl_timeout_status.header.cmd_num;
  137. break;
  138. case HAL_REO_DESC_THRES_STATUS_TLV:
  139. hal_reo_desc_thres_reached_status(reo_desc,
  140. &reo_status.thres_status,
  141. soc->hal_soc);
  142. num = reo_status.thres_status.header.cmd_num;
  143. break;
  144. case HAL_REO_UPDATE_RX_QUEUE_STATUS_TLV:
  145. hal_reo_rx_update_queue_status(reo_desc,
  146. &reo_status.rx_queue_status,
  147. soc->hal_soc);
  148. num = reo_status.rx_queue_status.header.cmd_num;
  149. break;
  150. default:
  151. dp_reo_warn("%pK: no handler for TLV:%d", soc, tlv);
  152. goto next;
  153. } /* switch */
  154. qdf_spin_lock_bh(&soc->rx.reo_cmd_lock);
  155. TAILQ_FOREACH(reo_cmd, &soc->rx.reo_cmd_list,
  156. reo_cmd_list_elem) {
  157. if (reo_cmd->cmd == num) {
  158. TAILQ_REMOVE(&soc->rx.reo_cmd_list, reo_cmd,
  159. reo_cmd_list_elem);
  160. break;
  161. }
  162. }
  163. qdf_spin_unlock_bh(&soc->rx.reo_cmd_lock);
  164. if (reo_cmd) {
  165. reo_cmd->handler(soc, reo_cmd->data,
  166. &reo_status);
  167. qdf_mem_free(reo_cmd);
  168. }
  169. next:
  170. reo_desc = hal_srng_dst_get_next(soc,
  171. soc->reo_status_ring.hal_srng);
  172. } /* while */
  173. dp_srng_access_end(int_ctx, soc, soc->reo_status_ring.hal_srng);
  174. return processed_count;
  175. }
  176. /**
  177. * dp_reo_cmdlist_destroy - Free REO commands in the queue
  178. * @soc: DP SoC hanle
  179. *
  180. */
  181. void dp_reo_cmdlist_destroy(struct dp_soc *soc)
  182. {
  183. struct dp_reo_cmd_info *reo_cmd = NULL;
  184. struct dp_reo_cmd_info *tmp_cmd = NULL;
  185. union hal_reo_status reo_status;
  186. reo_status.queue_status.header.status =
  187. HAL_REO_CMD_DRAIN;
  188. qdf_spin_lock_bh(&soc->rx.reo_cmd_lock);
  189. TAILQ_FOREACH_SAFE(reo_cmd, &soc->rx.reo_cmd_list,
  190. reo_cmd_list_elem, tmp_cmd) {
  191. TAILQ_REMOVE(&soc->rx.reo_cmd_list, reo_cmd,
  192. reo_cmd_list_elem);
  193. reo_cmd->handler(soc, reo_cmd->data, &reo_status);
  194. qdf_mem_free(reo_cmd);
  195. }
  196. qdf_spin_unlock_bh(&soc->rx.reo_cmd_lock);
  197. }