1 /* 2 * Copyright (c) 2016-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 19 #include "dp_types.h" 20 #include "hal_reo.h" 21 #include "dp_internal.h" 22 23 QDF_STATUS dp_reo_send_cmd(struct dp_soc *soc, enum hal_reo_cmd_type type, 24 struct hal_reo_cmd_params *params, 25 void (*callback_fn), void *data) 26 { 27 struct dp_reo_cmd_info *reo_cmd; 28 int num; 29 30 switch (type) { 31 case CMD_GET_QUEUE_STATS: 32 num = hal_reo_cmd_queue_stats(soc->reo_cmd_ring.hal_srng, 33 soc->hal_soc, params); 34 break; 35 case CMD_FLUSH_QUEUE: 36 num = hal_reo_cmd_flush_queue(soc->reo_cmd_ring.hal_srng, 37 soc->hal_soc, params); 38 break; 39 case CMD_FLUSH_CACHE: 40 num = hal_reo_cmd_flush_cache(soc->reo_cmd_ring.hal_srng, 41 soc->hal_soc, params); 42 break; 43 case CMD_UNBLOCK_CACHE: 44 num = hal_reo_cmd_unblock_cache(soc->reo_cmd_ring.hal_srng, 45 soc->hal_soc, params); 46 break; 47 case CMD_FLUSH_TIMEOUT_LIST: 48 num = hal_reo_cmd_flush_timeout_list(soc->reo_cmd_ring.hal_srng, 49 soc->hal_soc, params); 50 break; 51 case CMD_UPDATE_RX_REO_QUEUE: 52 num = hal_reo_cmd_update_rx_queue(soc->reo_cmd_ring.hal_srng, 53 soc->hal_soc, params); 54 break; 55 default: 56 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 57 "%s: Invalid REO command type", __func__); 58 return QDF_STATUS_E_FAILURE; 59 }; 60 61 if (num < 0) { 62 qdf_print("%s: Error with sending REO command", __func__); 63 return QDF_STATUS_E_FAILURE; 64 } 65 66 if (callback_fn) { 67 reo_cmd = qdf_mem_malloc(sizeof(*reo_cmd)); 68 if (!reo_cmd) { 69 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 70 "%s: alloc failed for REO cmd:%d!!", 71 __func__, type); 72 return QDF_STATUS_E_NOMEM; 73 } 74 75 reo_cmd->cmd = num; 76 reo_cmd->cmd_type = type; 77 reo_cmd->handler = callback_fn; 78 reo_cmd->data = data; 79 qdf_spin_lock_bh(&soc->rx.reo_cmd_lock); 80 TAILQ_INSERT_TAIL(&soc->rx.reo_cmd_list, reo_cmd, 81 reo_cmd_list_elem); 82 qdf_spin_unlock_bh(&soc->rx.reo_cmd_lock); 83 } 84 85 return QDF_STATUS_SUCCESS; 86 } 87 88 uint32_t dp_reo_status_ring_handler(struct dp_soc *soc) 89 { 90 uint32_t *reo_desc; 91 struct dp_reo_cmd_info *reo_cmd = NULL; 92 union hal_reo_status reo_status; 93 int num; 94 int processed_count = 0; 95 96 if (hal_srng_access_start(soc->hal_soc, 97 soc->reo_status_ring.hal_srng)) { 98 return processed_count; 99 } 100 reo_desc = hal_srng_dst_get_next(soc->hal_soc, 101 soc->reo_status_ring.hal_srng); 102 103 while (reo_desc) { 104 uint16_t tlv = HAL_GET_TLV(reo_desc); 105 processed_count++; 106 107 switch (tlv) { 108 case HAL_REO_QUEUE_STATS_STATUS_TLV: 109 hal_reo_queue_stats_status(reo_desc, 110 &reo_status.queue_status, 111 soc->hal_soc); 112 num = reo_status.queue_status.header.cmd_num; 113 break; 114 case HAL_REO_FLUSH_QUEUE_STATUS_TLV: 115 hal_reo_flush_queue_status(reo_desc, 116 &reo_status.fl_queue_status, 117 soc->hal_soc); 118 num = reo_status.fl_queue_status.header.cmd_num; 119 break; 120 case HAL_REO_FLUSH_CACHE_STATUS_TLV: 121 hal_reo_flush_cache_status(reo_desc, soc->hal_soc, 122 &reo_status.fl_cache_status, 123 soc->hal_soc); 124 num = reo_status.fl_cache_status.header.cmd_num; 125 break; 126 case HAL_REO_UNBLK_CACHE_STATUS_TLV: 127 hal_reo_unblock_cache_status(reo_desc, soc->hal_soc, 128 &reo_status.unblk_cache_status); 129 num = reo_status.unblk_cache_status.header.cmd_num; 130 break; 131 case HAL_REO_TIMOUT_LIST_STATUS_TLV: 132 hal_reo_flush_timeout_list_status(reo_desc, 133 &reo_status.fl_timeout_status, 134 soc->hal_soc); 135 num = reo_status.fl_timeout_status.header.cmd_num; 136 break; 137 case HAL_REO_DESC_THRES_STATUS_TLV: 138 hal_reo_desc_thres_reached_status(reo_desc, 139 &reo_status.thres_status, 140 soc->hal_soc); 141 num = reo_status.thres_status.header.cmd_num; 142 break; 143 case HAL_REO_UPDATE_RX_QUEUE_STATUS_TLV: 144 hal_reo_rx_update_queue_status(reo_desc, 145 &reo_status.rx_queue_status, 146 soc->hal_soc); 147 num = reo_status.rx_queue_status.header.cmd_num; 148 break; 149 default: 150 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_WARN, 151 "%s, no handler for TLV:%d", __func__, tlv); 152 goto next; 153 } /* switch */ 154 155 qdf_spin_lock_bh(&soc->rx.reo_cmd_lock); 156 TAILQ_FOREACH(reo_cmd, &soc->rx.reo_cmd_list, 157 reo_cmd_list_elem) { 158 if (reo_cmd->cmd == num) { 159 TAILQ_REMOVE(&soc->rx.reo_cmd_list, reo_cmd, 160 reo_cmd_list_elem); 161 break; 162 } 163 } 164 qdf_spin_unlock_bh(&soc->rx.reo_cmd_lock); 165 166 if (reo_cmd) { 167 reo_cmd->handler(soc, reo_cmd->data, 168 &reo_status); 169 qdf_mem_free(reo_cmd); 170 } 171 172 next: 173 reo_desc = hal_srng_dst_get_next(soc, 174 soc->reo_status_ring.hal_srng); 175 } /* while */ 176 177 hal_srng_access_end(soc->hal_soc, soc->reo_status_ring.hal_srng); 178 return processed_count; 179 } 180 181 /** 182 * dp_reo_cmdlist_destroy - Free REO commands in the queue 183 * @soc: DP SoC hanle 184 * 185 */ 186 void dp_reo_cmdlist_destroy(struct dp_soc *soc) 187 { 188 struct dp_reo_cmd_info *reo_cmd = NULL; 189 struct dp_reo_cmd_info *tmp_cmd = NULL; 190 union hal_reo_status reo_status; 191 192 reo_status.queue_status.header.status = 193 HAL_REO_CMD_DRAIN; 194 195 qdf_spin_lock_bh(&soc->rx.reo_cmd_lock); 196 TAILQ_FOREACH_SAFE(reo_cmd, &soc->rx.reo_cmd_list, 197 reo_cmd_list_elem, tmp_cmd) { 198 TAILQ_REMOVE(&soc->rx.reo_cmd_list, reo_cmd, 199 reo_cmd_list_elem); 200 reo_cmd->handler(soc, reo_cmd->data, &reo_status); 201 qdf_mem_free(reo_cmd); 202 } 203 qdf_spin_unlock_bh(&soc->rx.reo_cmd_lock); 204 } 205