[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / ath / wil6210 / cfg80211.c

/*
 * Copyright (c) 2012 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "wil6210.h"
#include "wmi.h"

#define CHAN60G(_channel, _flags) {				\
	.band			= IEEE80211_BAND_60GHZ,		\
	.center_freq		= 56160 + (2160 * (_channel)),	\
	.hw_value		= (_channel),			\
	.flags			= (_flags),			\
	.max_antenna_gain	= 0,				\
	.max_power		= 40,				\
}

static struct ieee80211_channel wil_60ghz_channels[] = {
	CHAN60G(1, 0),
	CHAN60G(2, 0),
	CHAN60G(3, 0),
/* channel 4 not supported yet */
};

static struct ieee80211_supported_band wil_band_60ghz = {
	.channels = wil_60ghz_channels,
	.n_channels = ARRAY_SIZE(wil_60ghz_channels),
	.ht_cap = {
		.ht_supported = true,
		.cap = 0, /* TODO */
		.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, /* TODO */
		.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, /* TODO */
		.mcs = {
				/* MCS 1..12 - SC PHY */
			.rx_mask = {0xfe, 0x1f}, /* 1..12 */
			.tx_params = IEEE80211_HT_MCS_TX_DEFINED, /* TODO */
		},
	},
};

static const struct ieee80211_txrx_stypes
wil_mgmt_stypes[NUM_NL80211_IFTYPES] = {
	[NL80211_IFTYPE_STATION] = {
		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	},
	[NL80211_IFTYPE_AP] = {
		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	},
	[NL80211_IFTYPE_P2P_CLIENT] = {
		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	},
	[NL80211_IFTYPE_P2P_GO] = {
		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	},
};

static const u32 wil_cipher_suites[] = {
	WLAN_CIPHER_SUITE_GCMP,
};

int wil_iftype_nl2wmi(enum nl80211_iftype type)
{
	static const struct {
		enum nl80211_iftype nl;
		enum wmi_network_type wmi;
	} __nl2wmi[] = {
		{NL80211_IFTYPE_ADHOC,		WMI_NETTYPE_ADHOC},
		{NL80211_IFTYPE_STATION,	WMI_NETTYPE_INFRA},
		{NL80211_IFTYPE_AP,		WMI_NETTYPE_AP},
		{NL80211_IFTYPE_P2P_CLIENT,	WMI_NETTYPE_P2P},
		{NL80211_IFTYPE_P2P_GO,		WMI_NETTYPE_P2P},
		{NL80211_IFTYPE_MONITOR,	WMI_NETTYPE_ADHOC}, /* FIXME */
	};
	uint i;

	for (i = 0; i < ARRAY_SIZE(__nl2wmi); i++) {
		if (__nl2wmi[i].nl == type)
			return __nl2wmi[i].wmi;
	}

	return -EOPNOTSUPP;
}

static int wil_cfg80211_get_station(struct wiphy *wiphy,
				    struct net_device *ndev,
				    u8 *mac, struct station_info *sinfo)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	int rc;
	struct wmi_notify_req_cmd cmd = {
		.cid = 0,
		.interval_usec = 0,
	};

	if (memcmp(mac, wil->dst_addr[0], ETH_ALEN))
		return -ENOENT;

	/* WMI_NOTIFY_REQ_DONE_EVENTID handler fills wil->stats.bf_mcs */
	rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd),
		      WMI_NOTIFY_REQ_DONE_EVENTID, NULL, 0, 20);
	if (rc)
		return rc;

	sinfo->generation = wil->sinfo_gen;

	sinfo->filled |= STATION_INFO_TX_BITRATE;
	sinfo->txrate.flags = RATE_INFO_FLAGS_MCS | RATE_INFO_FLAGS_60G;
	sinfo->txrate.mcs = wil->stats.bf_mcs;
	sinfo->filled |= STATION_INFO_RX_BITRATE;
	sinfo->rxrate.flags = RATE_INFO_FLAGS_MCS | RATE_INFO_FLAGS_60G;
	sinfo->rxrate.mcs = wil->stats.last_mcs_rx;

	if (test_bit(wil_status_fwconnected, &wil->status)) {
		sinfo->filled |= STATION_INFO_SIGNAL;
		sinfo->signal = 12; /* TODO: provide real value */
	}

	return 0;
}

static int wil_cfg80211_change_iface(struct wiphy *wiphy,
				     struct net_device *ndev,
				     enum nl80211_iftype type, u32 *flags,
				     struct vif_params *params)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	struct wireless_dev *wdev = wil->wdev;

	switch (type) {
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_P2P_GO:
		break;
	case NL80211_IFTYPE_MONITOR:
		if (flags)
			wil->monitor_flags = *flags;
		else
			wil->monitor_flags = 0;

		break;
	default:
		return -EOPNOTSUPP;
	}

	wdev->iftype = type;

	return 0;
}

static int wil_cfg80211_scan(struct wiphy *wiphy,
			     struct cfg80211_scan_request *request)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	struct wireless_dev *wdev = wil->wdev;
	struct {
		struct wmi_start_scan_cmd cmd;
		u16 chnl[4];
	} __packed cmd;
	uint i, n;

	if (wil->scan_request) {
		wil_err(wil, "Already scanning\n");
		return -EAGAIN;
	}

	/* check we are client side */
	switch (wdev->iftype) {
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_P2P_CLIENT:
		break;
	default:
		return -EOPNOTSUPP;
	}

	/* FW don't support scan after connection attempt */
	if (test_bit(wil_status_dontscan, &wil->status)) {
		wil_err(wil, "Scan after connect attempt not supported\n");
		return -EBUSY;
	}

	wil->scan_request = request;

	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd.num_channels = 0;
	n = min(request->n_channels, 4U);
	for (i = 0; i < n; i++) {
		int ch = request->channels[i]->hw_value;
		if (ch == 0) {
			wil_err(wil,
				"Scan requested for unknown frequency %dMhz\n",
				request->channels[i]->center_freq);
			continue;
		}
		/* 0-based channel indexes */
		cmd.cmd.channel_list[cmd.cmd.num_channels++].channel = ch - 1;
		wil_dbg_misc(wil, "Scan for ch %d  : %d MHz\n", ch,
			     request->channels[i]->center_freq);
	}

	return wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) +
			cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0]));
}

static int wil_cfg80211_connect(struct wiphy *wiphy,
				struct net_device *ndev,
				struct cfg80211_connect_params *sme)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	struct cfg80211_bss *bss;
	struct wmi_connect_cmd conn;
	const u8 *ssid_eid;
	const u8 *rsn_eid;
	int ch;
	int rc = 0;

	bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid,
			       sme->ssid, sme->ssid_len,
			       WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
	if (!bss) {
		wil_err(wil, "Unable to find BSS\n");
		return -ENOENT;
	}

	ssid_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
	if (!ssid_eid) {
		wil_err(wil, "No SSID\n");
		rc = -ENOENT;
		goto out;
	}

	rsn_eid = sme->ie ?
			cfg80211_find_ie(WLAN_EID_RSN, sme->ie, sme->ie_len) :
			NULL;
	if (rsn_eid) {
		if (sme->ie_len > WMI_MAX_IE_LEN) {
			rc = -ERANGE;
			wil_err(wil, "IE too large (%td bytes)\n",
				sme->ie_len);
			goto out;
		}
		/*
		 * For secure assoc, send:
		 * (1) WMI_DELETE_CIPHER_KEY_CMD
		 * (2) WMI_SET_APPIE_CMD
		 */
		rc = wmi_del_cipher_key(wil, 0, bss->bssid);
		if (rc) {
			wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD failed\n");
			goto out;
		}
		/* WMI_SET_APPIE_CMD */
		rc = wmi_set_ie(wil, WMI_FRAME_ASSOC_REQ, sme->ie_len, sme->ie);
		if (rc) {
			wil_err(wil, "WMI_SET_APPIE_CMD failed\n");
			goto out;
		}
	}

	/* WMI_CONNECT_CMD */
	memset(&conn, 0, sizeof(conn));
	switch (bss->capability & WLAN_CAPABILITY_DMG_TYPE_MASK) {
	case WLAN_CAPABILITY_DMG_TYPE_AP:
		conn.network_type = WMI_NETTYPE_INFRA;
		break;
	case WLAN_CAPABILITY_DMG_TYPE_PBSS:
		conn.network_type = WMI_NETTYPE_P2P;
		break;
	default:
		wil_err(wil, "Unsupported BSS type, capability= 0x%04x\n",
			bss->capability);
		goto out;
	}
	if (rsn_eid) {
		conn.dot11_auth_mode = WMI_AUTH11_SHARED;
		conn.auth_mode = WMI_AUTH_WPA2_PSK;
		conn.pairwise_crypto_type = WMI_CRYPT_AES_GCMP;
		conn.pairwise_crypto_len = 16;
	} else {
		conn.dot11_auth_mode = WMI_AUTH11_OPEN;
		conn.auth_mode = WMI_AUTH_NONE;
	}

	conn.ssid_len = min_t(u8, ssid_eid[1], 32);
	memcpy(conn.ssid, ssid_eid+2, conn.ssid_len);

	ch = bss->channel->hw_value;
	if (ch == 0) {
		wil_err(wil, "BSS at unknown frequency %dMhz\n",
			bss->channel->center_freq);
		rc = -EOPNOTSUPP;
		goto out;
	}
	conn.channel = ch - 1;

	memcpy(conn.bssid, bss->bssid, ETH_ALEN);
	memcpy(conn.dst_mac, bss->bssid, ETH_ALEN);
	/*
	 * FW don't support scan after connection attempt
	 */
	set_bit(wil_status_dontscan, &wil->status);
	set_bit(wil_status_fwconnecting, &wil->status);

	rc = wmi_send(wil, WMI_CONNECT_CMDID, &conn, sizeof(conn));
	if (rc == 0) {
		/* Connect can take lots of time */
		mod_timer(&wil->connect_timer,
			  jiffies + msecs_to_jiffies(2000));
	} else {
		clear_bit(wil_status_dontscan, &wil->status);
		clear_bit(wil_status_fwconnecting, &wil->status);
	}

 out:
	cfg80211_put_bss(wiphy, bss);

	return rc;
}

static int wil_cfg80211_disconnect(struct wiphy *wiphy,
				   struct net_device *ndev,
				   u16 reason_code)
{
	int rc;
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);

	rc = wmi_send(wil, WMI_DISCONNECT_CMDID, NULL, 0);

	return rc;
}

static int wil_cfg80211_mgmt_tx(struct wiphy *wiphy,
				struct wireless_dev *wdev,
				struct cfg80211_mgmt_tx_params *params,
				u64 *cookie)
{
	const u8 *buf = params->buf;
	size_t len = params->len;
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	int rc;
	struct ieee80211_mgmt *mgmt_frame = (void *)buf;
	struct wmi_sw_tx_req_cmd *cmd;
	struct {
		struct wil6210_mbox_hdr_wmi wmi;
		struct wmi_sw_tx_complete_event evt;
	} __packed evt;

	cmd = kmalloc(sizeof(*cmd) + len, GFP_KERNEL);
	if (!cmd)
		return -ENOMEM;

	memcpy(cmd->dst_mac, mgmt_frame->da, WMI_MAC_LEN);
	cmd->len = cpu_to_le16(len);
	memcpy(cmd->payload, buf, len);

	rc = wmi_call(wil, WMI_SW_TX_REQ_CMDID, cmd, sizeof(*cmd) + len,
		      WMI_SW_TX_COMPLETE_EVENTID, &evt, sizeof(evt), 2000);
	if (rc == 0)
		rc = evt.evt.status;

	kfree(cmd);

	return rc;
}

static int wil_cfg80211_set_channel(struct wiphy *wiphy,
				    struct cfg80211_chan_def *chandef)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	struct wireless_dev *wdev = wil->wdev;

	wdev->preset_chandef = *chandef;

	return 0;
}

static int wil_cfg80211_add_key(struct wiphy *wiphy,
				struct net_device *ndev,
				u8 key_index, bool pairwise,
				const u8 *mac_addr,
				struct key_params *params)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);

	/* group key is not used */
	if (!pairwise)
		return 0;

	return wmi_add_cipher_key(wil, key_index, mac_addr,
				  params->key_len, params->key);
}

static int wil_cfg80211_del_key(struct wiphy *wiphy,
				struct net_device *ndev,
				u8 key_index, bool pairwise,
				const u8 *mac_addr)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);

	/* group key is not used */
	if (!pairwise)
		return 0;

	return wmi_del_cipher_key(wil, key_index, mac_addr);
}

/* Need to be present or wiphy_new() will WARN */
static int wil_cfg80211_set_default_key(struct wiphy *wiphy,
					struct net_device *ndev,
					u8 key_index, bool unicast,
					bool multicast)
{
	return 0;
}

static int wil_remain_on_channel(struct wiphy *wiphy,
				 struct wireless_dev *wdev,
				 struct ieee80211_channel *chan,
				 unsigned int duration,
				 u64 *cookie)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	int rc;

	/* TODO: handle duration */
	wil_info(wil, "%s(%d, %d ms)\n", __func__, chan->center_freq, duration);

	rc = wmi_set_channel(wil, chan->hw_value);
	if (rc)
		return rc;

	rc = wmi_rxon(wil, true);

	return rc;
}

static int wil_cancel_remain_on_channel(struct wiphy *wiphy,
					struct wireless_dev *wdev,
					u64 cookie)
{
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	int rc;

	wil_info(wil, "%s()\n", __func__);

	rc = wmi_rxon(wil, false);

	return rc;
}

static int wil_fix_bcon(struct wil6210_priv *wil,
			struct cfg80211_beacon_data *bcon)
{
	struct ieee80211_mgmt *f = (struct ieee80211_mgmt *)bcon->probe_resp;
	size_t hlen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
	int rc = 0;

	if (bcon->probe_resp_len <= hlen)
		return 0;

	if (!bcon->proberesp_ies) {
		bcon->proberesp_ies = f->u.probe_resp.variable;
		bcon->proberesp_ies_len = bcon->probe_resp_len - hlen;
		rc = 1;
	}
	if (!bcon->assocresp_ies) {
		bcon->assocresp_ies = f->u.probe_resp.variable;
		bcon->assocresp_ies_len = bcon->probe_resp_len - hlen;
		rc = 1;
	}

	return rc;
}

static int wil_cfg80211_start_ap(struct wiphy *wiphy,
				 struct net_device *ndev,
				 struct cfg80211_ap_settings *info)
{
	int rc = 0;
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	struct wireless_dev *wdev = ndev->ieee80211_ptr;
	struct ieee80211_channel *channel = info->chandef.chan;
	struct cfg80211_beacon_data *bcon = &info->beacon;
	u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype);

	if (!channel) {
		wil_err(wil, "AP: No channel???\n");
		return -EINVAL;
	}

	wil_dbg_misc(wil, "AP on Channel %d %d MHz, %s\n", channel->hw_value,
		     channel->center_freq, info->privacy ? "secure" : "open");
	print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET,
			     info->ssid, info->ssid_len);

	if (wil_fix_bcon(wil, bcon))
		wil_dbg_misc(wil, "Fixed bcon\n");

	rc = wil_reset(wil);
	if (rc)
		return rc;

	/* Rx VRING. */
	rc = wil_rx_init(wil);
	if (rc)
		return rc;

	rc = wmi_set_ssid(wil, info->ssid_len, info->ssid);
	if (rc)
		return rc;

	/* MAC address - pre-requisite for other commands */
	wmi_set_mac_address(wil, ndev->dev_addr);

	/* IE's */
	/* bcon 'head IE's are not relevant for 60g band */
	/*
	 * FW do not form regular beacon, so bcon IE's are not set
	 * For the DMG bcon, when it will be supported, bcon IE's will
	 * be reused; add something like:
	 * wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len,
	 * bcon->beacon_ies);
	 */
	wmi_set_ie(wil, WMI_FRAME_PROBE_RESP, bcon->proberesp_ies_len,
		   bcon->proberesp_ies);
	wmi_set_ie(wil, WMI_FRAME_ASSOC_RESP, bcon->assocresp_ies_len,
		   bcon->assocresp_ies);

	wil->secure_pcp = info->privacy;

	rc = wmi_pcp_start(wil, info->beacon_interval, wmi_nettype,
			   channel->hw_value);
	if (rc)
		return rc;


	netif_carrier_on(ndev);

	return rc;
}

static int wil_cfg80211_stop_ap(struct wiphy *wiphy,
				struct net_device *ndev)
{
	int rc = 0;
	struct wil6210_priv *wil = wiphy_to_wil(wiphy);

	rc = wmi_pcp_stop(wil);

	return rc;
}

static struct cfg80211_ops wil_cfg80211_ops = {
	.scan = wil_cfg80211_scan,
	.connect = wil_cfg80211_connect,
	.disconnect = wil_cfg80211_disconnect,
	.change_virtual_intf = wil_cfg80211_change_iface,
	.get_station = wil_cfg80211_get_station,
	.remain_on_channel = wil_remain_on_channel,
	.cancel_remain_on_channel = wil_cancel_remain_on_channel,
	.mgmt_tx = wil_cfg80211_mgmt_tx,
	.set_monitor_channel = wil_cfg80211_set_channel,
	.add_key = wil_cfg80211_add_key,
	.del_key = wil_cfg80211_del_key,
	.set_default_key = wil_cfg80211_set_default_key,
	/* AP mode */
	.start_ap = wil_cfg80211_start_ap,
	.stop_ap = wil_cfg80211_stop_ap,
};

static void wil_wiphy_init(struct wiphy *wiphy)
{
	/* TODO: set real value */
	wiphy->max_scan_ssids = 10;
	wiphy->max_num_pmkids = 0 /* TODO: */;
	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
				 BIT(NL80211_IFTYPE_AP) |
				 BIT(NL80211_IFTYPE_MONITOR);
	/* TODO: enable P2P when integrated with supplicant:
	 * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO)
	 */
	wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
			WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
	dev_warn(wiphy_dev(wiphy), "%s : flags = 0x%08x\n",
		 __func__, wiphy->flags);
	wiphy->probe_resp_offload =
		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;

	wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz;

	/* TODO: figure this out */
	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;

	wiphy->cipher_suites = wil_cipher_suites;
	wiphy->n_cipher_suites = ARRAY_SIZE(wil_cipher_suites);
	wiphy->mgmt_stypes = wil_mgmt_stypes;
}

struct wireless_dev *wil_cfg80211_init(struct device *dev)
{
	int rc = 0;
	struct wireless_dev *wdev;

	wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
	if (!wdev)
		return ERR_PTR(-ENOMEM);

	wdev->wiphy = wiphy_new(&wil_cfg80211_ops,
				sizeof(struct wil6210_priv));
	if (!wdev->wiphy) {
		rc = -ENOMEM;
		goto out;
	}

	set_wiphy_dev(wdev->wiphy, dev);
	wil_wiphy_init(wdev->wiphy);

	rc = wiphy_register(wdev->wiphy);
	if (rc < 0)
		goto out_failed_reg;

	return wdev;

out_failed_reg:
	wiphy_free(wdev->wiphy);
out:
	kfree(wdev);

	return ERR_PTR(rc);
}

void wil_wdev_free(struct wil6210_priv *wil)
{
	struct wireless_dev *wdev = wil_to_wdev(wil);

	if (!wdev)
		return;

	wiphy_unregister(wdev->wiphy);
	wiphy_free(wdev->wiphy);
	kfree(wdev);
}
Commit	Line	Data
2be7d22f VK	1	/*
	2	* Copyright (c) 2012 Qualcomm Atheros, Inc.
	3	*
	4	* Permission to use, copy, modify, and/or distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16
2be7d22f VK	17	#include "wil6210.h"
	18	#include "wmi.h"
	19
	20	#define CHAN60G(_channel, _flags) { \
	21	.band = IEEE80211_BAND_60GHZ, \
	22	.center_freq = 56160 + (2160 * (_channel)), \
	23	.hw_value = (_channel), \
	24	.flags = (_flags), \
	25	.max_antenna_gain = 0, \
	26	.max_power = 40, \
	27	}
	28
	29	static struct ieee80211_channel wil_60ghz_channels[] = {
	30	CHAN60G(1, 0),
	31	CHAN60G(2, 0),
	32	CHAN60G(3, 0),
	33	/* channel 4 not supported yet */
	34	};
	35
	36	static struct ieee80211_supported_band wil_band_60ghz = {
	37	.channels = wil_60ghz_channels,
	38	.n_channels = ARRAY_SIZE(wil_60ghz_channels),
	39	.ht_cap = {
	40	.ht_supported = true,
	41	.cap = 0, /* TODO */
	42	.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, /* TODO */
	43	.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, /* TODO */
	44	.mcs = {
	45	/* MCS 1..12 - SC PHY */
	46	.rx_mask = {0xfe, 0x1f}, /* 1..12 */
	47	.tx_params = IEEE80211_HT_MCS_TX_DEFINED, /* TODO */
	48	},
	49	},
	50	};
	51
	52	static const struct ieee80211_txrx_stypes
	53	wil_mgmt_stypes[NUM_NL80211_IFTYPES] = {
	54	[NL80211_IFTYPE_STATION] = {
	55	.tx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	56	BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
	57	.rx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	58	BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	59	},
	60	[NL80211_IFTYPE_AP] = {
	61	.tx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	62	BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
	63	.rx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	64	BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	65	},
	66	[NL80211_IFTYPE_P2P_CLIENT] = {
	67	.tx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	68	BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
	69	.rx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	70	BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	71	},
	72	[NL80211_IFTYPE_P2P_GO] = {
	73	.tx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	74	BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
	75	.rx = BIT(IEEE80211_STYPE_ACTION >> 4) \|
	76	BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
	77	},
	78	};
	79
	80	static const u32 wil_cipher_suites[] = {
81	WLAN_CIPHER_SUITE_GCMP,
82	};
83
84	int wil_iftype_nl2wmi(enum nl80211_iftype type)
85	{
86	static const struct {
87	enum nl80211_iftype nl;
88	enum wmi_network_type wmi;
89	} __nl2wmi[] = {
90	{NL80211_IFTYPE_ADHOC, WMI_NETTYPE_ADHOC},
91	{NL80211_IFTYPE_STATION, WMI_NETTYPE_INFRA},
92	{NL80211_IFTYPE_AP, WMI_NETTYPE_AP},
93	{NL80211_IFTYPE_P2P_CLIENT, WMI_NETTYPE_P2P},
94	{NL80211_IFTYPE_P2P_GO, WMI_NETTYPE_P2P},
95	{NL80211_IFTYPE_MONITOR, WMI_NETTYPE_ADHOC}, /* FIXME */
96	};
97	uint i;
98
99	for (i = 0; i < ARRAY_SIZE(__nl2wmi); i++) {
100	if (__nl2wmi[i].nl == type)
101	return __nl2wmi[i].wmi;
102	}
103
104	return -EOPNOTSUPP;
105	}
106
107	static int wil_cfg80211_get_station(struct wiphy *wiphy,
108	struct net_device *ndev,
109	u8 mac, struct station_info sinfo)
110	{
111	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
112	int rc;
113	struct wmi_notify_req_cmd cmd = {
114	.cid = 0,
115	.interval_usec = 0,
116	};
117
118	if (memcmp(mac, wil->dst_addr[0], ETH_ALEN))
119	return -ENOENT;
120
121	/* WMI_NOTIFY_REQ_DONE_EVENTID handler fills wil->stats.bf_mcs */
122	rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd),
123	WMI_NOTIFY_REQ_DONE_EVENTID, NULL, 0, 20);
124	if (rc)
125	return rc;
126
127	sinfo->generation = wil->sinfo_gen;
128
129	sinfo->filled \|= STATION_INFO_TX_BITRATE;
130	sinfo->txrate.flags = RATE_INFO_FLAGS_MCS \| RATE_INFO_FLAGS_60G;
131	sinfo->txrate.mcs = wil->stats.bf_mcs;
132	sinfo->filled \|= STATION_INFO_RX_BITRATE;
133	sinfo->rxrate.flags = RATE_INFO_FLAGS_MCS \| RATE_INFO_FLAGS_60G;
134	sinfo->rxrate.mcs = wil->stats.last_mcs_rx;
135
136	if (test_bit(wil_status_fwconnected, &wil->status)) {
137	sinfo->filled \|= STATION_INFO_SIGNAL;
138	sinfo->signal = 12; /* TODO: provide real value */
139	}
140
141	return 0;
142	}
143
144	static int wil_cfg80211_change_iface(struct wiphy *wiphy,
145	struct net_device *ndev,
146	enum nl80211_iftype type, u32 *flags,
147	struct vif_params *params)
148	{
149	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
150	struct wireless_dev *wdev = wil->wdev;
151
152	switch (type) {
153	case NL80211_IFTYPE_STATION:
154	case NL80211_IFTYPE_AP:
155	case NL80211_IFTYPE_P2P_CLIENT:
156	case NL80211_IFTYPE_P2P_GO:
157	break;
158	case NL80211_IFTYPE_MONITOR:
159	if (flags)
160	wil->monitor_flags = *flags;
161	else
162	wil->monitor_flags = 0;
163
164	break;
165	default:
166	return -EOPNOTSUPP;
167	}
168
169	wdev->iftype = type;
170
171	return 0;
172	}
173
174	static int wil_cfg80211_scan(struct wiphy *wiphy,
175	struct cfg80211_scan_request *request)
176	{
177	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
178	struct wireless_dev *wdev = wil->wdev;
179	struct {
180	struct wmi_start_scan_cmd cmd;
181	u16 chnl[4];
182	} __packed cmd;
183	uint i, n;
184
185	if (wil->scan_request) {
186	wil_err(wil, "Already scanning\n");
187	return -EAGAIN;
188	}
189
190	/* check we are client side */
191	switch (wdev->iftype) {
192	case NL80211_IFTYPE_STATION:
193	case NL80211_IFTYPE_P2P_CLIENT:
194	break;
195	default:
196	return -EOPNOTSUPP;
2be7d22f VK	197	}
	198
	199	/* FW don't support scan after connection attempt */
	200	if (test_bit(wil_status_dontscan, &wil->status)) {
	201	wil_err(wil, "Scan after connect attempt not supported\n");
	202	return -EBUSY;
	203	}
	204
	205	wil->scan_request = request;
	206
	207	memset(&cmd, 0, sizeof(cmd));
	208	cmd.cmd.num_channels = 0;
	209	n = min(request->n_channels, 4U);
	210	for (i = 0; i < n; i++) {
	211	int ch = request->channels[i]->hw_value;
	212	if (ch == 0) {
	213	wil_err(wil,
	214	"Scan requested for unknown frequency %dMhz\n",
	215	request->channels[i]->center_freq);
	216	continue;
	217	}
	218	/* 0-based channel indexes */
	219	cmd.cmd.channel_list[cmd.cmd.num_channels++].channel = ch - 1;
7743882d	220	wil_dbg_misc(wil, "Scan for ch %d : %d MHz\n", ch,
2057ebb2	221	request->channels[i]->center_freq);
2be7d22f VK	222	}
	223
	224	return wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) +
	225	cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0]));
	226	}
	227
	228	static int wil_cfg80211_connect(struct wiphy *wiphy,
	229	struct net_device *ndev,
	230	struct cfg80211_connect_params *sme)
	231	{
	232	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	233	struct cfg80211_bss *bss;
	234	struct wmi_connect_cmd conn;
	235	const u8 *ssid_eid;
	236	const u8 *rsn_eid;
	237	int ch;
	238	int rc = 0;
	239
	240	bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid,
	241	sme->ssid, sme->ssid_len,
	242	WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
	243	if (!bss) {
	244	wil_err(wil, "Unable to find BSS\n");
	245	return -ENOENT;
	246	}
	247
	248	ssid_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
	249	if (!ssid_eid) {
	250	wil_err(wil, "No SSID\n");
	251	rc = -ENOENT;
	252	goto out;
	253	}
	254
	255	rsn_eid = sme->ie ?
	256	cfg80211_find_ie(WLAN_EID_RSN, sme->ie, sme->ie_len) :
	257	NULL;
	258	if (rsn_eid) {
	259	if (sme->ie_len > WMI_MAX_IE_LEN) {
	260	rc = -ERANGE;
	261	wil_err(wil, "IE too large (%td bytes)\n",
	262	sme->ie_len);
	263	goto out;
	264	}
	265	/*
	266	* For secure assoc, send:
	267	* (1) WMI_DELETE_CIPHER_KEY_CMD
	268	* (2) WMI_SET_APPIE_CMD
	269	*/
	270	rc = wmi_del_cipher_key(wil, 0, bss->bssid);
	271	if (rc) {
	272	wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD failed\n");
	273	goto out;
	274	}
	275	/* WMI_SET_APPIE_CMD */
	276	rc = wmi_set_ie(wil, WMI_FRAME_ASSOC_REQ, sme->ie_len, sme->ie);
	277	if (rc) {
	278	wil_err(wil, "WMI_SET_APPIE_CMD failed\n");
	279	goto out;
	280	}
	281	}
	282
	283	/* WMI_CONNECT_CMD */
	284	memset(&conn, 0, sizeof(conn));
acc9780d	285	switch (bss->capability & WLAN_CAPABILITY_DMG_TYPE_MASK) {
2be7d22f VK	286	case WLAN_CAPABILITY_DMG_TYPE_AP:
	287	conn.network_type = WMI_NETTYPE_INFRA;
	288	break;
	289	case WLAN_CAPABILITY_DMG_TYPE_PBSS:
	290	conn.network_type = WMI_NETTYPE_P2P;
	291	break;
	292	default:
	293	wil_err(wil, "Unsupported BSS type, capability= 0x%04x\n",
	294	bss->capability);
	295	goto out;
	296	}
	297	if (rsn_eid) {
	298	conn.dot11_auth_mode = WMI_AUTH11_SHARED;
	299	conn.auth_mode = WMI_AUTH_WPA2_PSK;
	300	conn.pairwise_crypto_type = WMI_CRYPT_AES_GCMP;
	301	conn.pairwise_crypto_len = 16;
	302	} else {
	303	conn.dot11_auth_mode = WMI_AUTH11_OPEN;
	304	conn.auth_mode = WMI_AUTH_NONE;
	305	}
	306
	307	conn.ssid_len = min_t(u8, ssid_eid[1], 32);
	308	memcpy(conn.ssid, ssid_eid+2, conn.ssid_len);
	309
	310	ch = bss->channel->hw_value;
	311	if (ch == 0) {
	312	wil_err(wil, "BSS at unknown frequency %dMhz\n",
	313	bss->channel->center_freq);
	314	rc = -EOPNOTSUPP;
	315	goto out;
	316	}
	317	conn.channel = ch - 1;
	318
d458cdf7 JP	319	memcpy(conn.bssid, bss->bssid, ETH_ALEN);
d458cdf7 JP	320	memcpy(conn.dst_mac, bss->bssid, ETH_ALEN);
2be7d22f VK	321	/*
	322	* FW don't support scan after connection attempt
	323	*/
	324	set_bit(wil_status_dontscan, &wil->status);
b338f74e	325	set_bit(wil_status_fwconnecting, &wil->status);
2be7d22f VK	326
	327	rc = wmi_send(wil, WMI_CONNECT_CMDID, &conn, sizeof(conn));
	328	if (rc == 0) {
	329	/* Connect can take lots of time */
	330	mod_timer(&wil->connect_timer,
	331	jiffies + msecs_to_jiffies(2000));
b338f74e VK	332	} else {
	333	clear_bit(wil_status_dontscan, &wil->status);
	334	clear_bit(wil_status_fwconnecting, &wil->status);
2be7d22f VK	335	}
	336
	337	out:
5b112d3d	338	cfg80211_put_bss(wiphy, bss);
2be7d22f VK	339
	340	return rc;
	341	}
	342
	343	static int wil_cfg80211_disconnect(struct wiphy *wiphy,
	344	struct net_device *ndev,
	345	u16 reason_code)
	346	{
	347	int rc;
	348	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	349
	350	rc = wmi_send(wil, WMI_DISCONNECT_CMDID, NULL, 0);
	351
	352	return rc;
	353	}
	354
1647f12f VK	355	static int wil_cfg80211_mgmt_tx(struct wiphy *wiphy,
	356	struct wireless_dev *wdev,
	357	struct cfg80211_mgmt_tx_params *params,
	358	u64 *cookie)
	359	{
	360	const u8 *buf = params->buf;
	361	size_t len = params->len;
	362	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	363	int rc;
	364	struct ieee80211_mgmt mgmt_frame = (void )buf;
	365	struct wmi_sw_tx_req_cmd *cmd;
	366	struct {
	367	struct wil6210_mbox_hdr_wmi wmi;
	368	struct wmi_sw_tx_complete_event evt;
	369	} __packed evt;
	370
	371	cmd = kmalloc(sizeof(*cmd) + len, GFP_KERNEL);
	372	if (!cmd)
	373	return -ENOMEM;
	374
	375	memcpy(cmd->dst_mac, mgmt_frame->da, WMI_MAC_LEN);
	376	cmd->len = cpu_to_le16(len);
	377	memcpy(cmd->payload, buf, len);
	378
	379	rc = wmi_call(wil, WMI_SW_TX_REQ_CMDID, cmd, sizeof(*cmd) + len,
	380	WMI_SW_TX_COMPLETE_EVENTID, &evt, sizeof(evt), 2000);
	381	if (rc == 0)
	382	rc = evt.evt.status;
	383
	384	kfree(cmd);
	385
	386	return rc;
	387	}
	388
2be7d22f VK	389	static int wil_cfg80211_set_channel(struct wiphy *wiphy,
	390	struct cfg80211_chan_def *chandef)
	391	{
	392	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	393	struct wireless_dev *wdev = wil->wdev;
	394
	395	wdev->preset_chandef = *chandef;
	396
	397	return 0;
	398	}
	399
	400	static int wil_cfg80211_add_key(struct wiphy *wiphy,
	401	struct net_device *ndev,
	402	u8 key_index, bool pairwise,
	403	const u8 *mac_addr,
	404	struct key_params *params)
	405	{
	406	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	407
	408	/* group key is not used */
	409	if (!pairwise)
	410	return 0;
	411
	412	return wmi_add_cipher_key(wil, key_index, mac_addr,
	413	params->key_len, params->key);
	414	}
	415
	416	static int wil_cfg80211_del_key(struct wiphy *wiphy,
	417	struct net_device *ndev,
	418	u8 key_index, bool pairwise,
	419	const u8 *mac_addr)
	420	{
	421	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	422
	423	/* group key is not used */
	424	if (!pairwise)
	425	return 0;
	426
	427	return wmi_del_cipher_key(wil, key_index, mac_addr);
	428	}
	429
	430	/* Need to be present or wiphy_new() will WARN */
	431	static int wil_cfg80211_set_default_key(struct wiphy *wiphy,
	432	struct net_device *ndev,
	433	u8 key_index, bool unicast,
	434	bool multicast)
	435	{
	436	return 0;
	437	}
	438
1647f12f VK	439	static int wil_remain_on_channel(struct wiphy *wiphy,
	440	struct wireless_dev *wdev,
	441	struct ieee80211_channel *chan,
	442	unsigned int duration,
	443	u64 *cookie)
	444	{
	445	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	446	int rc;
	447
	448	/* TODO: handle duration */
	449	wil_info(wil, "%s(%d, %d ms)\n", __func__, chan->center_freq, duration);
	450
	451	rc = wmi_set_channel(wil, chan->hw_value);
	452	if (rc)
	453	return rc;
	454
	455	rc = wmi_rxon(wil, true);
	456
	457	return rc;
	458	}
	459
	460	static int wil_cancel_remain_on_channel(struct wiphy *wiphy,
	461	struct wireless_dev *wdev,
	462	u64 cookie)
	463	{
	464	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	465	int rc;
	466
	467	wil_info(wil, "%s()\n", __func__);
	468
	469	rc = wmi_rxon(wil, false);
	470
	471	return rc;
	472	}
	473
92646c9f VK	474	static int wil_fix_bcon(struct wil6210_priv *wil,
	475	struct cfg80211_beacon_data *bcon)
	476	{
	477	struct ieee80211_mgmt f = (struct ieee80211_mgmt )bcon->probe_resp;
	478	size_t hlen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
	479	int rc = 0;
	480
	481	if (bcon->probe_resp_len <= hlen)
	482	return 0;
	483
	484	if (!bcon->proberesp_ies) {
	485	bcon->proberesp_ies = f->u.probe_resp.variable;
	486	bcon->proberesp_ies_len = bcon->probe_resp_len - hlen;
	487	rc = 1;
	488	}
	489	if (!bcon->assocresp_ies) {
	490	bcon->assocresp_ies = f->u.probe_resp.variable;
	491	bcon->assocresp_ies_len = bcon->probe_resp_len - hlen;
	492	rc = 1;
	493	}
	494
	495	return rc;
	496	}
	497
2be7d22f VK	498	static int wil_cfg80211_start_ap(struct wiphy *wiphy,
	499	struct net_device *ndev,
	500	struct cfg80211_ap_settings *info)
	501	{
	502	int rc = 0;
	503	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
	504	struct wireless_dev *wdev = ndev->ieee80211_ptr;
	505	struct ieee80211_channel *channel = info->chandef.chan;
	506	struct cfg80211_beacon_data *bcon = &info->beacon;
	507	u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype);
	508
	509	if (!channel) {
	510	wil_err(wil, "AP: No channel???\n");
	511	return -EINVAL;
	512	}
	513
7743882d	514	wil_dbg_misc(wil, "AP on Channel %d %d MHz, %s\n", channel->hw_value,
2057ebb2	515	channel->center_freq, info->privacy ? "secure" : "open");
2be7d22f VK	516	print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET,
	517	info->ssid, info->ssid_len);
	518
92646c9f VK	519	if (wil_fix_bcon(wil, bcon))
	520	wil_dbg_misc(wil, "Fixed bcon\n");
	521
2be7d22f VK	522	rc = wil_reset(wil);
	523	if (rc)
	524	return rc;
	525
e31b2562 VK	526	/* Rx VRING. */
	527	rc = wil_rx_init(wil);
	528	if (rc)
	529	return rc;
	530
2be7d22f VK	531	rc = wmi_set_ssid(wil, info->ssid_len, info->ssid);
	532	if (rc)
	533	return rc;
	534
2be7d22f VK	535	/* MAC address - pre-requisite for other commands */
	536	wmi_set_mac_address(wil, ndev->dev_addr);
	537
	538	/* IE's */
	539	/* bcon 'head IE's are not relevant for 60g band */
b1defa4d VK	540	/*
	541	* FW do not form regular beacon, so bcon IE's are not set
	542	* For the DMG bcon, when it will be supported, bcon IE's will
	543	* be reused; add something like:
	544	* wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len,
	545	* bcon->beacon_ies);
	546	*/
2be7d22f VK	547	wmi_set_ie(wil, WMI_FRAME_PROBE_RESP, bcon->proberesp_ies_len,
	548	bcon->proberesp_ies);
	549	wmi_set_ie(wil, WMI_FRAME_ASSOC_RESP, bcon->assocresp_ies_len,
	550	bcon->assocresp_ies);
	551
	552	wil->secure_pcp = info->privacy;
	553
b8023177 VK	554	rc = wmi_pcp_start(wil, info->beacon_interval, wmi_nettype,
b8023177 VK	555	channel->hw_value);
2be7d22f VK	556	if (rc)
	557	return rc;
	558
2be7d22f VK	559
	560	netif_carrier_on(ndev);
	561
	562	return rc;
	563	}
	564
	565	static int wil_cfg80211_stop_ap(struct wiphy *wiphy,
	566	struct net_device *ndev)
	567	{
	568	int rc = 0;
	569	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
2be7d22f	570
b8023177	571	rc = wmi_pcp_stop(wil);
2be7d22f VK	572
	573	return rc;
	574	}
	575
	576	static struct cfg80211_ops wil_cfg80211_ops = {
	577	.scan = wil_cfg80211_scan,
	578	.connect = wil_cfg80211_connect,
	579	.disconnect = wil_cfg80211_disconnect,
	580	.change_virtual_intf = wil_cfg80211_change_iface,
	581	.get_station = wil_cfg80211_get_station,
1647f12f VK	582	.remain_on_channel = wil_remain_on_channel,
	583	.cancel_remain_on_channel = wil_cancel_remain_on_channel,
	584	.mgmt_tx = wil_cfg80211_mgmt_tx,
2be7d22f VK	585	.set_monitor_channel = wil_cfg80211_set_channel,
	586	.add_key = wil_cfg80211_add_key,
	587	.del_key = wil_cfg80211_del_key,
	588	.set_default_key = wil_cfg80211_set_default_key,
	589	/* AP mode */
	590	.start_ap = wil_cfg80211_start_ap,
	591	.stop_ap = wil_cfg80211_stop_ap,
	592	};
	593
	594	static void wil_wiphy_init(struct wiphy *wiphy)
	595	{
	596	/* TODO: set real value */
	597	wiphy->max_scan_ssids = 10;
	598	wiphy->max_num_pmkids = 0 /* TODO: */;
	599	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) \|
	600	BIT(NL80211_IFTYPE_AP) \|
	601	BIT(NL80211_IFTYPE_MONITOR);
	602	/* TODO: enable P2P when integrated with supplicant:
	603	* BIT(NL80211_IFTYPE_P2P_CLIENT) \| BIT(NL80211_IFTYPE_P2P_GO)
	604	*/
	605	wiphy->flags \|= WIPHY_FLAG_HAVE_AP_SME \|
	606	WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
	607	dev_warn(wiphy_dev(wiphy), "%s : flags = 0x%08x\n",
	608	__func__, wiphy->flags);
	609	wiphy->probe_resp_offload =
	610	NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS \|
	611	NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 \|
	612	NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
	613
	614	wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz;
	615
	616	/* TODO: figure this out */
	617	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
	618
	619	wiphy->cipher_suites = wil_cipher_suites;
	620	wiphy->n_cipher_suites = ARRAY_SIZE(wil_cipher_suites);
	621	wiphy->mgmt_stypes = wil_mgmt_stypes;
	622	}
	623
	624	struct wireless_dev wil_cfg80211_init(struct device dev)
	625	{
	626	int rc = 0;
	627	struct wireless_dev *wdev;
	628
	629	wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
	630	if (!wdev)
	631	return ERR_PTR(-ENOMEM);
	632
	633	wdev->wiphy = wiphy_new(&wil_cfg80211_ops,
	634	sizeof(struct wil6210_priv));
	635	if (!wdev->wiphy) {
	636	rc = -ENOMEM;
	637	goto out;
	638	}
	639
	640	set_wiphy_dev(wdev->wiphy, dev);
	641	wil_wiphy_init(wdev->wiphy);
	642
	643	rc = wiphy_register(wdev->wiphy);
	644	if (rc < 0)
	645	goto out_failed_reg;
	646
	647	return wdev;
	648
649	out_failed_reg:
650	wiphy_free(wdev->wiphy);
651	out:
652	kfree(wdev);
653
654	return ERR_PTR(rc);
655	}
656
657	void wil_wdev_free(struct wil6210_priv *wil)
658	{
659	struct wireless_dev *wdev = wil_to_wdev(wil);
660
661	if (!wdev)
662	return;
663
664	wiphy_unregister(wdev->wiphy);
665	wiphy_free(wdev->wiphy);
666	kfree(wdev);
667	}