214 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/* Copyright (c) 2015-2016 Quantenna Communications. All rights reserved. */3 4#include <linux/types.h>5#include <linux/export.h>6#include <linux/slab.h>7 8#include "core.h"9#include "commands.h"10#include "event.h"11#include "bus.h"12 13#define QTNF_DEF_SYNC_CMD_TIMEOUT (5 * HZ)14 15int qtnf_trans_send_cmd_with_resp(struct qtnf_bus *bus, struct sk_buff *cmd_skb,16 struct sk_buff **response_skb)17{18 struct qtnf_cmd_ctl_node *ctl_node = &bus->trans.curr_cmd;19 struct qlink_cmd *cmd = (void *)cmd_skb->data;20 int ret = 0;21 long status;22 bool resp_not_handled = true;23 struct sk_buff *resp_skb = NULL;24 25 if (unlikely(!response_skb)) {26 dev_kfree_skb(cmd_skb);27 return -EFAULT;28 }29 30 spin_lock(&ctl_node->resp_lock);31 ctl_node->seq_num++;32 cmd->seq_num = cpu_to_le16(ctl_node->seq_num);33 WARN(ctl_node->resp_skb, "qtnfmac: response skb not empty\n");34 ctl_node->waiting_for_resp = true;35 spin_unlock(&ctl_node->resp_lock);36 37 ret = qtnf_bus_control_tx(bus, cmd_skb);38 dev_kfree_skb(cmd_skb);39 40 if (unlikely(ret))41 goto out;42 43 status = wait_for_completion_interruptible_timeout(44 &ctl_node->cmd_resp_completion,45 QTNF_DEF_SYNC_CMD_TIMEOUT);46 47 spin_lock(&ctl_node->resp_lock);48 resp_not_handled = ctl_node->waiting_for_resp;49 resp_skb = ctl_node->resp_skb;50 ctl_node->resp_skb = NULL;51 ctl_node->waiting_for_resp = false;52 spin_unlock(&ctl_node->resp_lock);53 54 if (unlikely(status <= 0)) {55 if (status == 0) {56 ret = -ETIMEDOUT;57 pr_err("response timeout\n");58 } else {59 ret = -EINTR;60 pr_debug("interrupted\n");61 }62 }63 64 if (unlikely(!resp_skb || resp_not_handled)) {65 if (!ret)66 ret = -EFAULT;67 68 goto out;69 }70 71 ret = 0;72 *response_skb = resp_skb;73 74out:75 if (unlikely(resp_skb && resp_not_handled))76 dev_kfree_skb(resp_skb);77 78 return ret;79}80 81static void qtnf_trans_signal_cmdresp(struct qtnf_bus *bus, struct sk_buff *skb)82{83 struct qtnf_cmd_ctl_node *ctl_node = &bus->trans.curr_cmd;84 const struct qlink_resp *resp = (const struct qlink_resp *)skb->data;85 const u16 recvd_seq_num = le16_to_cpu(resp->seq_num);86 87 spin_lock(&ctl_node->resp_lock);88 89 if (unlikely(!ctl_node->waiting_for_resp)) {90 pr_err("unexpected response\n");91 goto out_err;92 }93 94 if (unlikely(recvd_seq_num != ctl_node->seq_num)) {95 pr_err("seq num mismatch\n");96 goto out_err;97 }98 99 ctl_node->resp_skb = skb;100 ctl_node->waiting_for_resp = false;101 102 spin_unlock(&ctl_node->resp_lock);103 104 complete(&ctl_node->cmd_resp_completion);105 return;106 107out_err:108 spin_unlock(&ctl_node->resp_lock);109 dev_kfree_skb(skb);110}111 112static int qtnf_trans_event_enqueue(struct qtnf_bus *bus, struct sk_buff *skb)113{114 struct qtnf_qlink_transport *trans = &bus->trans;115 116 if (likely(skb_queue_len(&trans->event_queue) <117 trans->event_queue_max_len)) {118 skb_queue_tail(&trans->event_queue, skb);119 queue_work(bus->workqueue, &bus->event_work);120 } else {121 pr_warn("event dropped due to queue overflow\n");122 dev_kfree_skb(skb);123 return -1;124 }125 126 return 0;127}128 129void qtnf_trans_init(struct qtnf_bus *bus)130{131 struct qtnf_qlink_transport *trans = &bus->trans;132 133 init_completion(&trans->curr_cmd.cmd_resp_completion);134 spin_lock_init(&trans->curr_cmd.resp_lock);135 136 spin_lock(&trans->curr_cmd.resp_lock);137 trans->curr_cmd.seq_num = 0;138 trans->curr_cmd.waiting_for_resp = false;139 trans->curr_cmd.resp_skb = NULL;140 spin_unlock(&trans->curr_cmd.resp_lock);141 142 /* Init event handling related fields */143 skb_queue_head_init(&trans->event_queue);144 trans->event_queue_max_len = QTNF_MAX_EVENT_QUEUE_LEN;145}146 147static void qtnf_trans_free_events(struct qtnf_bus *bus)148{149 struct sk_buff_head *event_queue = &bus->trans.event_queue;150 struct sk_buff *current_event_skb = skb_dequeue(event_queue);151 152 while (current_event_skb) {153 dev_kfree_skb_any(current_event_skb);154 current_event_skb = skb_dequeue(event_queue);155 }156}157 158void qtnf_trans_free(struct qtnf_bus *bus)159{160 if (!bus) {161 pr_err("invalid bus pointer\n");162 return;163 }164 165 qtnf_trans_free_events(bus);166}167 168int qtnf_trans_handle_rx_ctl_packet(struct qtnf_bus *bus, struct sk_buff *skb)169{170 const struct qlink_msg_header *header = (void *)skb->data;171 int ret = -1;172 173 if (unlikely(skb->len < sizeof(*header))) {174 pr_warn("packet is too small: %u\n", skb->len);175 dev_kfree_skb(skb);176 return -EINVAL;177 }178 179 if (unlikely(skb->len != le16_to_cpu(header->len))) {180 pr_warn("cmd reply length mismatch: %u != %u\n",181 skb->len, le16_to_cpu(header->len));182 dev_kfree_skb(skb);183 return -EFAULT;184 }185 186 switch (le16_to_cpu(header->type)) {187 case QLINK_MSG_TYPE_CMDRSP:188 if (unlikely(skb->len < sizeof(struct qlink_cmd))) {189 pr_warn("cmd reply too short: %u\n", skb->len);190 dev_kfree_skb(skb);191 break;192 }193 194 qtnf_trans_signal_cmdresp(bus, skb);195 break;196 case QLINK_MSG_TYPE_EVENT:197 if (unlikely(skb->len < sizeof(struct qlink_event))) {198 pr_warn("event too short: %u\n", skb->len);199 dev_kfree_skb(skb);200 break;201 }202 203 ret = qtnf_trans_event_enqueue(bus, skb);204 break;205 default:206 pr_warn("unknown packet type: %x\n", le16_to_cpu(header->type));207 dev_kfree_skb(skb);208 break;209 }210 211 return ret;212}213EXPORT_SYMBOL_GPL(qtnf_trans_handle_rx_ctl_packet);214