[mirror_ubuntu-bionic-kernel.git] / drivers / net / wireless / quantenna / qtnfmac / core.c

/*
 * Copyright (c) 2015-2016 Quantenna Communications, Inc.
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/if_ether.h>

#include "core.h"
#include "bus.h"
#include "trans.h"
#include "commands.h"
#include "cfg80211.h"
#include "event.h"
#include "util.h"

#define QTNF_DMP_MAX_LEN 48
#define QTNF_PRIMARY_VIF_IDX	0

struct qtnf_frame_meta_info {
	u8 magic_s;
	u8 ifidx;
	u8 macid;
	u8 magic_e;
} __packed;

struct qtnf_wmac *qtnf_core_get_mac(const struct qtnf_bus *bus, u8 macid)
{
	struct qtnf_wmac *mac = NULL;

	if (unlikely(macid >= QTNF_MAX_MAC)) {
		pr_err("invalid MAC index %u\n", macid);
		return NULL;
	}

	mac = bus->mac[macid];

	if (unlikely(!mac)) {
		pr_err("MAC%u: not initialized\n", macid);
		return NULL;
	}

	return mac;
}

/* Netdev handler for open.
 */
static int qtnf_netdev_open(struct net_device *ndev)
{
	netif_carrier_off(ndev);
	qtnf_netdev_updown(ndev, 1);
	return 0;
}

/* Netdev handler for close.
 */
static int qtnf_netdev_close(struct net_device *ndev)
{
	netif_carrier_off(ndev);
	qtnf_virtual_intf_cleanup(ndev);
	qtnf_netdev_updown(ndev, 0);
	return 0;
}

/* Netdev handler for data transmission.
 */
static int
qtnf_netdev_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev)
{
	struct qtnf_vif *vif;
	struct qtnf_wmac *mac;

	vif = qtnf_netdev_get_priv(ndev);

	if (unlikely(skb->dev != ndev)) {
		pr_err_ratelimited("invalid skb->dev");
		dev_kfree_skb_any(skb);
		return 0;
	}

	if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
		pr_err_ratelimited("%s: VIF not initialized\n", ndev->name);
		dev_kfree_skb_any(skb);
		return 0;
	}

	mac = vif->mac;
	if (unlikely(!mac)) {
		pr_err_ratelimited("%s: NULL mac pointer", ndev->name);
		dev_kfree_skb_any(skb);
		return 0;
	}

	if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
		pr_err_ratelimited("%s: invalid skb len %d\n", ndev->name,
				   skb->len);
		dev_kfree_skb_any(skb);
		ndev->stats.tx_dropped++;
		return 0;
	}

	/* tx path is enabled: reset vif timeout */
	vif->cons_tx_timeout_cnt = 0;

	return qtnf_bus_data_tx(mac->bus, skb);
}

/* Netdev handler for getting stats.
 */
static struct net_device_stats *qtnf_netdev_get_stats(struct net_device *dev)
{
	return &dev->stats;
}

/* Netdev handler for transmission timeout.
 */
static void qtnf_netdev_tx_timeout(struct net_device *ndev)
{
	struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
	struct qtnf_wmac *mac;
	struct qtnf_bus *bus;

	if (unlikely(!vif || !vif->mac || !vif->mac->bus))
		return;

	mac = vif->mac;
	bus = mac->bus;

	pr_warn("VIF%u.%u: Tx timeout- %lu\n", mac->macid, vif->vifid, jiffies);

	qtnf_bus_data_tx_timeout(bus, ndev);
	ndev->stats.tx_errors++;

	if (++vif->cons_tx_timeout_cnt > QTNF_TX_TIMEOUT_TRSHLD) {
		pr_err("Tx timeout threshold exceeded !\n");
		pr_err("schedule interface %s reset !\n", netdev_name(ndev));
		queue_work(bus->workqueue, &vif->reset_work);
	}
}

/* Network device ops handlers */
const struct net_device_ops qtnf_netdev_ops = {
	.ndo_open = qtnf_netdev_open,
	.ndo_stop = qtnf_netdev_close,
	.ndo_start_xmit = qtnf_netdev_hard_start_xmit,
	.ndo_tx_timeout = qtnf_netdev_tx_timeout,
	.ndo_get_stats = qtnf_netdev_get_stats,
};

static int qtnf_mac_init_single_band(struct wiphy *wiphy,
				     struct qtnf_wmac *mac,
				     enum nl80211_band band)
{
	int ret;

	wiphy->bands[band] = kzalloc(sizeof(*wiphy->bands[band]), GFP_KERNEL);
	if (!wiphy->bands[band])
		return -ENOMEM;

	wiphy->bands[band]->band = band;

	ret = qtnf_cmd_band_info_get(mac, wiphy->bands[band]);
	if (ret) {
		pr_err("MAC%u: band %u: failed to get chans info: %d\n",
		       mac->macid, band, ret);
		return ret;
	}

	qtnf_band_init_rates(wiphy->bands[band]);

	return 0;
}

static int qtnf_mac_init_bands(struct qtnf_wmac *mac)
{
	struct wiphy *wiphy = priv_to_wiphy(mac);
	int ret = 0;

	if (mac->macinfo.bands_cap & QLINK_BAND_2GHZ) {
		ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_2GHZ);
		if (ret)
			goto out;
	}

	if (mac->macinfo.bands_cap & QLINK_BAND_5GHZ) {
		ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_5GHZ);
		if (ret)
			goto out;
	}

	if (mac->macinfo.bands_cap & QLINK_BAND_60GHZ)
		ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_60GHZ);

out:
	return ret;
}

struct qtnf_vif *qtnf_mac_get_free_vif(struct qtnf_wmac *mac)
{
	struct qtnf_vif *vif;
	int i;

	for (i = 0; i < QTNF_MAX_INTF; i++) {
		vif = &mac->iflist[i];
		if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
			return vif;
	}

	return NULL;
}

struct qtnf_vif *qtnf_mac_get_base_vif(struct qtnf_wmac *mac)
{
	struct qtnf_vif *vif;

	vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];

	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
		return NULL;

	return vif;
}

static void qtnf_vif_reset_handler(struct work_struct *work)
{
	struct qtnf_vif *vif = container_of(work, struct qtnf_vif, reset_work);

	rtnl_lock();

	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) {
		rtnl_unlock();
		return;
	}

	/* stop tx completely */
	netif_tx_stop_all_queues(vif->netdev);
	if (netif_carrier_ok(vif->netdev))
		netif_carrier_off(vif->netdev);

	qtnf_cfg80211_vif_reset(vif);

	rtnl_unlock();
}

static void qtnf_mac_init_primary_intf(struct qtnf_wmac *mac)
{
	struct qtnf_vif *vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];

	vif->wdev.iftype = NL80211_IFTYPE_AP;
	vif->bss_priority = QTNF_DEF_BSS_PRIORITY;
	vif->wdev.wiphy = priv_to_wiphy(mac);
	INIT_WORK(&vif->reset_work, qtnf_vif_reset_handler);
	vif->cons_tx_timeout_cnt = 0;
}

static struct qtnf_wmac *qtnf_core_mac_alloc(struct qtnf_bus *bus,
					     unsigned int macid)
{
	struct wiphy *wiphy;
	struct qtnf_wmac *mac;
	unsigned int i;

	wiphy = qtnf_wiphy_allocate(bus);
	if (!wiphy)
		return ERR_PTR(-ENOMEM);

	mac = wiphy_priv(wiphy);

	mac->macid = macid;
	mac->bus = bus;

	for (i = 0; i < QTNF_MAX_INTF; i++) {
		memset(&mac->iflist[i], 0, sizeof(struct qtnf_vif));
		mac->iflist[i].wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
		mac->iflist[i].mac = mac;
		mac->iflist[i].vifid = i;
		qtnf_sta_list_init(&mac->iflist[i].sta_list);
		mutex_init(&mac->mac_lock);
		timer_setup(&mac->scan_timeout, NULL, 0);
	}

	qtnf_mac_init_primary_intf(mac);
	bus->mac[macid] = mac;

	return mac;
}

int qtnf_core_net_attach(struct qtnf_wmac *mac, struct qtnf_vif *vif,
			 const char *name, unsigned char name_assign_type,
			 enum nl80211_iftype iftype)
{
	struct wiphy *wiphy = priv_to_wiphy(mac);
	struct net_device *dev;
	void *qdev_vif;
	int ret;

	dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name,
			       name_assign_type, ether_setup, 1, 1);
	if (!dev) {
		memset(&vif->wdev, 0, sizeof(vif->wdev));
		vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
		return -ENOMEM;
	}

	vif->netdev = dev;

	dev->netdev_ops = &qtnf_netdev_ops;
	dev->needs_free_netdev = true;
	dev_net_set(dev, wiphy_net(wiphy));
	dev->ieee80211_ptr = &vif->wdev;
	dev->ieee80211_ptr->iftype = iftype;
	ether_addr_copy(dev->dev_addr, vif->mac_addr);
	SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
	dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT;
	dev->tx_queue_len = 100;

	qdev_vif = netdev_priv(dev);
	*((void **)qdev_vif) = vif;

	SET_NETDEV_DEV(dev, mac->bus->dev);

	ret = register_netdevice(dev);
	if (ret) {
		free_netdev(dev);
		vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
	}

	return ret;
}

static void qtnf_core_mac_detach(struct qtnf_bus *bus, unsigned int macid)
{
	struct qtnf_wmac *mac;
	struct wiphy *wiphy;
	struct qtnf_vif *vif;
	unsigned int i;
	enum nl80211_band band;

	mac = bus->mac[macid];

	if (!mac)
		return;

	wiphy = priv_to_wiphy(mac);

	for (i = 0; i < QTNF_MAX_INTF; i++) {
		vif = &mac->iflist[i];
		rtnl_lock();
		if (vif->netdev &&
		    vif->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) {
			qtnf_virtual_intf_cleanup(vif->netdev);
			qtnf_del_virtual_intf(wiphy, &vif->wdev);
		}
		rtnl_unlock();
		qtnf_sta_list_free(&vif->sta_list);
	}

	if (mac->wiphy_registered)
		wiphy_unregister(wiphy);

	for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; ++band) {
		if (!wiphy->bands[band])
			continue;

		kfree(wiphy->bands[band]->channels);
		wiphy->bands[band]->n_channels = 0;

		kfree(wiphy->bands[band]);
		wiphy->bands[band] = NULL;
	}

	kfree(mac->macinfo.limits);
	kfree(wiphy->iface_combinations);
	wiphy_free(wiphy);
	bus->mac[macid] = NULL;
}

static int qtnf_core_mac_attach(struct qtnf_bus *bus, unsigned int macid)
{
	struct qtnf_wmac *mac;
	struct qtnf_vif *vif;
	int ret;

	if (!(bus->hw_info.mac_bitmap & BIT(macid))) {
		pr_info("MAC%u is not active in FW\n", macid);
		return 0;
	}

	mac = qtnf_core_mac_alloc(bus, macid);
	if (IS_ERR(mac)) {
		pr_err("MAC%u allocation failed\n", macid);
		return PTR_ERR(mac);
	}

	ret = qtnf_cmd_get_mac_info(mac);
	if (ret) {
		pr_err("MAC%u: failed to get info\n", macid);
		goto error;
	}

	vif = qtnf_mac_get_base_vif(mac);
	if (!vif) {
		pr_err("MAC%u: primary VIF is not ready\n", macid);
		ret = -EFAULT;
		goto error;
	}

	ret = qtnf_cmd_send_add_intf(vif, NL80211_IFTYPE_AP, vif->mac_addr);
	if (ret) {
		pr_err("MAC%u: failed to add VIF\n", macid);
		goto error;
	}

	ret = qtnf_cmd_send_get_phy_params(mac);
	if (ret) {
		pr_err("MAC%u: failed to get PHY settings\n", macid);
		goto error;
	}

	ret = qtnf_mac_init_bands(mac);
	if (ret) {
		pr_err("MAC%u: failed to init bands\n", macid);
		goto error;
	}

	ret = qtnf_wiphy_register(&bus->hw_info, mac);
	if (ret) {
		pr_err("MAC%u: wiphy registration failed\n", macid);
		goto error;
	}

	mac->wiphy_registered = 1;

	rtnl_lock();

	ret = qtnf_core_net_attach(mac, vif, "wlan%d", NET_NAME_ENUM,
				   NL80211_IFTYPE_AP);
	rtnl_unlock();

	if (ret) {
		pr_err("MAC%u: failed to attach netdev\n", macid);
		vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
		vif->netdev = NULL;
		goto error;
	}

	pr_debug("MAC%u initialized\n", macid);

	return 0;

error:
	qtnf_core_mac_detach(bus, macid);
	return ret;
}

int qtnf_core_attach(struct qtnf_bus *bus)
{
	unsigned int i;
	int ret;

	qtnf_trans_init(bus);

	bus->fw_state = QTNF_FW_STATE_BOOT_DONE;
	qtnf_bus_data_rx_start(bus);

	bus->workqueue = alloc_ordered_workqueue("QTNF_BUS", 0);
	if (!bus->workqueue) {
		pr_err("failed to alloc main workqueue\n");
		ret = -ENOMEM;
		goto error;
	}

	INIT_WORK(&bus->event_work, qtnf_event_work_handler);

	ret = qtnf_cmd_send_init_fw(bus);
	if (ret) {
		pr_err("failed to init FW: %d\n", ret);
		goto error;
	}

	bus->fw_state = QTNF_FW_STATE_ACTIVE;

	ret = qtnf_cmd_get_hw_info(bus);
	if (ret) {
		pr_err("failed to get HW info: %d\n", ret);
		goto error;
	}

	if (bus->hw_info.ql_proto_ver != QLINK_PROTO_VER) {
		pr_err("qlink version mismatch %u != %u\n",
		       QLINK_PROTO_VER, bus->hw_info.ql_proto_ver);
		ret = -EPROTONOSUPPORT;
		goto error;
	}

	if (bus->hw_info.num_mac > QTNF_MAX_MAC) {
		pr_err("no support for number of MACs=%u\n",
		       bus->hw_info.num_mac);
		ret = -ERANGE;
		goto error;
	}

	for (i = 0; i < bus->hw_info.num_mac; i++) {
		ret = qtnf_core_mac_attach(bus, i);

		if (ret) {
			pr_err("MAC%u: attach failed: %d\n", i, ret);
			goto error;
		}
	}

	return 0;

error:
	qtnf_core_detach(bus);

	return ret;
}
EXPORT_SYMBOL_GPL(qtnf_core_attach);

void qtnf_core_detach(struct qtnf_bus *bus)
{
	unsigned int macid;

	qtnf_bus_data_rx_stop(bus);

	for (macid = 0; macid < QTNF_MAX_MAC; macid++)
		qtnf_core_mac_detach(bus, macid);

	if (bus->fw_state == QTNF_FW_STATE_ACTIVE)
		qtnf_cmd_send_deinit_fw(bus);

	bus->fw_state = QTNF_FW_STATE_DEAD;

	if (bus->workqueue) {
		flush_workqueue(bus->workqueue);
		destroy_workqueue(bus->workqueue);
	}

	kfree(bus->hw_info.rd);
	bus->hw_info.rd = NULL;

	qtnf_trans_free(bus);
}
EXPORT_SYMBOL_GPL(qtnf_core_detach);

static inline int qtnf_is_frame_meta_magic_valid(struct qtnf_frame_meta_info *m)
{
	return m->magic_s == 0xAB && m->magic_e == 0xBA;
}

struct net_device *qtnf_classify_skb(struct qtnf_bus *bus, struct sk_buff *skb)
{
	struct qtnf_frame_meta_info *meta;
	struct net_device *ndev = NULL;
	struct qtnf_wmac *mac;
	struct qtnf_vif *vif;

	meta = (struct qtnf_frame_meta_info *)
		(skb_tail_pointer(skb) - sizeof(*meta));

	if (unlikely(!qtnf_is_frame_meta_magic_valid(meta))) {
		pr_err_ratelimited("invalid magic 0x%x:0x%x\n",
				   meta->magic_s, meta->magic_e);
		goto out;
	}

	if (unlikely(meta->macid >= QTNF_MAX_MAC)) {
		pr_err_ratelimited("invalid mac(%u)\n", meta->macid);
		goto out;
	}

	if (unlikely(meta->ifidx >= QTNF_MAX_INTF)) {
		pr_err_ratelimited("invalid vif(%u)\n", meta->ifidx);
		goto out;
	}

	mac = bus->mac[meta->macid];

	if (unlikely(!mac)) {
		pr_err_ratelimited("mac(%d) does not exist\n", meta->macid);
		goto out;
	}

	vif = &mac->iflist[meta->ifidx];

	if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
		pr_err_ratelimited("vif(%u) does not exists\n", meta->ifidx);
		goto out;
	}

	ndev = vif->netdev;

	if (unlikely(!ndev)) {
		pr_err_ratelimited("netdev for wlan%u.%u does not exists\n",
				   meta->macid, meta->ifidx);
		goto out;
	}

	__skb_trim(skb, skb->len - sizeof(*meta));

out:
	return ndev;
}
EXPORT_SYMBOL_GPL(qtnf_classify_skb);

void qtnf_wake_all_queues(struct net_device *ndev)
{
	struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
	struct qtnf_wmac *mac;
	struct qtnf_bus *bus;
	int macid;
	int i;

	if (unlikely(!vif || !vif->mac || !vif->mac->bus))
		return;

	bus = vif->mac->bus;

	for (macid = 0; macid < QTNF_MAX_MAC; macid++) {
		if (!(bus->hw_info.mac_bitmap & BIT(macid)))
			continue;

		mac = bus->mac[macid];
		for (i = 0; i < QTNF_MAX_INTF; i++) {
			vif = &mac->iflist[i];
			if (vif->netdev && netif_queue_stopped(vif->netdev))
				netif_tx_wake_all_queues(vif->netdev);
		}
	}
}
EXPORT_SYMBOL_GPL(qtnf_wake_all_queues);

MODULE_AUTHOR("Quantenna Communications");
MODULE_DESCRIPTION("Quantenna 802.11 wireless LAN FullMAC driver.");
MODULE_LICENSE("GPL");
Commit	Line	Data
98f44cb0 IM	1	/*
	2	* Copyright (c) 2015-2016 Quantenna Communications, Inc.
	3	* All rights reserved.
	4	*
	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.
	9	*
	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.
	14	*
	15	*/
	16
	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/if_ether.h>
	20
	21	#include "core.h"
	22	#include "bus.h"
	23	#include "trans.h"
	24	#include "commands.h"
	25	#include "cfg80211.h"
	26	#include "event.h"
	27	#include "util.h"
	28
	29	#define QTNF_DMP_MAX_LEN 48
	30	#define QTNF_PRIMARY_VIF_IDX 0
	31
	32	struct qtnf_frame_meta_info {
	33	u8 magic_s;
	34	u8 ifidx;
	35	u8 macid;
	36	u8 magic_e;
	37	} __packed;
	38
	39	struct qtnf_wmac qtnf_core_get_mac(const struct qtnf_bus bus, u8 macid)
	40	{
	41	struct qtnf_wmac *mac = NULL;
	42
	43	if (unlikely(macid >= QTNF_MAX_MAC)) {
	44	pr_err("invalid MAC index %u\n", macid);
	45	return NULL;
	46	}
	47
	48	mac = bus->mac[macid];
	49
	50	if (unlikely(!mac)) {
	51	pr_err("MAC%u: not initialized\n", macid);
	52	return NULL;
	53	}
	54
	55	return mac;
	56	}
	57
	58	/* Netdev handler for open.
	59	*/
	60	static int qtnf_netdev_open(struct net_device *ndev)
	61	{
	62	netif_carrier_off(ndev);
	63	qtnf_netdev_updown(ndev, 1);
	64	return 0;
65	}
66
67	/* Netdev handler for close.
68	*/
69	static int qtnf_netdev_close(struct net_device *ndev)
70	{
71	netif_carrier_off(ndev);
72	qtnf_virtual_intf_cleanup(ndev);
73	qtnf_netdev_updown(ndev, 0);
74	return 0;
75	}
76
77	/* Netdev handler for data transmission.
78	*/
79	static int
80	qtnf_netdev_hard_start_xmit(struct sk_buff skb, struct net_device ndev)
81	{
82	struct qtnf_vif *vif;
83	struct qtnf_wmac *mac;
84
85	vif = qtnf_netdev_get_priv(ndev);
86
87	if (unlikely(skb->dev != ndev)) {
88	pr_err_ratelimited("invalid skb->dev");
89	dev_kfree_skb_any(skb);
90	return 0;
91	}
92
93	if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
94	pr_err_ratelimited("%s: VIF not initialized\n", ndev->name);
95	dev_kfree_skb_any(skb);
96	return 0;
97	}
98
99	mac = vif->mac;
100	if (unlikely(!mac)) {
101	pr_err_ratelimited("%s: NULL mac pointer", ndev->name);
102	dev_kfree_skb_any(skb);
103	return 0;
104	}
105
106	if (!skb->len \|\| (skb->len > ETH_FRAME_LEN)) {
107	pr_err_ratelimited("%s: invalid skb len %d\n", ndev->name,
108	skb->len);
109	dev_kfree_skb_any(skb);
110	ndev->stats.tx_dropped++;
111	return 0;
112	}
113
114	/* tx path is enabled: reset vif timeout */
115	vif->cons_tx_timeout_cnt = 0;
116
117	return qtnf_bus_data_tx(mac->bus, skb);
118	}
119
120	/* Netdev handler for getting stats.
121	*/
122	static struct net_device_stats qtnf_netdev_get_stats(struct net_device dev)
123	{
124	return &dev->stats;
125	}
126
127	/* Netdev handler for transmission timeout.
128	*/
129	static void qtnf_netdev_tx_timeout(struct net_device *ndev)
130	{
131	struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
132	struct qtnf_wmac *mac;
133	struct qtnf_bus *bus;
134
135	if (unlikely(!vif \|\| !vif->mac \|\| !vif->mac->bus))
136	return;
137
138	mac = vif->mac;
139	bus = mac->bus;
140
141	pr_warn("VIF%u.%u: Tx timeout- %lu\n", mac->macid, vif->vifid, jiffies);
142
143	qtnf_bus_data_tx_timeout(bus, ndev);
144	ndev->stats.tx_errors++;
145
146	if (++vif->cons_tx_timeout_cnt > QTNF_TX_TIMEOUT_TRSHLD) {
147	pr_err("Tx timeout threshold exceeded !\n");
148	pr_err("schedule interface %s reset !\n", netdev_name(ndev));
149	queue_work(bus->workqueue, &vif->reset_work);
150	}
151	}
152
153	/* Network device ops handlers */
154	const struct net_device_ops qtnf_netdev_ops = {
155	.ndo_open = qtnf_netdev_open,
156	.ndo_stop = qtnf_netdev_close,
157	.ndo_start_xmit = qtnf_netdev_hard_start_xmit,
158	.ndo_tx_timeout = qtnf_netdev_tx_timeout,
159	.ndo_get_stats = qtnf_netdev_get_stats,
160	};
161
162	static int qtnf_mac_init_single_band(struct wiphy *wiphy,
163	struct qtnf_wmac *mac,
164	enum nl80211_band band)
165	{
166	int ret;
167
168	wiphy->bands[band] = kzalloc(sizeof(*wiphy->bands[band]), GFP_KERNEL);
169	if (!wiphy->bands[band])
170	return -ENOMEM;
171
172	wiphy->bands[band]->band = band;
173
e294cbfd	174	ret = qtnf_cmd_band_info_get(mac, wiphy->bands[band]);
98f44cb0 IM	175	if (ret) {
	176	pr_err("MAC%u: band %u: failed to get chans info: %d\n",
	177	mac->macid, band, ret);
	178	return ret;
	179	}
	180
	181	qtnf_band_init_rates(wiphy->bands[band]);
98f44cb0 IM	182
	183	return 0;
	184	}
	185
	186	static int qtnf_mac_init_bands(struct qtnf_wmac *mac)
	187	{
	188	struct wiphy *wiphy = priv_to_wiphy(mac);
	189	int ret = 0;
	190
	191	if (mac->macinfo.bands_cap & QLINK_BAND_2GHZ) {
	192	ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_2GHZ);
	193	if (ret)
	194	goto out;
	195	}
	196
	197	if (mac->macinfo.bands_cap & QLINK_BAND_5GHZ) {
	198	ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_5GHZ);
	199	if (ret)
	200	goto out;
	201	}
	202
	203	if (mac->macinfo.bands_cap & QLINK_BAND_60GHZ)
	204	ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_60GHZ);
	205
	206	out:
	207	return ret;
	208	}
	209
	210	struct qtnf_vif qtnf_mac_get_free_vif(struct qtnf_wmac mac)
	211	{
	212	struct qtnf_vif *vif;
	213	int i;
	214
	215	for (i = 0; i < QTNF_MAX_INTF; i++) {
	216	vif = &mac->iflist[i];
	217	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
	218	return vif;
	219	}
	220
	221	return NULL;
	222	}
	223
	224	struct qtnf_vif qtnf_mac_get_base_vif(struct qtnf_wmac mac)
	225	{
	226	struct qtnf_vif *vif;
	227
	228	vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];
	229
	230	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
	231	return NULL;
	232
	233	return vif;
	234	}
	235
	236	static void qtnf_vif_reset_handler(struct work_struct *work)
	237	{
	238	struct qtnf_vif *vif = container_of(work, struct qtnf_vif, reset_work);
	239
	240	rtnl_lock();
	241
	242	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) {
	243	rtnl_unlock();
	244	return;
	245	}
246
247	/* stop tx completely */
248	netif_tx_stop_all_queues(vif->netdev);
249	if (netif_carrier_ok(vif->netdev))
250	netif_carrier_off(vif->netdev);
251
252	qtnf_cfg80211_vif_reset(vif);
253
254	rtnl_unlock();
255	}
256
257	static void qtnf_mac_init_primary_intf(struct qtnf_wmac *mac)
258	{
259	struct qtnf_vif *vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];
260
261	vif->wdev.iftype = NL80211_IFTYPE_AP;
262	vif->bss_priority = QTNF_DEF_BSS_PRIORITY;
263	vif->wdev.wiphy = priv_to_wiphy(mac);
264	INIT_WORK(&vif->reset_work, qtnf_vif_reset_handler);
265	vif->cons_tx_timeout_cnt = 0;
266	}
267
268	static struct qtnf_wmac qtnf_core_mac_alloc(struct qtnf_bus bus,
269	unsigned int macid)
270	{
271	struct wiphy *wiphy;
272	struct qtnf_wmac *mac;
273	unsigned int i;
274
275	wiphy = qtnf_wiphy_allocate(bus);
276	if (!wiphy)
277	return ERR_PTR(-ENOMEM);
278
279	mac = wiphy_priv(wiphy);
280
281	mac->macid = macid;
282	mac->bus = bus;
283
284	for (i = 0; i < QTNF_MAX_INTF; i++) {
285	memset(&mac->iflist[i], 0, sizeof(struct qtnf_vif));
286	mac->iflist[i].wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
287	mac->iflist[i].mac = mac;
288	mac->iflist[i].vifid = i;
289	qtnf_sta_list_init(&mac->iflist[i].sta_list);
c7ead2ab	290	mutex_init(&mac->mac_lock);
e99e88a9	291	timer_setup(&mac->scan_timeout, NULL, 0);
98f44cb0 IM	292	}
	293
	294	qtnf_mac_init_primary_intf(mac);
	295	bus->mac[macid] = mac;
	296
	297	return mac;
	298	}
	299
	300	int qtnf_core_net_attach(struct qtnf_wmac mac, struct qtnf_vif vif,
	301	const char *name, unsigned char name_assign_type,
	302	enum nl80211_iftype iftype)
	303	{
	304	struct wiphy *wiphy = priv_to_wiphy(mac);
	305	struct net_device *dev;
	306	void *qdev_vif;
	307	int ret;
	308
	309	dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name,
	310	name_assign_type, ether_setup, 1, 1);
	311	if (!dev) {
	312	memset(&vif->wdev, 0, sizeof(vif->wdev));
	313	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
	314	return -ENOMEM;
	315	}
	316
	317	vif->netdev = dev;
	318
	319	dev->netdev_ops = &qtnf_netdev_ops;
0ddead90	320	dev->needs_free_netdev = true;
98f44cb0 IM	321	dev_net_set(dev, wiphy_net(wiphy));
	322	dev->ieee80211_ptr = &vif->wdev;
	323	dev->ieee80211_ptr->iftype = iftype;
	324	ether_addr_copy(dev->dev_addr, vif->mac_addr);
	325	SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
	326	dev->flags \|= IFF_BROADCAST \| IFF_MULTICAST;
	327	dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT;
	328	dev->tx_queue_len = 100;
	329
	330	qdev_vif = netdev_priv(dev);
	331	((void *)qdev_vif) = vif;
	332
	333	SET_NETDEV_DEV(dev, mac->bus->dev);
	334
	335	ret = register_netdevice(dev);
	336	if (ret) {
	337	free_netdev(dev);
	338	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
	339	}
	340
	341	return ret;
	342	}
	343
	344	static void qtnf_core_mac_detach(struct qtnf_bus *bus, unsigned int macid)
	345	{
	346	struct qtnf_wmac *mac;
	347	struct wiphy *wiphy;
	348	struct qtnf_vif *vif;
	349	unsigned int i;
	350	enum nl80211_band band;
	351
	352	mac = bus->mac[macid];
	353
	354	if (!mac)
	355	return;
	356
	357	wiphy = priv_to_wiphy(mac);
	358
	359	for (i = 0; i < QTNF_MAX_INTF; i++) {
	360	vif = &mac->iflist[i];
	361	rtnl_lock();
	362	if (vif->netdev &&
	363	vif->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) {
	364	qtnf_virtual_intf_cleanup(vif->netdev);
	365	qtnf_del_virtual_intf(wiphy, &vif->wdev);
	366	}
	367	rtnl_unlock();
	368	qtnf_sta_list_free(&vif->sta_list);
	369	}
	370
	371	if (mac->wiphy_registered)
	372	wiphy_unregister(wiphy);
	373
	374	for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; ++band) {
	375	if (!wiphy->bands[band])
	376	continue;
	377
	378	kfree(wiphy->bands[band]->channels);
	379	wiphy->bands[band]->n_channels = 0;
	380
	381	kfree(wiphy->bands[band]);
	382	wiphy->bands[band] = NULL;
	383	}
	384
385	kfree(mac->macinfo.limits);
386	kfree(wiphy->iface_combinations);
387	wiphy_free(wiphy);
388	bus->mac[macid] = NULL;
389	}
390
391	static int qtnf_core_mac_attach(struct qtnf_bus *bus, unsigned int macid)
392	{
393	struct qtnf_wmac *mac;
394	struct qtnf_vif *vif;
395	int ret;
396
397	if (!(bus->hw_info.mac_bitmap & BIT(macid))) {
398	pr_info("MAC%u is not active in FW\n", macid);
399	return 0;
400	}
401
402	mac = qtnf_core_mac_alloc(bus, macid);
403	if (IS_ERR(mac)) {
404	pr_err("MAC%u allocation failed\n", macid);
405	return PTR_ERR(mac);
406	}
407
408	ret = qtnf_cmd_get_mac_info(mac);
409	if (ret) {
410	pr_err("MAC%u: failed to get info\n", macid);
411	goto error;
412	}
413
414	vif = qtnf_mac_get_base_vif(mac);
415	if (!vif) {
416	pr_err("MAC%u: primary VIF is not ready\n", macid);
417	ret = -EFAULT;
418	goto error;
419	}
420
421	ret = qtnf_cmd_send_add_intf(vif, NL80211_IFTYPE_AP, vif->mac_addr);
422	if (ret) {
423	pr_err("MAC%u: failed to add VIF\n", macid);
424	goto error;
425	}
426
427	ret = qtnf_cmd_send_get_phy_params(mac);
428	if (ret) {
429	pr_err("MAC%u: failed to get PHY settings\n", macid);
430	goto error;
431	}
432
433	ret = qtnf_mac_init_bands(mac);
434	if (ret) {
435	pr_err("MAC%u: failed to init bands\n", macid);
436	goto error;
437	}
438
439	ret = qtnf_wiphy_register(&bus->hw_info, mac);
440	if (ret) {
441	pr_err("MAC%u: wiphy registration failed\n", macid);
442	goto error;
443	}
444
445	mac->wiphy_registered = 1;
446
447	rtnl_lock();
448
449	ret = qtnf_core_net_attach(mac, vif, "wlan%d", NET_NAME_ENUM,
450	NL80211_IFTYPE_AP);
451	rtnl_unlock();
452
453	if (ret) {
454	pr_err("MAC%u: failed to attach netdev\n", macid);
455	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
456	vif->netdev = NULL;
457	goto error;
458	}
459
460	pr_debug("MAC%u initialized\n", macid);
461
462	return 0;
463
464	error:
465	qtnf_core_mac_detach(bus, macid);
466	return ret;
467	}
468
469	int qtnf_core_attach(struct qtnf_bus *bus)
470	{
471	unsigned int i;
472	int ret;
473
474	qtnf_trans_init(bus);
475
476	bus->fw_state = QTNF_FW_STATE_BOOT_DONE;
477	qtnf_bus_data_rx_start(bus);
478
479	bus->workqueue = alloc_ordered_workqueue("QTNF_BUS", 0);
480	if (!bus->workqueue) {
481	pr_err("failed to alloc main workqueue\n");
482	ret = -ENOMEM;
483	goto error;
484	}
485
486	INIT_WORK(&bus->event_work, qtnf_event_work_handler);
487
488	ret = qtnf_cmd_send_init_fw(bus);
489	if (ret) {
490	pr_err("failed to init FW: %d\n", ret);
491	goto error;
492	}
493
494	bus->fw_state = QTNF_FW_STATE_ACTIVE;
495
496	ret = qtnf_cmd_get_hw_info(bus);
497	if (ret) {
498	pr_err("failed to get HW info: %d\n", ret);
499	goto error;
500	}
501
502	if (bus->hw_info.ql_proto_ver != QLINK_PROTO_VER) {
503	pr_err("qlink version mismatch %u != %u\n",
504	QLINK_PROTO_VER, bus->hw_info.ql_proto_ver);
505	ret = -EPROTONOSUPPORT;
506	goto error;
507	}
508
509	if (bus->hw_info.num_mac > QTNF_MAX_MAC) {
510	pr_err("no support for number of MACs=%u\n",
511	bus->hw_info.num_mac);
512	ret = -ERANGE;
513	goto error;
514	}
515
516	for (i = 0; i < bus->hw_info.num_mac; i++) {
517	ret = qtnf_core_mac_attach(bus, i);
518
519	if (ret) {
520	pr_err("MAC%u: attach failed: %d\n", i, ret);
521	goto error;
522	}
523	}
524
525	return 0;
526
527	error:
528	qtnf_core_detach(bus);
529
530	return ret;
531	}
532	EXPORT_SYMBOL_GPL(qtnf_core_attach);
533
534	void qtnf_core_detach(struct qtnf_bus *bus)
535	{
536	unsigned int macid;
537
538	qtnf_bus_data_rx_stop(bus);
539
540	for (macid = 0; macid < QTNF_MAX_MAC; macid++)
541	qtnf_core_mac_detach(bus, macid);
542
543	if (bus->fw_state == QTNF_FW_STATE_ACTIVE)
544	qtnf_cmd_send_deinit_fw(bus);
545
546	bus->fw_state = QTNF_FW_STATE_DEAD;
547
548	if (bus->workqueue) {
549	flush_workqueue(bus->workqueue);
550	destroy_workqueue(bus->workqueue);
551	}
552
4dd07d2b SM	553	kfree(bus->hw_info.rd);
	554	bus->hw_info.rd = NULL;
	555
98f44cb0 IM	556	qtnf_trans_free(bus);
	557	}
	558	EXPORT_SYMBOL_GPL(qtnf_core_detach);
	559
	560	static inline int qtnf_is_frame_meta_magic_valid(struct qtnf_frame_meta_info *m)
	561	{
	562	return m->magic_s == 0xAB && m->magic_e == 0xBA;
	563	}
	564
	565	struct net_device qtnf_classify_skb(struct qtnf_bus bus, struct sk_buff *skb)
	566	{
	567	struct qtnf_frame_meta_info *meta;
	568	struct net_device *ndev = NULL;
	569	struct qtnf_wmac *mac;
	570	struct qtnf_vif *vif;
	571
	572	meta = (struct qtnf_frame_meta_info *)
	573	(skb_tail_pointer(skb) - sizeof(*meta));
	574
	575	if (unlikely(!qtnf_is_frame_meta_magic_valid(meta))) {
	576	pr_err_ratelimited("invalid magic 0x%x:0x%x\n",
	577	meta->magic_s, meta->magic_e);
	578	goto out;
	579	}
	580
	581	if (unlikely(meta->macid >= QTNF_MAX_MAC)) {
	582	pr_err_ratelimited("invalid mac(%u)\n", meta->macid);
	583	goto out;
	584	}
	585
	586	if (unlikely(meta->ifidx >= QTNF_MAX_INTF)) {
	587	pr_err_ratelimited("invalid vif(%u)\n", meta->ifidx);
	588	goto out;
	589	}
	590
	591	mac = bus->mac[meta->macid];
	592
	593	if (unlikely(!mac)) {
	594	pr_err_ratelimited("mac(%d) does not exist\n", meta->macid);
	595	goto out;
	596	}
	597
	598	vif = &mac->iflist[meta->ifidx];
	599
	600	if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
	601	pr_err_ratelimited("vif(%u) does not exists\n", meta->ifidx);
	602	goto out;
	603	}
	604
	605	ndev = vif->netdev;
	606
	607	if (unlikely(!ndev)) {
	608	pr_err_ratelimited("netdev for wlan%u.%u does not exists\n",
	609	meta->macid, meta->ifidx);
	610	goto out;
	611	}
	612
	613	__skb_trim(skb, skb->len - sizeof(*meta));
	614
	615	out:
	616	return ndev;
	617	}
	618	EXPORT_SYMBOL_GPL(qtnf_classify_skb);
	619
c35c0d54 SM	620	void qtnf_wake_all_queues(struct net_device *ndev)
	621	{
	622	struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev);
	623	struct qtnf_wmac *mac;
	624	struct qtnf_bus *bus;
	625	int macid;
	626	int i;
	627
	628	if (unlikely(!vif \|\| !vif->mac \|\| !vif->mac->bus))
	629	return;
	630
	631	bus = vif->mac->bus;
	632
	633	for (macid = 0; macid < QTNF_MAX_MAC; macid++) {
	634	if (!(bus->hw_info.mac_bitmap & BIT(macid)))
	635	continue;
	636
	637	mac = bus->mac[macid];
	638	for (i = 0; i < QTNF_MAX_INTF; i++) {
	639	vif = &mac->iflist[i];
	640	if (vif->netdev && netif_queue_stopped(vif->netdev))
	641	netif_tx_wake_all_queues(vif->netdev);
	642	}
	643	}
	644	}
	645	EXPORT_SYMBOL_GPL(qtnf_wake_all_queues);
	646
98f44cb0 IM	647	MODULE_AUTHOR("Quantenna Communications");
	648	MODULE_DESCRIPTION("Quantenna 802.11 wireless LAN FullMAC driver.");
	649	MODULE_LICENSE("GPL");