quantenna/qtnfmac/trans.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /* Copyright (c) 2015-2016 Quantenna Communications. All rights reserved. */
0003
0004 #include <linux/types.h>
0005 #include <linux/export.h>
0006 #include <linux/slab.h>
0007
0008 #include "core.h"
0009 #include "commands.h"
0010 #include "event.h"
0011 #include "bus.h"
0012
0013 #define QTNF_DEF_SYNC_CMD_TIMEOUT   (5 * HZ)
0014
0015 int qtnf_trans_send_cmd_with_resp(struct qtnf_bus *bus, struct sk_buff *cmd_skb,
0016                   struct sk_buff **response_skb)
0017 {
0018     struct qtnf_cmd_ctl_node *ctl_node = &bus->trans.curr_cmd;
0019     struct qlink_cmd *cmd = (void *)cmd_skb->data;
0020     int ret = 0;
0021     long status;
0022     bool resp_not_handled = true;
0023     struct sk_buff *resp_skb = NULL;
0024
0025     if (unlikely(!response_skb)) {
0026         dev_kfree_skb(cmd_skb);
0027         return -EFAULT;
0028     }
0029
0030     spin_lock(&ctl_node->resp_lock);
0031     ctl_node->seq_num++;
0032     cmd->seq_num = cpu_to_le16(ctl_node->seq_num);
0033     WARN(ctl_node->resp_skb, "qtnfmac: response skb not empty\n");
0034     ctl_node->waiting_for_resp = true;
0035     spin_unlock(&ctl_node->resp_lock);
0036
0037     ret = qtnf_bus_control_tx(bus, cmd_skb);
0038     dev_kfree_skb(cmd_skb);
0039
0040     if (unlikely(ret))
0041         goto out;
0042
0043     status = wait_for_completion_interruptible_timeout(
0044                         &ctl_node->cmd_resp_completion,
0045                         QTNF_DEF_SYNC_CMD_TIMEOUT);
0046
0047     spin_lock(&ctl_node->resp_lock);
0048     resp_not_handled = ctl_node->waiting_for_resp;
0049     resp_skb = ctl_node->resp_skb;
0050     ctl_node->resp_skb = NULL;
0051     ctl_node->waiting_for_resp = false;
0052     spin_unlock(&ctl_node->resp_lock);
0053
0054     if (unlikely(status <= 0)) {
0055         if (status == 0) {
0056             ret = -ETIMEDOUT;
0057             pr_err("response timeout\n");
0058         } else {
0059             ret = -EINTR;
0060             pr_debug("interrupted\n");
0061         }
0062     }
0063
0064     if (unlikely(!resp_skb || resp_not_handled)) {
0065         if (!ret)
0066             ret = -EFAULT;
0067
0068         goto out;
0069     }
0070
0071     ret = 0;
0072     *response_skb = resp_skb;
0073
0074 out:
0075     if (unlikely(resp_skb && resp_not_handled))
0076         dev_kfree_skb(resp_skb);
0077
0078     return ret;
0079 }
0080
0081 static void qtnf_trans_signal_cmdresp(struct qtnf_bus *bus, struct sk_buff *skb)
0082 {
0083     struct qtnf_cmd_ctl_node *ctl_node = &bus->trans.curr_cmd;
0084     const struct qlink_resp *resp = (const struct qlink_resp *)skb->data;
0085     const u16 recvd_seq_num = le16_to_cpu(resp->seq_num);
0086
0087     spin_lock(&ctl_node->resp_lock);
0088
0089     if (unlikely(!ctl_node->waiting_for_resp)) {
0090         pr_err("unexpected response\n");
0091         goto out_err;
0092     }
0093
0094     if (unlikely(recvd_seq_num != ctl_node->seq_num)) {
0095         pr_err("seq num mismatch\n");
0096         goto out_err;
0097     }
0098
0099     ctl_node->resp_skb = skb;
0100     ctl_node->waiting_for_resp = false;
0101
0102     spin_unlock(&ctl_node->resp_lock);
0103
0104     complete(&ctl_node->cmd_resp_completion);
0105     return;
0106
0107 out_err:
0108     spin_unlock(&ctl_node->resp_lock);
0109     dev_kfree_skb(skb);
0110 }
0111
0112 static int qtnf_trans_event_enqueue(struct qtnf_bus *bus, struct sk_buff *skb)
0113 {
0114     struct qtnf_qlink_transport *trans = &bus->trans;
0115
0116     if (likely(skb_queue_len(&trans->event_queue) <
0117            trans->event_queue_max_len)) {
0118         skb_queue_tail(&trans->event_queue, skb);
0119         queue_work(bus->workqueue, &bus->event_work);
0120     } else {
0121         pr_warn("event dropped due to queue overflow\n");
0122         dev_kfree_skb(skb);
0123         return -1;
0124     }
0125
0126     return 0;
0127 }
0128
0129 void qtnf_trans_init(struct qtnf_bus *bus)
0130 {
0131     struct qtnf_qlink_transport *trans = &bus->trans;
0132
0133     init_completion(&trans->curr_cmd.cmd_resp_completion);
0134     spin_lock_init(&trans->curr_cmd.resp_lock);
0135
0136     spin_lock(&trans->curr_cmd.resp_lock);
0137     trans->curr_cmd.seq_num = 0;
0138     trans->curr_cmd.waiting_for_resp = false;
0139     trans->curr_cmd.resp_skb = NULL;
0140     spin_unlock(&trans->curr_cmd.resp_lock);
0141
0142     /* Init event handling related fields */
0143     skb_queue_head_init(&trans->event_queue);
0144     trans->event_queue_max_len = QTNF_MAX_EVENT_QUEUE_LEN;
0145 }
0146
0147 static void qtnf_trans_free_events(struct qtnf_bus *bus)
0148 {
0149     struct sk_buff_head *event_queue = &bus->trans.event_queue;
0150     struct sk_buff *current_event_skb = skb_dequeue(event_queue);
0151
0152     while (current_event_skb) {
0153         dev_kfree_skb_any(current_event_skb);
0154         current_event_skb = skb_dequeue(event_queue);
0155     }
0156 }
0157
0158 void qtnf_trans_free(struct qtnf_bus *bus)
0159 {
0160     if (!bus) {
0161         pr_err("invalid bus pointer\n");
0162         return;
0163     }
0164
0165     qtnf_trans_free_events(bus);
0166 }
0167
0168 int qtnf_trans_handle_rx_ctl_packet(struct qtnf_bus *bus, struct sk_buff *skb)
0169 {
0170     const struct qlink_msg_header *header = (void *)skb->data;
0171     int ret = -1;
0172
0173     if (unlikely(skb->len < sizeof(*header))) {
0174         pr_warn("packet is too small: %u\n", skb->len);
0175         dev_kfree_skb(skb);
0176         return -EINVAL;
0177     }
0178
0179     if (unlikely(skb->len != le16_to_cpu(header->len))) {
0180         pr_warn("cmd reply length mismatch: %u != %u\n",
0181             skb->len, le16_to_cpu(header->len));
0182         dev_kfree_skb(skb);
0183         return -EFAULT;
0184     }
0185
0186     switch (le16_to_cpu(header->type)) {
0187     case QLINK_MSG_TYPE_CMDRSP:
0188         if (unlikely(skb->len < sizeof(struct qlink_cmd))) {
0189             pr_warn("cmd reply too short: %u\n", skb->len);
0190             dev_kfree_skb(skb);
0191             break;
0192         }
0193
0194         qtnf_trans_signal_cmdresp(bus, skb);
0195         break;
0196     case QLINK_MSG_TYPE_EVENT:
0197         if (unlikely(skb->len < sizeof(struct qlink_event))) {
0198             pr_warn("event too short: %u\n", skb->len);
0199             dev_kfree_skb(skb);
0200             break;
0201         }
0202
0203         ret = qtnf_trans_event_enqueue(bus, skb);
0204         break;
0205     default:
0206         pr_warn("unknown packet type: %x\n", le16_to_cpu(header->type));
0207         dev_kfree_skb(skb);
0208         break;
0209     }
0210
0211     return ret;
0212 }
0213 EXPORT_SYMBOL_GPL(qtnf_trans_handle_rx_ctl_packet);