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