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 
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_cid_fill_sinfo(struct wil6210_priv *wil, int cid,
108 			      struct station_info *sinfo)
109 {
110 	struct wmi_notify_req_cmd cmd = {
111 		.cid = cid,
112 		.interval_usec = 0,
113 	};
114 	struct {
115 		struct wil6210_mbox_hdr_wmi wmi;
116 		struct wmi_notify_req_done_event evt;
117 	} __packed reply;
118 	struct wil_net_stats *stats = &wil->sta[cid].stats;
119 	int rc;
120 
121 	rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd),
122 		      WMI_NOTIFY_REQ_DONE_EVENTID, &reply, sizeof(reply), 20);
123 	if (rc)
124 		return rc;
125 
126 	wil_dbg_wmi(wil, "Link status for CID %d: {\n"
127 		    "  MCS %d TSF 0x%016llx\n"
128 		    "  BF status 0x%08x SNR 0x%08x SQI %d%%\n"
129 		    "  Tx Tpt %d goodput %d Rx goodput %d\n"
130 		    "  Sectors(rx:tx) my %d:%d peer %d:%d\n""}\n",
131 		    cid, le16_to_cpu(reply.evt.bf_mcs),
132 		    le64_to_cpu(reply.evt.tsf), reply.evt.status,
133 		    le32_to_cpu(reply.evt.snr_val),
134 		    reply.evt.sqi,
135 		    le32_to_cpu(reply.evt.tx_tpt),
136 		    le32_to_cpu(reply.evt.tx_goodput),
137 		    le32_to_cpu(reply.evt.rx_goodput),
138 		    le16_to_cpu(reply.evt.my_rx_sector),
139 		    le16_to_cpu(reply.evt.my_tx_sector),
140 		    le16_to_cpu(reply.evt.other_rx_sector),
141 		    le16_to_cpu(reply.evt.other_tx_sector));
142 
143 	sinfo->generation = wil->sinfo_gen;
144 
145 	sinfo->filled = STATION_INFO_RX_BYTES |
146 			STATION_INFO_TX_BYTES |
147 			STATION_INFO_RX_PACKETS |
148 			STATION_INFO_TX_PACKETS |
149 			STATION_INFO_RX_BITRATE |
150 			STATION_INFO_TX_BITRATE |
151 			STATION_INFO_RX_DROP_MISC |
152 			STATION_INFO_TX_FAILED;
153 
154 	sinfo->txrate.flags = RATE_INFO_FLAGS_MCS | RATE_INFO_FLAGS_60G;
155 	sinfo->txrate.mcs = le16_to_cpu(reply.evt.bf_mcs);
156 	sinfo->rxrate.flags = RATE_INFO_FLAGS_MCS | RATE_INFO_FLAGS_60G;
157 	sinfo->rxrate.mcs = stats->last_mcs_rx;
158 	sinfo->rx_bytes = stats->rx_bytes;
159 	sinfo->rx_packets = stats->rx_packets;
160 	sinfo->rx_dropped_misc = stats->rx_dropped;
161 	sinfo->tx_bytes = stats->tx_bytes;
162 	sinfo->tx_packets = stats->tx_packets;
163 	sinfo->tx_failed = stats->tx_errors;
164 
165 	if (test_bit(wil_status_fwconnected, &wil->status)) {
166 		sinfo->filled |= STATION_INFO_SIGNAL;
167 		sinfo->signal = reply.evt.sqi;
168 	}
169 
170 	return rc;
171 }
172 
173 static int wil_cfg80211_get_station(struct wiphy *wiphy,
174 				    struct net_device *ndev,
175 				    u8 *mac, struct station_info *sinfo)
176 {
177 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
178 	int rc;
179 
180 	int cid = wil_find_cid(wil, mac);
181 
182 	wil_dbg_misc(wil, "%s(%pM) CID %d\n", __func__, mac, cid);
183 	if (cid < 0)
184 		return cid;
185 
186 	rc = wil_cid_fill_sinfo(wil, cid, sinfo);
187 
188 	return rc;
189 }
190 
191 /*
192  * Find @idx-th active STA for station dump.
193  */
194 static int wil_find_cid_by_idx(struct wil6210_priv *wil, int idx)
195 {
196 	int i;
197 
198 	for (i = 0; i < ARRAY_SIZE(wil->sta); i++) {
199 		if (wil->sta[i].status == wil_sta_unused)
200 			continue;
201 		if (idx == 0)
202 			return i;
203 		idx--;
204 	}
205 
206 	return -ENOENT;
207 }
208 
209 static int wil_cfg80211_dump_station(struct wiphy *wiphy,
210 				     struct net_device *dev, int idx,
211 				     u8 *mac, struct station_info *sinfo)
212 {
213 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
214 	int rc;
215 	int cid = wil_find_cid_by_idx(wil, idx);
216 
217 	if (cid < 0)
218 		return -ENOENT;
219 
220 	memcpy(mac, wil->sta[cid].addr, ETH_ALEN);
221 	wil_dbg_misc(wil, "%s(%pM) CID %d\n", __func__, mac, cid);
222 
223 	rc = wil_cid_fill_sinfo(wil, cid, sinfo);
224 
225 	return rc;
226 }
227 
228 static int wil_cfg80211_change_iface(struct wiphy *wiphy,
229 				     struct net_device *ndev,
230 				     enum nl80211_iftype type, u32 *flags,
231 				     struct vif_params *params)
232 {
233 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
234 	struct wireless_dev *wdev = wil->wdev;
235 
236 	switch (type) {
237 	case NL80211_IFTYPE_STATION:
238 	case NL80211_IFTYPE_AP:
239 	case NL80211_IFTYPE_P2P_CLIENT:
240 	case NL80211_IFTYPE_P2P_GO:
241 		break;
242 	case NL80211_IFTYPE_MONITOR:
243 		if (flags)
244 			wil->monitor_flags = *flags;
245 		else
246 			wil->monitor_flags = 0;
247 
248 		break;
249 	default:
250 		return -EOPNOTSUPP;
251 	}
252 
253 	wdev->iftype = type;
254 
255 	return 0;
256 }
257 
258 static int wil_cfg80211_scan(struct wiphy *wiphy,
259 			     struct cfg80211_scan_request *request)
260 {
261 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
262 	struct wireless_dev *wdev = wil->wdev;
263 	struct {
264 		struct wmi_start_scan_cmd cmd;
265 		u16 chnl[4];
266 	} __packed cmd;
267 	uint i, n;
268 	int rc;
269 
270 	if (wil->scan_request) {
271 		wil_err(wil, "Already scanning\n");
272 		return -EAGAIN;
273 	}
274 
275 	/* check we are client side */
276 	switch (wdev->iftype) {
277 	case NL80211_IFTYPE_STATION:
278 	case NL80211_IFTYPE_P2P_CLIENT:
279 		break;
280 	default:
281 		return -EOPNOTSUPP;
282 	}
283 
284 	/* FW don't support scan after connection attempt */
285 	if (test_bit(wil_status_dontscan, &wil->status)) {
286 		wil_err(wil, "Can't scan now\n");
287 		return -EBUSY;
288 	}
289 
290 	wil->scan_request = request;
291 
292 	memset(&cmd, 0, sizeof(cmd));
293 	cmd.cmd.num_channels = 0;
294 	n = min(request->n_channels, 4U);
295 	for (i = 0; i < n; i++) {
296 		int ch = request->channels[i]->hw_value;
297 		if (ch == 0) {
298 			wil_err(wil,
299 				"Scan requested for unknown frequency %dMhz\n",
300 				request->channels[i]->center_freq);
301 			continue;
302 		}
303 		/* 0-based channel indexes */
304 		cmd.cmd.channel_list[cmd.cmd.num_channels++].channel = ch - 1;
305 		wil_dbg_misc(wil, "Scan for ch %d  : %d MHz\n", ch,
306 			     request->channels[i]->center_freq);
307 	}
308 
309 	rc = wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) +
310 			cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0]));
311 
312 	if (rc)
313 		wil->scan_request = NULL;
314 
315 	return rc;
316 }
317 
318 static int wil_cfg80211_connect(struct wiphy *wiphy,
319 				struct net_device *ndev,
320 				struct cfg80211_connect_params *sme)
321 {
322 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
323 	struct cfg80211_bss *bss;
324 	struct wmi_connect_cmd conn;
325 	const u8 *ssid_eid;
326 	const u8 *rsn_eid;
327 	int ch;
328 	int rc = 0;
329 
330 	if (test_bit(wil_status_fwconnecting, &wil->status) ||
331 	    test_bit(wil_status_fwconnected, &wil->status))
332 		return -EALREADY;
333 
334 	bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid,
335 			       sme->ssid, sme->ssid_len,
336 			       WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
337 	if (!bss) {
338 		wil_err(wil, "Unable to find BSS\n");
339 		return -ENOENT;
340 	}
341 
342 	ssid_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
343 	if (!ssid_eid) {
344 		wil_err(wil, "No SSID\n");
345 		rc = -ENOENT;
346 		goto out;
347 	}
348 
349 	rsn_eid = sme->ie ?
350 			cfg80211_find_ie(WLAN_EID_RSN, sme->ie, sme->ie_len) :
351 			NULL;
352 	if (rsn_eid) {
353 		if (sme->ie_len > WMI_MAX_IE_LEN) {
354 			rc = -ERANGE;
355 			wil_err(wil, "IE too large (%td bytes)\n",
356 				sme->ie_len);
357 			goto out;
358 		}
359 		/*
360 		 * For secure assoc, send:
361 		 * (1) WMI_DELETE_CIPHER_KEY_CMD
362 		 * (2) WMI_SET_APPIE_CMD
363 		 */
364 		rc = wmi_del_cipher_key(wil, 0, bss->bssid);
365 		if (rc) {
366 			wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD failed\n");
367 			goto out;
368 		}
369 		/* WMI_SET_APPIE_CMD */
370 		rc = wmi_set_ie(wil, WMI_FRAME_ASSOC_REQ, sme->ie_len, sme->ie);
371 		if (rc) {
372 			wil_err(wil, "WMI_SET_APPIE_CMD failed\n");
373 			goto out;
374 		}
375 	}
376 
377 	/* WMI_CONNECT_CMD */
378 	memset(&conn, 0, sizeof(conn));
379 	switch (bss->capability & WLAN_CAPABILITY_DMG_TYPE_MASK) {
380 	case WLAN_CAPABILITY_DMG_TYPE_AP:
381 		conn.network_type = WMI_NETTYPE_INFRA;
382 		break;
383 	case WLAN_CAPABILITY_DMG_TYPE_PBSS:
384 		conn.network_type = WMI_NETTYPE_P2P;
385 		break;
386 	default:
387 		wil_err(wil, "Unsupported BSS type, capability= 0x%04x\n",
388 			bss->capability);
389 		goto out;
390 	}
391 	if (rsn_eid) {
392 		conn.dot11_auth_mode = WMI_AUTH11_SHARED;
393 		conn.auth_mode = WMI_AUTH_WPA2_PSK;
394 		conn.pairwise_crypto_type = WMI_CRYPT_AES_GCMP;
395 		conn.pairwise_crypto_len = 16;
396 	} else {
397 		conn.dot11_auth_mode = WMI_AUTH11_OPEN;
398 		conn.auth_mode = WMI_AUTH_NONE;
399 	}
400 
401 	conn.ssid_len = min_t(u8, ssid_eid[1], 32);
402 	memcpy(conn.ssid, ssid_eid+2, conn.ssid_len);
403 
404 	ch = bss->channel->hw_value;
405 	if (ch == 0) {
406 		wil_err(wil, "BSS at unknown frequency %dMhz\n",
407 			bss->channel->center_freq);
408 		rc = -EOPNOTSUPP;
409 		goto out;
410 	}
411 	conn.channel = ch - 1;
412 
413 	memcpy(conn.bssid, bss->bssid, ETH_ALEN);
414 	memcpy(conn.dst_mac, bss->bssid, ETH_ALEN);
415 
416 	set_bit(wil_status_fwconnecting, &wil->status);
417 
418 	rc = wmi_send(wil, WMI_CONNECT_CMDID, &conn, sizeof(conn));
419 	if (rc == 0) {
420 		/* Connect can take lots of time */
421 		mod_timer(&wil->connect_timer,
422 			  jiffies + msecs_to_jiffies(2000));
423 	} else {
424 		clear_bit(wil_status_fwconnecting, &wil->status);
425 	}
426 
427  out:
428 	cfg80211_put_bss(wiphy, bss);
429 
430 	return rc;
431 }
432 
433 static int wil_cfg80211_disconnect(struct wiphy *wiphy,
434 				   struct net_device *ndev,
435 				   u16 reason_code)
436 {
437 	int rc;
438 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
439 
440 	rc = wmi_send(wil, WMI_DISCONNECT_CMDID, NULL, 0);
441 
442 	return rc;
443 }
444 
445 static int wil_cfg80211_mgmt_tx(struct wiphy *wiphy,
446 				struct wireless_dev *wdev,
447 				struct cfg80211_mgmt_tx_params *params,
448 				u64 *cookie)
449 {
450 	const u8 *buf = params->buf;
451 	size_t len = params->len;
452 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
453 	int rc;
454 	struct ieee80211_mgmt *mgmt_frame = (void *)buf;
455 	struct wmi_sw_tx_req_cmd *cmd;
456 	struct {
457 		struct wil6210_mbox_hdr_wmi wmi;
458 		struct wmi_sw_tx_complete_event evt;
459 	} __packed evt;
460 
461 	cmd = kmalloc(sizeof(*cmd) + len, GFP_KERNEL);
462 	if (!cmd)
463 		return -ENOMEM;
464 
465 	memcpy(cmd->dst_mac, mgmt_frame->da, WMI_MAC_LEN);
466 	cmd->len = cpu_to_le16(len);
467 	memcpy(cmd->payload, buf, len);
468 
469 	rc = wmi_call(wil, WMI_SW_TX_REQ_CMDID, cmd, sizeof(*cmd) + len,
470 		      WMI_SW_TX_COMPLETE_EVENTID, &evt, sizeof(evt), 2000);
471 	if (rc == 0)
472 		rc = evt.evt.status;
473 
474 	kfree(cmd);
475 
476 	return rc;
477 }
478 
479 static int wil_cfg80211_set_channel(struct wiphy *wiphy,
480 				    struct cfg80211_chan_def *chandef)
481 {
482 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
483 	struct wireless_dev *wdev = wil->wdev;
484 
485 	wdev->preset_chandef = *chandef;
486 
487 	return 0;
488 }
489 
490 static int wil_cfg80211_add_key(struct wiphy *wiphy,
491 				struct net_device *ndev,
492 				u8 key_index, bool pairwise,
493 				const u8 *mac_addr,
494 				struct key_params *params)
495 {
496 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
497 
498 	/* group key is not used */
499 	if (!pairwise)
500 		return 0;
501 
502 	return wmi_add_cipher_key(wil, key_index, mac_addr,
503 				  params->key_len, params->key);
504 }
505 
506 static int wil_cfg80211_del_key(struct wiphy *wiphy,
507 				struct net_device *ndev,
508 				u8 key_index, bool pairwise,
509 				const u8 *mac_addr)
510 {
511 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
512 
513 	/* group key is not used */
514 	if (!pairwise)
515 		return 0;
516 
517 	return wmi_del_cipher_key(wil, key_index, mac_addr);
518 }
519 
520 /* Need to be present or wiphy_new() will WARN */
521 static int wil_cfg80211_set_default_key(struct wiphy *wiphy,
522 					struct net_device *ndev,
523 					u8 key_index, bool unicast,
524 					bool multicast)
525 {
526 	return 0;
527 }
528 
529 static int wil_remain_on_channel(struct wiphy *wiphy,
530 				 struct wireless_dev *wdev,
531 				 struct ieee80211_channel *chan,
532 				 unsigned int duration,
533 				 u64 *cookie)
534 {
535 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
536 	int rc;
537 
538 	/* TODO: handle duration */
539 	wil_info(wil, "%s(%d, %d ms)\n", __func__, chan->center_freq, duration);
540 
541 	rc = wmi_set_channel(wil, chan->hw_value);
542 	if (rc)
543 		return rc;
544 
545 	rc = wmi_rxon(wil, true);
546 
547 	return rc;
548 }
549 
550 static int wil_cancel_remain_on_channel(struct wiphy *wiphy,
551 					struct wireless_dev *wdev,
552 					u64 cookie)
553 {
554 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
555 	int rc;
556 
557 	wil_info(wil, "%s()\n", __func__);
558 
559 	rc = wmi_rxon(wil, false);
560 
561 	return rc;
562 }
563 
564 static int wil_fix_bcon(struct wil6210_priv *wil,
565 			struct cfg80211_beacon_data *bcon)
566 {
567 	struct ieee80211_mgmt *f = (struct ieee80211_mgmt *)bcon->probe_resp;
568 	size_t hlen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
569 	int rc = 0;
570 
571 	if (bcon->probe_resp_len <= hlen)
572 		return 0;
573 
574 	if (!bcon->proberesp_ies) {
575 		bcon->proberesp_ies = f->u.probe_resp.variable;
576 		bcon->proberesp_ies_len = bcon->probe_resp_len - hlen;
577 		rc = 1;
578 	}
579 	if (!bcon->assocresp_ies) {
580 		bcon->assocresp_ies = f->u.probe_resp.variable;
581 		bcon->assocresp_ies_len = bcon->probe_resp_len - hlen;
582 		rc = 1;
583 	}
584 
585 	return rc;
586 }
587 
588 static int wil_cfg80211_start_ap(struct wiphy *wiphy,
589 				 struct net_device *ndev,
590 				 struct cfg80211_ap_settings *info)
591 {
592 	int rc = 0;
593 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
594 	struct wireless_dev *wdev = ndev->ieee80211_ptr;
595 	struct ieee80211_channel *channel = info->chandef.chan;
596 	struct cfg80211_beacon_data *bcon = &info->beacon;
597 	u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype);
598 
599 	if (!channel) {
600 		wil_err(wil, "AP: No channel???\n");
601 		return -EINVAL;
602 	}
603 
604 	wil_dbg_misc(wil, "AP on Channel %d %d MHz, %s\n", channel->hw_value,
605 		     channel->center_freq, info->privacy ? "secure" : "open");
606 	print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET,
607 			     info->ssid, info->ssid_len);
608 
609 	if (wil_fix_bcon(wil, bcon))
610 		wil_dbg_misc(wil, "Fixed bcon\n");
611 
612 	mutex_lock(&wil->mutex);
613 
614 	rc = wil_reset(wil);
615 	if (rc)
616 		goto out;
617 
618 	/* Rx VRING. */
619 	rc = wil_rx_init(wil);
620 	if (rc)
621 		goto out;
622 
623 	rc = wmi_set_ssid(wil, info->ssid_len, info->ssid);
624 	if (rc)
625 		goto out;
626 
627 	/* MAC address - pre-requisite for other commands */
628 	wmi_set_mac_address(wil, ndev->dev_addr);
629 
630 	/* IE's */
631 	/* bcon 'head IE's are not relevant for 60g band */
632 	/*
633 	 * FW do not form regular beacon, so bcon IE's are not set
634 	 * For the DMG bcon, when it will be supported, bcon IE's will
635 	 * be reused; add something like:
636 	 * wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len,
637 	 * bcon->beacon_ies);
638 	 */
639 	wmi_set_ie(wil, WMI_FRAME_PROBE_RESP, bcon->proberesp_ies_len,
640 		   bcon->proberesp_ies);
641 	wmi_set_ie(wil, WMI_FRAME_ASSOC_RESP, bcon->assocresp_ies_len,
642 		   bcon->assocresp_ies);
643 
644 	wil->secure_pcp = info->privacy;
645 
646 	rc = wmi_pcp_start(wil, info->beacon_interval, wmi_nettype,
647 			   channel->hw_value);
648 	if (rc)
649 		goto out;
650 
651 
652 	netif_carrier_on(ndev);
653 
654 out:
655 	mutex_unlock(&wil->mutex);
656 	return rc;
657 }
658 
659 static int wil_cfg80211_stop_ap(struct wiphy *wiphy,
660 				struct net_device *ndev)
661 {
662 	int rc = 0;
663 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
664 
665 	mutex_lock(&wil->mutex);
666 
667 	rc = wmi_pcp_stop(wil);
668 
669 	mutex_unlock(&wil->mutex);
670 	return rc;
671 }
672 
673 static int wil_cfg80211_del_station(struct wiphy *wiphy,
674 				    struct net_device *dev, u8 *mac)
675 {
676 	struct wil6210_priv *wil = wiphy_to_wil(wiphy);
677 
678 	mutex_lock(&wil->mutex);
679 	wil6210_disconnect(wil, mac);
680 	mutex_unlock(&wil->mutex);
681 
682 	return 0;
683 }
684 
685 static struct cfg80211_ops wil_cfg80211_ops = {
686 	.scan = wil_cfg80211_scan,
687 	.connect = wil_cfg80211_connect,
688 	.disconnect = wil_cfg80211_disconnect,
689 	.change_virtual_intf = wil_cfg80211_change_iface,
690 	.get_station = wil_cfg80211_get_station,
691 	.dump_station = wil_cfg80211_dump_station,
692 	.remain_on_channel = wil_remain_on_channel,
693 	.cancel_remain_on_channel = wil_cancel_remain_on_channel,
694 	.mgmt_tx = wil_cfg80211_mgmt_tx,
695 	.set_monitor_channel = wil_cfg80211_set_channel,
696 	.add_key = wil_cfg80211_add_key,
697 	.del_key = wil_cfg80211_del_key,
698 	.set_default_key = wil_cfg80211_set_default_key,
699 	/* AP mode */
700 	.start_ap = wil_cfg80211_start_ap,
701 	.stop_ap = wil_cfg80211_stop_ap,
702 	.del_station = wil_cfg80211_del_station,
703 };
704 
705 static void wil_wiphy_init(struct wiphy *wiphy)
706 {
707 	/* TODO: set real value */
708 	wiphy->max_scan_ssids = 10;
709 	wiphy->max_num_pmkids = 0 /* TODO: */;
710 	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
711 				 BIT(NL80211_IFTYPE_AP) |
712 				 BIT(NL80211_IFTYPE_MONITOR);
713 	/* TODO: enable P2P when integrated with supplicant:
714 	 * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO)
715 	 */
716 	wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
717 			WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
718 	dev_warn(wiphy_dev(wiphy), "%s : flags = 0x%08x\n",
719 		 __func__, wiphy->flags);
720 	wiphy->probe_resp_offload =
721 		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
722 		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
723 		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
724 
725 	wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz;
726 
727 	/* TODO: figure this out */
728 	wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
729 
730 	wiphy->cipher_suites = wil_cipher_suites;
731 	wiphy->n_cipher_suites = ARRAY_SIZE(wil_cipher_suites);
732 	wiphy->mgmt_stypes = wil_mgmt_stypes;
733 }
734 
735 struct wireless_dev *wil_cfg80211_init(struct device *dev)
736 {
737 	int rc = 0;
738 	struct wireless_dev *wdev;
739 
740 	wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
741 	if (!wdev)
742 		return ERR_PTR(-ENOMEM);
743 
744 	wdev->wiphy = wiphy_new(&wil_cfg80211_ops,
745 				sizeof(struct wil6210_priv));
746 	if (!wdev->wiphy) {
747 		rc = -ENOMEM;
748 		goto out;
749 	}
750 
751 	set_wiphy_dev(wdev->wiphy, dev);
752 	wil_wiphy_init(wdev->wiphy);
753 
754 	rc = wiphy_register(wdev->wiphy);
755 	if (rc < 0)
756 		goto out_failed_reg;
757 
758 	return wdev;
759 
760 out_failed_reg:
761 	wiphy_free(wdev->wiphy);
762 out:
763 	kfree(wdev);
764 
765 	return ERR_PTR(rc);
766 }
767 
768 void wil_wdev_free(struct wil6210_priv *wil)
769 {
770 	struct wireless_dev *wdev = wil_to_wdev(wil);
771 
772 	if (!wdev)
773 		return;
774 
775 	wiphy_unregister(wdev->wiphy);
776 	wiphy_free(wdev->wiphy);
777 	kfree(wdev);
778 }
779