2 * Copyright (c) 2015-2016 Quantenna Communications, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <linux/types.h>
18 #include <linux/export.h>
19 #include <linux/slab.h>
26 #define QTNF_DEF_SYNC_CMD_TIMEOUT (5 * HZ)
28 int qtnf_trans_send_cmd_with_resp(struct qtnf_bus *bus, struct sk_buff *cmd_skb,
29 struct sk_buff **response_skb)
31 struct qtnf_cmd_ctl_node *ctl_node = &bus->trans.curr_cmd;
32 struct qlink_cmd *cmd = (void *)cmd_skb->data;
35 bool resp_not_handled = true;
36 struct sk_buff *resp_skb = NULL;
38 if (unlikely(!response_skb)) {
39 dev_kfree_skb(cmd_skb);
43 spin_lock(&ctl_node->resp_lock);
45 cmd->seq_num = cpu_to_le16(ctl_node->seq_num);
46 WARN(ctl_node->resp_skb, "qtnfmac: response skb not empty\n");
47 ctl_node->waiting_for_resp = true;
48 spin_unlock(&ctl_node->resp_lock);
50 ret = qtnf_bus_control_tx(bus, cmd_skb);
51 dev_kfree_skb(cmd_skb);
56 status = wait_for_completion_interruptible_timeout(
57 &ctl_node->cmd_resp_completion,
58 QTNF_DEF_SYNC_CMD_TIMEOUT);
60 spin_lock(&ctl_node->resp_lock);
61 resp_not_handled = ctl_node->waiting_for_resp;
62 resp_skb = ctl_node->resp_skb;
63 ctl_node->resp_skb = NULL;
64 ctl_node->waiting_for_resp = false;
65 spin_unlock(&ctl_node->resp_lock);
67 if (unlikely(status <= 0)) {
70 pr_err("response timeout\n");
73 pr_debug("interrupted\n");
77 if (unlikely(!resp_skb || resp_not_handled)) {
85 *response_skb = resp_skb;
88 if (unlikely(resp_skb && resp_not_handled))
89 dev_kfree_skb(resp_skb);
94 static void qtnf_trans_signal_cmdresp(struct qtnf_bus *bus, struct sk_buff *skb)
96 struct qtnf_cmd_ctl_node *ctl_node = &bus->trans.curr_cmd;
97 const struct qlink_resp *resp = (const struct qlink_resp *)skb->data;
98 const u16 recvd_seq_num = le16_to_cpu(resp->seq_num);
100 spin_lock(&ctl_node->resp_lock);
102 if (unlikely(!ctl_node->waiting_for_resp)) {
103 pr_err("unexpected response\n");
107 if (unlikely(recvd_seq_num != ctl_node->seq_num)) {
108 pr_err("seq num mismatch\n");
112 ctl_node->resp_skb = skb;
113 ctl_node->waiting_for_resp = false;
115 spin_unlock(&ctl_node->resp_lock);
117 complete(&ctl_node->cmd_resp_completion);
121 spin_unlock(&ctl_node->resp_lock);
125 static int qtnf_trans_event_enqueue(struct qtnf_bus *bus, struct sk_buff *skb)
127 struct qtnf_qlink_transport *trans = &bus->trans;
129 if (likely(skb_queue_len(&trans->event_queue) <
130 trans->event_queue_max_len)) {
131 skb_queue_tail(&trans->event_queue, skb);
132 queue_work(bus->workqueue, &bus->event_work);
134 pr_warn("event dropped due to queue overflow\n");
142 void qtnf_trans_init(struct qtnf_bus *bus)
144 struct qtnf_qlink_transport *trans = &bus->trans;
146 init_completion(&trans->curr_cmd.cmd_resp_completion);
147 spin_lock_init(&trans->curr_cmd.resp_lock);
149 spin_lock(&trans->curr_cmd.resp_lock);
150 trans->curr_cmd.seq_num = 0;
151 trans->curr_cmd.waiting_for_resp = false;
152 trans->curr_cmd.resp_skb = NULL;
153 spin_unlock(&trans->curr_cmd.resp_lock);
155 /* Init event handling related fields */
156 skb_queue_head_init(&trans->event_queue);
157 trans->event_queue_max_len = QTNF_MAX_EVENT_QUEUE_LEN;
160 static void qtnf_trans_free_events(struct qtnf_bus *bus)
162 struct sk_buff_head *event_queue = &bus->trans.event_queue;
163 struct sk_buff *current_event_skb = skb_dequeue(event_queue);
165 while (current_event_skb) {
166 dev_kfree_skb_any(current_event_skb);
167 current_event_skb = skb_dequeue(event_queue);
171 void qtnf_trans_free(struct qtnf_bus *bus)
174 pr_err("invalid bus pointer\n");
178 qtnf_trans_free_events(bus);
181 int qtnf_trans_handle_rx_ctl_packet(struct qtnf_bus *bus, struct sk_buff *skb)
183 const struct qlink_msg_header *header = (void *)skb->data;
186 if (unlikely(skb->len < sizeof(*header))) {
187 pr_warn("packet is too small: %u\n", skb->len);
192 if (unlikely(skb->len != le16_to_cpu(header->len))) {
193 pr_warn("cmd reply length mismatch: %u != %u\n",
194 skb->len, le16_to_cpu(header->len));
199 switch (le16_to_cpu(header->type)) {
200 case QLINK_MSG_TYPE_CMDRSP:
201 if (unlikely(skb->len < sizeof(struct qlink_cmd))) {
202 pr_warn("cmd reply too short: %u\n", skb->len);
207 qtnf_trans_signal_cmdresp(bus, skb);
209 case QLINK_MSG_TYPE_EVENT:
210 if (unlikely(skb->len < sizeof(struct qlink_event))) {
211 pr_warn("event too short: %u\n", skb->len);
216 ret = qtnf_trans_event_enqueue(bus, skb);
219 pr_warn("unknown packet type: %x\n", le16_to_cpu(header->type));
226 EXPORT_SYMBOL_GPL(qtnf_trans_handle_rx_ctl_packet);