[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_get_mac_chan_info(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]);
	qtnf_band_setup_htvht_caps(&mac->macinfo, 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);
	}

	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->destructor = free_netdev;
	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);
	}

	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);

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
174	ret = qtnf_cmd_get_mac_chan_info(mac, wiphy->bands[band]);
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]);
182	qtnf_band_setup_htvht_caps(&mac->macinfo, wiphy->bands[band]);
183
184	return 0;
185	}
186
187	static int qtnf_mac_init_bands(struct qtnf_wmac *mac)
188	{
189	struct wiphy *wiphy = priv_to_wiphy(mac);
190	int ret = 0;
191
192	if (mac->macinfo.bands_cap & QLINK_BAND_2GHZ) {
193	ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_2GHZ);
194	if (ret)
195	goto out;
196	}
197
198	if (mac->macinfo.bands_cap & QLINK_BAND_5GHZ) {
199	ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_5GHZ);
200	if (ret)
201	goto out;
202	}
203
204	if (mac->macinfo.bands_cap & QLINK_BAND_60GHZ)
205	ret = qtnf_mac_init_single_band(wiphy, mac, NL80211_BAND_60GHZ);
206
207	out:
208	return ret;
209	}
210
211	struct qtnf_vif qtnf_mac_get_free_vif(struct qtnf_wmac mac)
212	{
213	struct qtnf_vif *vif;
214	int i;
215
216	for (i = 0; i < QTNF_MAX_INTF; i++) {
217	vif = &mac->iflist[i];
218	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
219	return vif;
220	}
221
222	return NULL;
223	}
224
225	struct qtnf_vif qtnf_mac_get_base_vif(struct qtnf_wmac mac)
226	{
227	struct qtnf_vif *vif;
228
229	vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];
230
231	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)
232	return NULL;
233
234	return vif;
235	}
236
237	static void qtnf_vif_reset_handler(struct work_struct *work)
238	{
239	struct qtnf_vif *vif = container_of(work, struct qtnf_vif, reset_work);
240
241	rtnl_lock();
242
243	if (vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED) {
244	rtnl_unlock();
245	return;
246	}
247
248	/* stop tx completely */
249	netif_tx_stop_all_queues(vif->netdev);
250	if (netif_carrier_ok(vif->netdev))
251	netif_carrier_off(vif->netdev);
252
253	qtnf_cfg80211_vif_reset(vif);
254
255	rtnl_unlock();
256	}
257
258	static void qtnf_mac_init_primary_intf(struct qtnf_wmac *mac)
259	{
260	struct qtnf_vif *vif = &mac->iflist[QTNF_PRIMARY_VIF_IDX];
261
262	vif->wdev.iftype = NL80211_IFTYPE_AP;
263	vif->bss_priority = QTNF_DEF_BSS_PRIORITY;
264	vif->wdev.wiphy = priv_to_wiphy(mac);
265	INIT_WORK(&vif->reset_work, qtnf_vif_reset_handler);
266	vif->cons_tx_timeout_cnt = 0;
267	}
268
269	static struct qtnf_wmac qtnf_core_mac_alloc(struct qtnf_bus bus,
270	unsigned int macid)
271	{
272	struct wiphy *wiphy;
273	struct qtnf_wmac *mac;
274	unsigned int i;
275
276	wiphy = qtnf_wiphy_allocate(bus);
277	if (!wiphy)
278	return ERR_PTR(-ENOMEM);
279
280	mac = wiphy_priv(wiphy);
281
282	mac->macid = macid;
283	mac->bus = bus;
284
285	for (i = 0; i < QTNF_MAX_INTF; i++) {
286	memset(&mac->iflist[i], 0, sizeof(struct qtnf_vif));
287	mac->iflist[i].wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
288	mac->iflist[i].mac = mac;
289	mac->iflist[i].vifid = i;
290	qtnf_sta_list_init(&mac->iflist[i].sta_list);
291	}
292
293	qtnf_mac_init_primary_intf(mac);
294	bus->mac[macid] = mac;
295
296	return mac;
297	}
298
299	int qtnf_core_net_attach(struct qtnf_wmac mac, struct qtnf_vif vif,
300	const char *name, unsigned char name_assign_type,
301	enum nl80211_iftype iftype)
302	{
303	struct wiphy *wiphy = priv_to_wiphy(mac);
304	struct net_device *dev;
305	void *qdev_vif;
306	int ret;
307
308	dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name,
309	name_assign_type, ether_setup, 1, 1);
310	if (!dev) {
311	memset(&vif->wdev, 0, sizeof(vif->wdev));
312	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
313	return -ENOMEM;
314	}
315
316	vif->netdev = dev;
317
318	dev->netdev_ops = &qtnf_netdev_ops;
319	dev->destructor = free_netdev;
320	dev_net_set(dev, wiphy_net(wiphy));
321	dev->ieee80211_ptr = &vif->wdev;
322	dev->ieee80211_ptr->iftype = iftype;
323	ether_addr_copy(dev->dev_addr, vif->mac_addr);
324	SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
325	dev->flags \|= IFF_BROADCAST \| IFF_MULTICAST;
326	dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT;
327	dev->tx_queue_len = 100;
328
329	qdev_vif = netdev_priv(dev);
330	((void *)qdev_vif) = vif;
331
332	SET_NETDEV_DEV(dev, mac->bus->dev);
333
334	ret = register_netdevice(dev);
335	if (ret) {
336	free_netdev(dev);
337	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
338	}
339
340	return ret;
341	}
342
343	static void qtnf_core_mac_detach(struct qtnf_bus *bus, unsigned int macid)
344	{
345	struct qtnf_wmac *mac;
346	struct wiphy *wiphy;
347	struct qtnf_vif *vif;
348	unsigned int i;
349	enum nl80211_band band;
350
351	mac = bus->mac[macid];
352
353	if (!mac)
354	return;
355
356	wiphy = priv_to_wiphy(mac);
357
358	for (i = 0; i < QTNF_MAX_INTF; i++) {
359	vif = &mac->iflist[i];
360	rtnl_lock();
361	if (vif->netdev &&
362	vif->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) {
363	qtnf_virtual_intf_cleanup(vif->netdev);
364	qtnf_del_virtual_intf(wiphy, &vif->wdev);
365	}
366	rtnl_unlock();
367	qtnf_sta_list_free(&vif->sta_list);
368	}
369
370	if (mac->wiphy_registered)
371	wiphy_unregister(wiphy);
372
373	for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; ++band) {
374	if (!wiphy->bands[band])
375	continue;
376
377	kfree(wiphy->bands[band]->channels);
378	wiphy->bands[band]->n_channels = 0;
379
380	kfree(wiphy->bands[band]);
381	wiphy->bands[band] = NULL;
382	}
383
384	kfree(mac->macinfo.limits);
385	kfree(wiphy->iface_combinations);
386	wiphy_free(wiphy);
387	bus->mac[macid] = NULL;
388	}
389
390	static int qtnf_core_mac_attach(struct qtnf_bus *bus, unsigned int macid)
391	{
392	struct qtnf_wmac *mac;
393	struct qtnf_vif *vif;
394	int ret;
395
396	if (!(bus->hw_info.mac_bitmap & BIT(macid))) {
397	pr_info("MAC%u is not active in FW\n", macid);
398	return 0;
399	}
400
401	mac = qtnf_core_mac_alloc(bus, macid);
402	if (IS_ERR(mac)) {
403	pr_err("MAC%u allocation failed\n", macid);
404	return PTR_ERR(mac);
405	}
406
407	ret = qtnf_cmd_get_mac_info(mac);
408	if (ret) {
409	pr_err("MAC%u: failed to get info\n", macid);
410	goto error;
411	}
412
413	vif = qtnf_mac_get_base_vif(mac);
414	if (!vif) {
415	pr_err("MAC%u: primary VIF is not ready\n", macid);
416	ret = -EFAULT;
417	goto error;
418	}
419
420	ret = qtnf_cmd_send_add_intf(vif, NL80211_IFTYPE_AP, vif->mac_addr);
421	if (ret) {
422	pr_err("MAC%u: failed to add VIF\n", macid);
423	goto error;
424	}
425
426	ret = qtnf_cmd_send_get_phy_params(mac);
427	if (ret) {
428	pr_err("MAC%u: failed to get PHY settings\n", macid);
429	goto error;
430	}
431
432	ret = qtnf_mac_init_bands(mac);
433	if (ret) {
434	pr_err("MAC%u: failed to init bands\n", macid);
435	goto error;
436	}
437
438	ret = qtnf_wiphy_register(&bus->hw_info, mac);
439	if (ret) {
440	pr_err("MAC%u: wiphy registration failed\n", macid);
441	goto error;
442	}
443
444	mac->wiphy_registered = 1;
445
446	rtnl_lock();
447
448	ret = qtnf_core_net_attach(mac, vif, "wlan%d", NET_NAME_ENUM,
449	NL80211_IFTYPE_AP);
450	rtnl_unlock();
451
452	if (ret) {
453	pr_err("MAC%u: failed to attach netdev\n", macid);
454	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
455	vif->netdev = NULL;
456	goto error;
457	}
458
459	pr_debug("MAC%u initialized\n", macid);
460
461	return 0;
462
463	error:
464	qtnf_core_mac_detach(bus, macid);
465	return ret;
466	}
467
468	int qtnf_core_attach(struct qtnf_bus *bus)
469	{
470	unsigned int i;
471	int ret;
472
473	qtnf_trans_init(bus);
474
475	bus->fw_state = QTNF_FW_STATE_BOOT_DONE;
476	qtnf_bus_data_rx_start(bus);
477
478	bus->workqueue = alloc_ordered_workqueue("QTNF_BUS", 0);
479	if (!bus->workqueue) {
480	pr_err("failed to alloc main workqueue\n");
481	ret = -ENOMEM;
482	goto error;
483	}
484
485	INIT_WORK(&bus->event_work, qtnf_event_work_handler);
486
487	ret = qtnf_cmd_send_init_fw(bus);
488	if (ret) {
489	pr_err("failed to init FW: %d\n", ret);
490	goto error;
491	}
492
493	bus->fw_state = QTNF_FW_STATE_ACTIVE;
494
495	ret = qtnf_cmd_get_hw_info(bus);
496	if (ret) {
497	pr_err("failed to get HW info: %d\n", ret);
498	goto error;
499	}
500
501	if (bus->hw_info.ql_proto_ver != QLINK_PROTO_VER) {
502	pr_err("qlink version mismatch %u != %u\n",
503	QLINK_PROTO_VER, bus->hw_info.ql_proto_ver);
504	ret = -EPROTONOSUPPORT;
505	goto error;
506	}
507
508	if (bus->hw_info.num_mac > QTNF_MAX_MAC) {
509	pr_err("no support for number of MACs=%u\n",
510	bus->hw_info.num_mac);
511	ret = -ERANGE;
512	goto error;
513	}
514
515	for (i = 0; i < bus->hw_info.num_mac; i++) {
516	ret = qtnf_core_mac_attach(bus, i);
517
518	if (ret) {
519	pr_err("MAC%u: attach failed: %d\n", i, ret);
520	goto error;
521	}
522	}
523
524	return 0;
525
526	error:
527	qtnf_core_detach(bus);
528
529	return ret;
530	}
531	EXPORT_SYMBOL_GPL(qtnf_core_attach);
532
533	void qtnf_core_detach(struct qtnf_bus *bus)
534	{
535	unsigned int macid;
536
537	qtnf_bus_data_rx_stop(bus);
538
539	for (macid = 0; macid < QTNF_MAX_MAC; macid++)
540	qtnf_core_mac_detach(bus, macid);
541
542	if (bus->fw_state == QTNF_FW_STATE_ACTIVE)
543	qtnf_cmd_send_deinit_fw(bus);
544
545	bus->fw_state = QTNF_FW_STATE_DEAD;
546
547	if (bus->workqueue) {
548	flush_workqueue(bus->workqueue);
549	destroy_workqueue(bus->workqueue);
550	}
551
552	qtnf_trans_free(bus);
553	}
554	EXPORT_SYMBOL_GPL(qtnf_core_detach);
555
556	static inline int qtnf_is_frame_meta_magic_valid(struct qtnf_frame_meta_info *m)
557	{
558	return m->magic_s == 0xAB && m->magic_e == 0xBA;
559	}
560
561	struct net_device qtnf_classify_skb(struct qtnf_bus bus, struct sk_buff *skb)
562	{
563	struct qtnf_frame_meta_info *meta;
564	struct net_device *ndev = NULL;
565	struct qtnf_wmac *mac;
566	struct qtnf_vif *vif;
567
568	meta = (struct qtnf_frame_meta_info *)
569	(skb_tail_pointer(skb) - sizeof(*meta));
570
571	if (unlikely(!qtnf_is_frame_meta_magic_valid(meta))) {
572	pr_err_ratelimited("invalid magic 0x%x:0x%x\n",
573	meta->magic_s, meta->magic_e);
574	goto out;
575	}
576
577	if (unlikely(meta->macid >= QTNF_MAX_MAC)) {
578	pr_err_ratelimited("invalid mac(%u)\n", meta->macid);
579	goto out;
580	}
581
582	if (unlikely(meta->ifidx >= QTNF_MAX_INTF)) {
583	pr_err_ratelimited("invalid vif(%u)\n", meta->ifidx);
584	goto out;
585	}
586
587	mac = bus->mac[meta->macid];
588
589	if (unlikely(!mac)) {
590	pr_err_ratelimited("mac(%d) does not exist\n", meta->macid);
591	goto out;
592	}
593
594	vif = &mac->iflist[meta->ifidx];
595
596	if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) {
597	pr_err_ratelimited("vif(%u) does not exists\n", meta->ifidx);
598	goto out;
599	}
600
601	ndev = vif->netdev;
602
603	if (unlikely(!ndev)) {
604	pr_err_ratelimited("netdev for wlan%u.%u does not exists\n",
605	meta->macid, meta->ifidx);
606	goto out;
607	}
608
609	__skb_trim(skb, skb->len - sizeof(*meta));
610
611	out:
612	return ndev;
613	}
614	EXPORT_SYMBOL_GPL(qtnf_classify_skb);
615
616	MODULE_AUTHOR("Quantenna Communications");
617	MODULE_DESCRIPTION("Quantenna 802.11 wireless LAN FullMAC driver.");
618	MODULE_LICENSE("GPL");