drivers/net/wireless/quantenna/qtnfmac/trans.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
  15 int 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
  74 out:
  75         if (unlikely(resp_skb && resp_not_handled))
  76                 dev_kfree_skb(resp_skb);
  77
  78         return ret;
  79 }
  80
  81 static 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
 107 out_err:
 108         spin_unlock(&ctl_node->resp_lock);
 109         dev_kfree_skb(skb);
 110 }
 111
 112 static 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
 129 void 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
 147 static 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
 158 void 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
 168 int 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 }
 213 EXPORT_SYMBOL_GPL(qtnf_trans_handle_rx_ctl_packet);