void
ol_tx_desc_free(struct ol_txrx_pdev_t *pdev, struct ol_tx_desc_t *tx_desc)
{
adf_os_spin_lock_bh(&pdev->tx_mutex);
#ifdef QCA_SUPPORT_TXDESC_SANITY_CHECKS
tx_desc->pkt_type = ol_tx_frm_freed;
#ifdef QCA_COMPUTE_TX_DELAY
tx_desc->entry_timestamp_ticks = 0xffffffff;
#endif
#endif
((union ol_tx_desc_list_elem_t *)tx_desc)->next =
pdev->tx_desc.freelist;
pdev->tx_desc.freelist = (union ol_tx_desc_list_elem_t *) tx_desc;
pdev->tx_desc.num_free++;
#if defined(CONFIG_PER_VDEV_TX_DESC_POOL)
#ifdef QCA_LL_TX_FLOW_CT
if ( (adf_os_atomic_read(&tx_desc->vdev->os_q_paused)) &&
(adf_os_atomic_read(&tx_desc->vdev->tx_desc_count) <
TXRX_HL_TX_FLOW_CTRL_VDEV_LOW_WATER_MARK) ) {
/* wakeup netif_queue */
adf_os_atomic_set(&tx_desc->vdev->os_q_paused, 0);
tx_desc->vdev->osif_flow_control_cb(tx_desc->vdev->osif_dev,
tx_desc->vdev->vdev_id, A_TRUE);
}
#endif /* QCA_LL_TX_FLOW_CT */
adf_os_atomic_dec(&tx_desc->vdev->tx_desc_count);
#endif
#if defined(CONFIG_HL_SUPPORT)
tx_desc->vdev = NULL;
#endif
adf_os_spin_unlock_bh(&pdev->tx_mutex);
}
static inline struct ol_tx_desc_t *
ol_tx_desc_alloc_hl(struct ol_txrx_pdev_t *pdev, struct ol_txrx_vdev_t *vdev)
{
struct ol_tx_desc_t *tx_desc;
tx_desc = ol_tx_desc_alloc(pdev, vdev);
if (!tx_desc) return NULL;
adf_os_atomic_dec(&pdev->tx_queue.rsrc_cnt);
return tx_desc;
}
static int epping_tx_thread_fn(void *data)
{
int i;
epping_poll_t *epping_poll = data;
EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: arg = %p", __func__, data);
while (!epping_poll->done) {
down(&epping_poll->sem);
adf_os_atomic_dec(&epping_poll->atm);
if (epping_poll->skb && !epping_poll->done) {
for (i = 0; i < MAX_TX_PKT_DUP_NUM; i++) {
epping_tx_dup_pkt((epping_adapter_t *)epping_poll->arg,
epping_poll->eid, epping_poll->skb);
udelay(WLAN_EPPING_DELAY_TIMEOUT_US);
}
}
}
return 0;
}
void wmi_htc_tx_complete(void *ctx, HTC_PACKET *htc_pkt)
{
struct wmi_unified *wmi_handle = (struct wmi_unified *)ctx;
wmi_buf_t wmi_cmd_buf = GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
#ifdef WMI_INTERFACE_EVENT_LOGGING
u_int32_t cmd_id;
#endif
ASSERT(wmi_cmd_buf);
#ifdef WMI_INTERFACE_EVENT_LOGGING
cmd_id = WMI_GET_FIELD(adf_nbuf_data(wmi_cmd_buf),
WMI_CMD_HDR, COMMANDID);
adf_os_spin_lock_bh(&wmi_handle->wmi_record_lock);
/* Record 16 bytes of WMI cmd tx complete data
- exclude TLV and WMI headers */
WMI_COMMAND_TX_CMP_RECORD(cmd_id,
((u_int32_t *)adf_nbuf_data(wmi_cmd_buf) + 2));
adf_os_spin_unlock_bh(&wmi_handle->wmi_record_lock);
#endif
adf_nbuf_free(wmi_cmd_buf);
adf_os_mem_free(htc_pkt);
adf_os_atomic_dec(&wmi_handle->pending_cmds);
}
/* WMI command API */
int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, int len,
WMI_CMD_ID cmd_id)
{
HTC_PACKET *pkt;
A_STATUS status;
void *vos_context;
struct ol_softc *scn;
A_UINT16 htc_tag = 0;
if (wmi_get_runtime_pm_inprogress(wmi_handle))
goto skip_suspend_check;
if (adf_os_atomic_read(&wmi_handle->is_target_suspended) &&
( (WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID != cmd_id) &&
(WMI_PDEV_RESUME_CMDID != cmd_id)) ) {
pr_err("%s: Target is suspended could not send WMI command: %d\n",
__func__, cmd_id);
VOS_ASSERT(0);
return -EBUSY;
} else
goto dont_tag;
skip_suspend_check:
switch(cmd_id) {
case WMI_WOW_ENABLE_CMDID:
case WMI_PDEV_SUSPEND_CMDID:
case WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID:
case WMI_WOW_ADD_WAKE_PATTERN_CMDID:
case WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID:
case WMI_PDEV_RESUME_CMDID:
case WMI_WOW_DEL_WAKE_PATTERN_CMDID:
#ifdef FEATURE_WLAN_D0WOW
case WMI_D0_WOW_ENABLE_DISABLE_CMDID:
#endif
htc_tag = HTC_TX_PACKET_TAG_AUTO_PM;
default:
break;
}
dont_tag:
/* Do sanity check on the TLV parameter structure */
{
void *buf_ptr = (void *) adf_nbuf_data(buf);
if (wmitlv_check_command_tlv_params(NULL, buf_ptr, len, cmd_id) != 0)
{
adf_os_print("\nERROR: %s: Invalid WMI Parameter Buffer for Cmd:%d\n",
__func__, cmd_id);
return -1;
}
}
if (adf_nbuf_push_head(buf, sizeof(WMI_CMD_HDR)) == NULL) {
pr_err("%s, Failed to send cmd %x, no memory\n",
__func__, cmd_id);
return -ENOMEM;
}
WMI_SET_FIELD(adf_nbuf_data(buf), WMI_CMD_HDR, COMMANDID, cmd_id);
adf_os_atomic_inc(&wmi_handle->pending_cmds);
if (adf_os_atomic_read(&wmi_handle->pending_cmds) >= WMI_MAX_CMDS) {
vos_context = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
scn = vos_get_context(VOS_MODULE_ID_HIF, vos_context);
pr_err("\n%s: hostcredits = %d\n", __func__,
wmi_get_host_credits(wmi_handle));
HTC_dump_counter_info(wmi_handle->htc_handle);
//dump_CE_register(scn);
//dump_CE_debug_register(scn->hif_sc);
adf_os_atomic_dec(&wmi_handle->pending_cmds);
pr_err("%s: MAX 1024 WMI Pending cmds reached.\n", __func__);
vos_set_logp_in_progress(VOS_MODULE_ID_VOSS, TRUE);
schedule_work(&recovery_work);
return -EBUSY;
}
pkt = adf_os_mem_alloc(NULL, sizeof(*pkt));
if (!pkt) {
adf_os_atomic_dec(&wmi_handle->pending_cmds);
pr_err("%s, Failed to alloc htc packet %x, no memory\n",
__func__, cmd_id);
return -ENOMEM;
}
SET_HTC_PACKET_INFO_TX(pkt,
NULL,
adf_nbuf_data(buf),
len + sizeof(WMI_CMD_HDR),
/* htt_host_data_dl_len(buf)+20 */
wmi_handle->wmi_endpoint_id,
htc_tag);
SET_HTC_PACKET_NET_BUF_CONTEXT(pkt, buf);
WMA_LOGD("Send WMI command:%s command_id:%d",
get_wmi_cmd_string(cmd_id), cmd_id);
#ifdef WMI_INTERFACE_EVENT_LOGGING
adf_os_spin_lock_bh(&wmi_handle->wmi_record_lock);
/*Record 16 bytes of WMI cmd data - exclude TLV and WMI headers*/
WMI_COMMAND_RECORD(cmd_id ,((u_int32_t *)adf_nbuf_data(buf) + 2));
adf_os_spin_unlock_bh(&wmi_handle->wmi_record_lock);
#endif
status = HTCSendPkt(wmi_handle->htc_handle, pkt);
if (A_OK != status) {
adf_os_atomic_dec(&wmi_handle->pending_cmds);
pr_err("%s %d, HTCSendPkt failed\n", __func__, __LINE__);
}
return ((status == A_OK) ? EOK : -1);
}
