2 * Copyright (c) 2012-2015 Qualcomm Atheros, Inc.
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.
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.
17 #include <linux/etherdevice.h>
21 #define CHAN60G(_channel, _flags) { \
22 .band = IEEE80211_BAND_60GHZ, \
23 .center_freq = 56160 + (2160 * (_channel)), \
24 .hw_value = (_channel), \
26 .max_antenna_gain = 0, \
30 static struct ieee80211_channel wil_60ghz_channels
[] = {
34 /* channel 4 not supported yet */
37 static struct ieee80211_supported_band wil_band_60ghz
= {
38 .channels
= wil_60ghz_channels
,
39 .n_channels
= ARRAY_SIZE(wil_60ghz_channels
),
43 .ampdu_factor
= IEEE80211_HT_MAX_AMPDU_64K
, /* TODO */
44 .ampdu_density
= IEEE80211_HT_MPDU_DENSITY_8
, /* TODO */
46 /* MCS 1..12 - SC PHY */
47 .rx_mask
= {0xfe, 0x1f}, /* 1..12 */
48 .tx_params
= IEEE80211_HT_MCS_TX_DEFINED
, /* TODO */
53 static const struct ieee80211_txrx_stypes
54 wil_mgmt_stypes
[NUM_NL80211_IFTYPES
] = {
55 [NL80211_IFTYPE_STATION
] = {
56 .tx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
57 BIT(IEEE80211_STYPE_PROBE_RESP
>> 4),
58 .rx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
59 BIT(IEEE80211_STYPE_PROBE_REQ
>> 4)
61 [NL80211_IFTYPE_AP
] = {
62 .tx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
63 BIT(IEEE80211_STYPE_PROBE_RESP
>> 4),
64 .rx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
65 BIT(IEEE80211_STYPE_PROBE_REQ
>> 4)
67 [NL80211_IFTYPE_P2P_CLIENT
] = {
68 .tx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
69 BIT(IEEE80211_STYPE_PROBE_RESP
>> 4),
70 .rx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
71 BIT(IEEE80211_STYPE_PROBE_REQ
>> 4)
73 [NL80211_IFTYPE_P2P_GO
] = {
74 .tx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
75 BIT(IEEE80211_STYPE_PROBE_RESP
>> 4),
76 .rx
= BIT(IEEE80211_STYPE_ACTION
>> 4) |
77 BIT(IEEE80211_STYPE_PROBE_REQ
>> 4)
81 static const u32 wil_cipher_suites
[] = {
82 WLAN_CIPHER_SUITE_GCMP
,
85 int wil_iftype_nl2wmi(enum nl80211_iftype type
)
88 enum nl80211_iftype nl
;
89 enum wmi_network_type wmi
;
91 {NL80211_IFTYPE_ADHOC
, WMI_NETTYPE_ADHOC
},
92 {NL80211_IFTYPE_STATION
, WMI_NETTYPE_INFRA
},
93 {NL80211_IFTYPE_AP
, WMI_NETTYPE_AP
},
94 {NL80211_IFTYPE_P2P_CLIENT
, WMI_NETTYPE_P2P
},
95 {NL80211_IFTYPE_P2P_GO
, WMI_NETTYPE_P2P
},
96 {NL80211_IFTYPE_MONITOR
, WMI_NETTYPE_ADHOC
}, /* FIXME */
100 for (i
= 0; i
< ARRAY_SIZE(__nl2wmi
); i
++) {
101 if (__nl2wmi
[i
].nl
== type
)
102 return __nl2wmi
[i
].wmi
;
108 int wil_cid_fill_sinfo(struct wil6210_priv
*wil
, int cid
,
109 struct station_info
*sinfo
)
111 struct wmi_notify_req_cmd cmd
= {
116 struct wil6210_mbox_hdr_wmi wmi
;
117 struct wmi_notify_req_done_event evt
;
119 struct wil_net_stats
*stats
= &wil
->sta
[cid
].stats
;
122 rc
= wmi_call(wil
, WMI_NOTIFY_REQ_CMDID
, &cmd
, sizeof(cmd
),
123 WMI_NOTIFY_REQ_DONE_EVENTID
, &reply
, sizeof(reply
), 20);
127 wil_dbg_wmi(wil
, "Link status for CID %d: {\n"
128 " MCS %d TSF 0x%016llx\n"
129 " BF status 0x%08x SNR 0x%08x SQI %d%%\n"
130 " Tx Tpt %d goodput %d Rx goodput %d\n"
131 " Sectors(rx:tx) my %d:%d peer %d:%d\n""}\n",
132 cid
, le16_to_cpu(reply
.evt
.bf_mcs
),
133 le64_to_cpu(reply
.evt
.tsf
), reply
.evt
.status
,
134 le32_to_cpu(reply
.evt
.snr_val
),
136 le32_to_cpu(reply
.evt
.tx_tpt
),
137 le32_to_cpu(reply
.evt
.tx_goodput
),
138 le32_to_cpu(reply
.evt
.rx_goodput
),
139 le16_to_cpu(reply
.evt
.my_rx_sector
),
140 le16_to_cpu(reply
.evt
.my_tx_sector
),
141 le16_to_cpu(reply
.evt
.other_rx_sector
),
142 le16_to_cpu(reply
.evt
.other_tx_sector
));
144 sinfo
->generation
= wil
->sinfo_gen
;
146 sinfo
->filled
= BIT(NL80211_STA_INFO_RX_BYTES
) |
147 BIT(NL80211_STA_INFO_TX_BYTES
) |
148 BIT(NL80211_STA_INFO_RX_PACKETS
) |
149 BIT(NL80211_STA_INFO_TX_PACKETS
) |
150 BIT(NL80211_STA_INFO_RX_BITRATE
) |
151 BIT(NL80211_STA_INFO_TX_BITRATE
) |
152 BIT(NL80211_STA_INFO_RX_DROP_MISC
) |
153 BIT(NL80211_STA_INFO_TX_FAILED
);
155 sinfo
->txrate
.flags
= RATE_INFO_FLAGS_MCS
| RATE_INFO_FLAGS_60G
;
156 sinfo
->txrate
.mcs
= le16_to_cpu(reply
.evt
.bf_mcs
);
157 sinfo
->rxrate
.flags
= RATE_INFO_FLAGS_MCS
| RATE_INFO_FLAGS_60G
;
158 sinfo
->rxrate
.mcs
= stats
->last_mcs_rx
;
159 sinfo
->rx_bytes
= stats
->rx_bytes
;
160 sinfo
->rx_packets
= stats
->rx_packets
;
161 sinfo
->rx_dropped_misc
= stats
->rx_dropped
;
162 sinfo
->tx_bytes
= stats
->tx_bytes
;
163 sinfo
->tx_packets
= stats
->tx_packets
;
164 sinfo
->tx_failed
= stats
->tx_errors
;
166 if (test_bit(wil_status_fwconnected
, wil
->status
)) {
167 sinfo
->filled
|= BIT(NL80211_STA_INFO_SIGNAL
);
168 sinfo
->signal
= reply
.evt
.sqi
;
174 static int wil_cfg80211_get_station(struct wiphy
*wiphy
,
175 struct net_device
*ndev
,
176 const u8
*mac
, struct station_info
*sinfo
)
178 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
181 int cid
= wil_find_cid(wil
, mac
);
183 wil_dbg_misc(wil
, "%s(%pM) CID %d\n", __func__
, mac
, cid
);
187 rc
= wil_cid_fill_sinfo(wil
, cid
, sinfo
);
193 * Find @idx-th active STA for station dump.
195 static int wil_find_cid_by_idx(struct wil6210_priv
*wil
, int idx
)
199 for (i
= 0; i
< ARRAY_SIZE(wil
->sta
); i
++) {
200 if (wil
->sta
[i
].status
== wil_sta_unused
)
210 static int wil_cfg80211_dump_station(struct wiphy
*wiphy
,
211 struct net_device
*dev
, int idx
,
212 u8
*mac
, struct station_info
*sinfo
)
214 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
216 int cid
= wil_find_cid_by_idx(wil
, idx
);
221 ether_addr_copy(mac
, wil
->sta
[cid
].addr
);
222 wil_dbg_misc(wil
, "%s(%pM) CID %d\n", __func__
, mac
, cid
);
224 rc
= wil_cid_fill_sinfo(wil
, cid
, sinfo
);
229 static int wil_cfg80211_change_iface(struct wiphy
*wiphy
,
230 struct net_device
*ndev
,
231 enum nl80211_iftype type
, u32
*flags
,
232 struct vif_params
*params
)
234 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
235 struct wireless_dev
*wdev
= wil
->wdev
;
238 case NL80211_IFTYPE_STATION
:
239 case NL80211_IFTYPE_AP
:
240 case NL80211_IFTYPE_P2P_CLIENT
:
241 case NL80211_IFTYPE_P2P_GO
:
243 case NL80211_IFTYPE_MONITOR
:
245 wil
->monitor_flags
= *flags
;
247 wil
->monitor_flags
= 0;
259 static int wil_cfg80211_scan(struct wiphy
*wiphy
,
260 struct cfg80211_scan_request
*request
)
262 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
263 struct wireless_dev
*wdev
= wil
->wdev
;
265 struct wmi_start_scan_cmd cmd
;
271 if (wil
->scan_request
) {
272 wil_err(wil
, "Already scanning\n");
276 /* check we are client side */
277 switch (wdev
->iftype
) {
278 case NL80211_IFTYPE_STATION
:
279 case NL80211_IFTYPE_P2P_CLIENT
:
285 /* FW don't support scan after connection attempt */
286 if (test_bit(wil_status_dontscan
, wil
->status
)) {
287 wil_err(wil
, "Can't scan now\n");
291 wil_dbg_misc(wil
, "Start scan_request 0x%p\n", request
);
292 wil
->scan_request
= request
;
293 mod_timer(&wil
->scan_timer
, jiffies
+ WIL6210_SCAN_TO
);
295 memset(&cmd
, 0, sizeof(cmd
));
296 cmd
.cmd
.num_channels
= 0;
297 n
= min(request
->n_channels
, 4U);
298 for (i
= 0; i
< n
; i
++) {
299 int ch
= request
->channels
[i
]->hw_value
;
303 "Scan requested for unknown frequency %dMhz\n",
304 request
->channels
[i
]->center_freq
);
307 /* 0-based channel indexes */
308 cmd
.cmd
.channel_list
[cmd
.cmd
.num_channels
++].channel
= ch
- 1;
309 wil_dbg_misc(wil
, "Scan for ch %d : %d MHz\n", ch
,
310 request
->channels
[i
]->center_freq
);
314 print_hex_dump_bytes("Scan IE ", DUMP_PREFIX_OFFSET
,
315 request
->ie
, request
->ie_len
);
317 wil_dbg_misc(wil
, "Scan has no IE's\n");
319 rc
= wmi_set_ie(wil
, WMI_FRAME_PROBE_REQ
, request
->ie_len
,
322 wil_err(wil
, "Aborting scan, set_ie failed: %d\n", rc
);
326 rc
= wmi_send(wil
, WMI_START_SCAN_CMDID
, &cmd
, sizeof(cmd
.cmd
) +
327 cmd
.cmd
.num_channels
* sizeof(cmd
.cmd
.channel_list
[0]));
331 del_timer_sync(&wil
->scan_timer
);
332 wil
->scan_request
= NULL
;
338 static void wil_print_crypto(struct wil6210_priv
*wil
,
339 struct cfg80211_crypto_settings
*c
)
343 wil_dbg_misc(wil
, "WPA versions: 0x%08x cipher group 0x%08x\n",
344 c
->wpa_versions
, c
->cipher_group
);
345 wil_dbg_misc(wil
, "Pairwise ciphers [%d] {\n", c
->n_ciphers_pairwise
);
346 n
= min_t(int, c
->n_ciphers_pairwise
, ARRAY_SIZE(c
->ciphers_pairwise
));
347 for (i
= 0; i
< n
; i
++)
348 wil_dbg_misc(wil
, " [%d] = 0x%08x\n", i
,
349 c
->ciphers_pairwise
[i
]);
350 wil_dbg_misc(wil
, "}\n");
351 wil_dbg_misc(wil
, "AKM suites [%d] {\n", c
->n_akm_suites
);
352 n
= min_t(int, c
->n_akm_suites
, ARRAY_SIZE(c
->akm_suites
));
353 for (i
= 0; i
< n
; i
++)
354 wil_dbg_misc(wil
, " [%d] = 0x%08x\n", i
,
356 wil_dbg_misc(wil
, "}\n");
357 wil_dbg_misc(wil
, "Control port : %d, eth_type 0x%04x no_encrypt %d\n",
358 c
->control_port
, be16_to_cpu(c
->control_port_ethertype
),
359 c
->control_port_no_encrypt
);
362 static void wil_print_connect_params(struct wil6210_priv
*wil
,
363 struct cfg80211_connect_params
*sme
)
365 wil_info(wil
, "Connecting to:\n");
367 wil_info(wil
, " Channel: %d freq %d\n",
368 sme
->channel
->hw_value
, sme
->channel
->center_freq
);
371 wil_info(wil
, " BSSID: %pM\n", sme
->bssid
);
373 print_hex_dump(KERN_INFO
, " SSID: ", DUMP_PREFIX_OFFSET
,
374 16, 1, sme
->ssid
, sme
->ssid_len
, true);
375 wil_info(wil
, " Privacy: %s\n", sme
->privacy
? "secure" : "open");
376 wil_print_crypto(wil
, &sme
->crypto
);
379 static int wil_cfg80211_connect(struct wiphy
*wiphy
,
380 struct net_device
*ndev
,
381 struct cfg80211_connect_params
*sme
)
383 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
384 struct cfg80211_bss
*bss
;
385 struct wmi_connect_cmd conn
;
391 wil_print_connect_params(wil
, sme
);
393 if (test_bit(wil_status_fwconnecting
, wil
->status
) ||
394 test_bit(wil_status_fwconnected
, wil
->status
))
397 if (sme
->ie_len
> WMI_MAX_IE_LEN
) {
398 wil_err(wil
, "IE too large (%td bytes)\n", sme
->ie_len
);
403 cfg80211_find_ie(WLAN_EID_RSN
, sme
->ie
, sme
->ie_len
) :
406 if (sme
->privacy
&& !rsn_eid
) {
407 wil_err(wil
, "Missing RSN IE for secure connection\n");
411 bss
= cfg80211_get_bss(wiphy
, sme
->channel
, sme
->bssid
,
412 sme
->ssid
, sme
->ssid_len
,
413 IEEE80211_BSS_TYPE_ESS
, IEEE80211_PRIVACY_ANY
);
415 wil_err(wil
, "Unable to find BSS\n");
419 ssid_eid
= ieee80211_bss_get_ie(bss
, WLAN_EID_SSID
);
421 wil_err(wil
, "No SSID\n");
425 wil
->privacy
= sme
->privacy
;
428 /* For secure assoc, send WMI_DELETE_CIPHER_KEY_CMD */
429 rc
= wmi_del_cipher_key(wil
, 0, bss
->bssid
);
431 wil_err(wil
, "WMI_DELETE_CIPHER_KEY_CMD failed\n");
436 /* WMI_SET_APPIE_CMD. ie may contain rsn info as well as other info
437 * elements. Send it also in case it's empty, to erase previously set
440 rc
= wmi_set_ie(wil
, WMI_FRAME_ASSOC_REQ
, sme
->ie_len
, sme
->ie
);
442 wil_err(wil
, "WMI_SET_APPIE_CMD failed\n");
446 /* WMI_CONNECT_CMD */
447 memset(&conn
, 0, sizeof(conn
));
448 switch (bss
->capability
& WLAN_CAPABILITY_DMG_TYPE_MASK
) {
449 case WLAN_CAPABILITY_DMG_TYPE_AP
:
450 conn
.network_type
= WMI_NETTYPE_INFRA
;
452 case WLAN_CAPABILITY_DMG_TYPE_PBSS
:
453 conn
.network_type
= WMI_NETTYPE_P2P
;
456 wil_err(wil
, "Unsupported BSS type, capability= 0x%04x\n",
461 conn
.dot11_auth_mode
= WMI_AUTH11_SHARED
;
462 conn
.auth_mode
= WMI_AUTH_WPA2_PSK
;
463 conn
.pairwise_crypto_type
= WMI_CRYPT_AES_GCMP
;
464 conn
.pairwise_crypto_len
= 16;
466 conn
.dot11_auth_mode
= WMI_AUTH11_OPEN
;
467 conn
.auth_mode
= WMI_AUTH_NONE
;
470 conn
.ssid_len
= min_t(u8
, ssid_eid
[1], 32);
471 memcpy(conn
.ssid
, ssid_eid
+2, conn
.ssid_len
);
473 ch
= bss
->channel
->hw_value
;
475 wil_err(wil
, "BSS at unknown frequency %dMhz\n",
476 bss
->channel
->center_freq
);
480 conn
.channel
= ch
- 1;
482 ether_addr_copy(conn
.bssid
, bss
->bssid
);
483 ether_addr_copy(conn
.dst_mac
, bss
->bssid
);
485 set_bit(wil_status_fwconnecting
, wil
->status
);
487 rc
= wmi_send(wil
, WMI_CONNECT_CMDID
, &conn
, sizeof(conn
));
489 netif_carrier_on(ndev
);
490 /* Connect can take lots of time */
491 mod_timer(&wil
->connect_timer
,
492 jiffies
+ msecs_to_jiffies(2000));
494 clear_bit(wil_status_fwconnecting
, wil
->status
);
498 cfg80211_put_bss(wiphy
, bss
);
503 static int wil_cfg80211_disconnect(struct wiphy
*wiphy
,
504 struct net_device
*ndev
,
508 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
510 rc
= wmi_send(wil
, WMI_DISCONNECT_CMDID
, NULL
, 0);
515 int wil_cfg80211_mgmt_tx(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
516 struct cfg80211_mgmt_tx_params
*params
,
519 const u8
*buf
= params
->buf
;
520 size_t len
= params
->len
;
521 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
523 bool tx_status
= false;
524 struct ieee80211_mgmt
*mgmt_frame
= (void *)buf
;
525 struct wmi_sw_tx_req_cmd
*cmd
;
527 struct wil6210_mbox_hdr_wmi wmi
;
528 struct wmi_sw_tx_complete_event evt
;
531 cmd
= kmalloc(sizeof(*cmd
) + len
, GFP_KERNEL
);
537 memcpy(cmd
->dst_mac
, mgmt_frame
->da
, WMI_MAC_LEN
);
538 cmd
->len
= cpu_to_le16(len
);
539 memcpy(cmd
->payload
, buf
, len
);
541 rc
= wmi_call(wil
, WMI_SW_TX_REQ_CMDID
, cmd
, sizeof(*cmd
) + len
,
542 WMI_SW_TX_COMPLETE_EVENTID
, &evt
, sizeof(evt
), 2000);
544 tx_status
= !evt
.evt
.status
;
548 cfg80211_mgmt_tx_status(wdev
, cookie
? *cookie
: 0, buf
, len
,
549 tx_status
, GFP_KERNEL
);
553 static int wil_cfg80211_set_channel(struct wiphy
*wiphy
,
554 struct cfg80211_chan_def
*chandef
)
556 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
557 struct wireless_dev
*wdev
= wil
->wdev
;
559 wdev
->preset_chandef
= *chandef
;
564 static int wil_cfg80211_add_key(struct wiphy
*wiphy
,
565 struct net_device
*ndev
,
566 u8 key_index
, bool pairwise
,
568 struct key_params
*params
)
570 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
572 /* group key is not used */
576 return wmi_add_cipher_key(wil
, key_index
, mac_addr
,
577 params
->key_len
, params
->key
);
580 static int wil_cfg80211_del_key(struct wiphy
*wiphy
,
581 struct net_device
*ndev
,
582 u8 key_index
, bool pairwise
,
585 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
587 /* group key is not used */
591 return wmi_del_cipher_key(wil
, key_index
, mac_addr
);
594 /* Need to be present or wiphy_new() will WARN */
595 static int wil_cfg80211_set_default_key(struct wiphy
*wiphy
,
596 struct net_device
*ndev
,
597 u8 key_index
, bool unicast
,
603 static int wil_remain_on_channel(struct wiphy
*wiphy
,
604 struct wireless_dev
*wdev
,
605 struct ieee80211_channel
*chan
,
606 unsigned int duration
,
609 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
612 /* TODO: handle duration */
613 wil_info(wil
, "%s(%d, %d ms)\n", __func__
, chan
->center_freq
, duration
);
615 rc
= wmi_set_channel(wil
, chan
->hw_value
);
619 rc
= wmi_rxon(wil
, true);
624 static int wil_cancel_remain_on_channel(struct wiphy
*wiphy
,
625 struct wireless_dev
*wdev
,
628 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
631 wil_info(wil
, "%s()\n", __func__
);
633 rc
= wmi_rxon(wil
, false);
638 static void wil_print_bcon_data(struct cfg80211_beacon_data
*b
)
640 print_hex_dump_bytes("head ", DUMP_PREFIX_OFFSET
,
641 b
->head
, b
->head_len
);
642 print_hex_dump_bytes("tail ", DUMP_PREFIX_OFFSET
,
643 b
->tail
, b
->tail_len
);
644 print_hex_dump_bytes("BCON IE ", DUMP_PREFIX_OFFSET
,
645 b
->beacon_ies
, b
->beacon_ies_len
);
646 print_hex_dump_bytes("PROBE ", DUMP_PREFIX_OFFSET
,
647 b
->probe_resp
, b
->probe_resp_len
);
648 print_hex_dump_bytes("PROBE IE ", DUMP_PREFIX_OFFSET
,
649 b
->proberesp_ies
, b
->proberesp_ies_len
);
650 print_hex_dump_bytes("ASSOC IE ", DUMP_PREFIX_OFFSET
,
651 b
->assocresp_ies
, b
->assocresp_ies_len
);
654 static int wil_fix_bcon(struct wil6210_priv
*wil
,
655 struct cfg80211_beacon_data
*bcon
)
657 struct ieee80211_mgmt
*f
= (struct ieee80211_mgmt
*)bcon
->probe_resp
;
658 size_t hlen
= offsetof(struct ieee80211_mgmt
, u
.probe_resp
.variable
);
661 if (bcon
->probe_resp_len
<= hlen
)
664 if (!bcon
->proberesp_ies
) {
665 bcon
->proberesp_ies
= f
->u
.probe_resp
.variable
;
666 bcon
->proberesp_ies_len
= bcon
->probe_resp_len
- hlen
;
669 if (!bcon
->assocresp_ies
) {
670 bcon
->assocresp_ies
= f
->u
.probe_resp
.variable
;
671 bcon
->assocresp_ies_len
= bcon
->probe_resp_len
- hlen
;
678 static int wil_cfg80211_change_beacon(struct wiphy
*wiphy
,
679 struct net_device
*ndev
,
680 struct cfg80211_beacon_data
*bcon
)
682 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
685 wil_dbg_misc(wil
, "%s()\n", __func__
);
687 if (wil_fix_bcon(wil
, bcon
)) {
688 wil_dbg_misc(wil
, "Fixed bcon\n");
689 wil_print_bcon_data(bcon
);
692 /* FW do not form regular beacon, so bcon IE's are not set
693 * For the DMG bcon, when it will be supported, bcon IE's will
694 * be reused; add something like:
695 * wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len,
698 rc
= wmi_set_ie(wil
, WMI_FRAME_PROBE_RESP
,
699 bcon
->proberesp_ies_len
,
700 bcon
->proberesp_ies
);
702 wil_err(wil
, "set_ie(PROBE_RESP) failed\n");
706 rc
= wmi_set_ie(wil
, WMI_FRAME_ASSOC_RESP
,
707 bcon
->assocresp_ies_len
,
708 bcon
->assocresp_ies
);
710 wil_err(wil
, "set_ie(ASSOC_RESP) failed\n");
717 static int wil_cfg80211_start_ap(struct wiphy
*wiphy
,
718 struct net_device
*ndev
,
719 struct cfg80211_ap_settings
*info
)
722 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
723 struct wireless_dev
*wdev
= ndev
->ieee80211_ptr
;
724 struct ieee80211_channel
*channel
= info
->chandef
.chan
;
725 struct cfg80211_beacon_data
*bcon
= &info
->beacon
;
726 struct cfg80211_crypto_settings
*crypto
= &info
->crypto
;
727 u8 wmi_nettype
= wil_iftype_nl2wmi(wdev
->iftype
);
729 wil_dbg_misc(wil
, "%s()\n", __func__
);
732 wil_err(wil
, "AP: No channel???\n");
736 wil_dbg_misc(wil
, "AP on Channel %d %d MHz, %s\n", channel
->hw_value
,
737 channel
->center_freq
, info
->privacy
? "secure" : "open");
738 wil_dbg_misc(wil
, "Privacy: %d auth_type %d\n",
739 info
->privacy
, info
->auth_type
);
740 wil_dbg_misc(wil
, "BI %d DTIM %d\n", info
->beacon_interval
,
742 print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET
,
743 info
->ssid
, info
->ssid_len
);
744 wil_print_bcon_data(bcon
);
745 wil_print_crypto(wil
, crypto
);
747 if (wil_fix_bcon(wil
, bcon
)) {
748 wil_dbg_misc(wil
, "Fixed bcon\n");
749 wil_print_bcon_data(bcon
);
752 wil_set_recovery_state(wil
, fw_recovery_idle
);
754 mutex_lock(&wil
->mutex
);
761 rc
= wmi_set_ssid(wil
, info
->ssid_len
, info
->ssid
);
766 /* bcon 'head IE's are not relevant for 60g band */
768 * FW do not form regular beacon, so bcon IE's are not set
769 * For the DMG bcon, when it will be supported, bcon IE's will
770 * be reused; add something like:
771 * wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len,
774 wmi_set_ie(wil
, WMI_FRAME_PROBE_RESP
, bcon
->proberesp_ies_len
,
775 bcon
->proberesp_ies
);
776 wmi_set_ie(wil
, WMI_FRAME_ASSOC_RESP
, bcon
->assocresp_ies_len
,
777 bcon
->assocresp_ies
);
779 wil
->privacy
= info
->privacy
;
781 netif_carrier_on(ndev
);
783 rc
= wmi_pcp_start(wil
, info
->beacon_interval
, wmi_nettype
,
788 rc
= wil_bcast_init(wil
);
792 goto out
; /* success */
796 netif_carrier_off(ndev
);
798 mutex_unlock(&wil
->mutex
);
802 static int wil_cfg80211_stop_ap(struct wiphy
*wiphy
,
803 struct net_device
*ndev
)
805 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
807 wil_dbg_misc(wil
, "%s()\n", __func__
);
809 netif_carrier_off(ndev
);
810 wil_set_recovery_state(wil
, fw_recovery_idle
);
812 mutex_lock(&wil
->mutex
);
819 mutex_unlock(&wil
->mutex
);
821 /* some functions above might fail (e.g. __wil_up). Nevertheless, we
822 * return success because AP has stopped
827 static int wil_cfg80211_del_station(struct wiphy
*wiphy
,
828 struct net_device
*dev
,
829 struct station_del_parameters
*params
)
831 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
833 mutex_lock(&wil
->mutex
);
834 wil6210_disconnect(wil
, params
->mac
, params
->reason_code
, false);
835 mutex_unlock(&wil
->mutex
);
840 /* probe_client handling */
841 static void wil_probe_client_handle(struct wil6210_priv
*wil
,
842 struct wil_probe_client_req
*req
)
844 struct net_device
*ndev
= wil_to_ndev(wil
);
845 struct wil_sta_info
*sta
= &wil
->sta
[req
->cid
];
846 /* assume STA is alive if it is still connected,
847 * else FW will disconnect it
849 bool alive
= (sta
->status
== wil_sta_connected
);
851 cfg80211_probe_status(ndev
, sta
->addr
, req
->cookie
, alive
, GFP_KERNEL
);
854 static struct list_head
*next_probe_client(struct wil6210_priv
*wil
)
856 struct list_head
*ret
= NULL
;
858 mutex_lock(&wil
->probe_client_mutex
);
860 if (!list_empty(&wil
->probe_client_pending
)) {
861 ret
= wil
->probe_client_pending
.next
;
865 mutex_unlock(&wil
->probe_client_mutex
);
870 void wil_probe_client_worker(struct work_struct
*work
)
872 struct wil6210_priv
*wil
= container_of(work
, struct wil6210_priv
,
873 probe_client_worker
);
874 struct wil_probe_client_req
*req
;
875 struct list_head
*lh
;
877 while ((lh
= next_probe_client(wil
)) != NULL
) {
878 req
= list_entry(lh
, struct wil_probe_client_req
, list
);
880 wil_probe_client_handle(wil
, req
);
885 void wil_probe_client_flush(struct wil6210_priv
*wil
)
887 struct wil_probe_client_req
*req
, *t
;
889 wil_dbg_misc(wil
, "%s()\n", __func__
);
891 mutex_lock(&wil
->probe_client_mutex
);
893 list_for_each_entry_safe(req
, t
, &wil
->probe_client_pending
, list
) {
894 list_del(&req
->list
);
898 mutex_unlock(&wil
->probe_client_mutex
);
901 static int wil_cfg80211_probe_client(struct wiphy
*wiphy
,
902 struct net_device
*dev
,
903 const u8
*peer
, u64
*cookie
)
905 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
906 struct wil_probe_client_req
*req
;
907 int cid
= wil_find_cid(wil
, peer
);
909 wil_dbg_misc(wil
, "%s(%pM => CID %d)\n", __func__
, peer
, cid
);
914 req
= kzalloc(sizeof(*req
), GFP_KERNEL
);
921 mutex_lock(&wil
->probe_client_mutex
);
922 list_add_tail(&req
->list
, &wil
->probe_client_pending
);
923 mutex_unlock(&wil
->probe_client_mutex
);
925 *cookie
= req
->cookie
;
926 queue_work(wil
->wq_service
, &wil
->probe_client_worker
);
930 static int wil_cfg80211_change_bss(struct wiphy
*wiphy
,
931 struct net_device
*dev
,
932 struct bss_parameters
*params
)
934 struct wil6210_priv
*wil
= wiphy_to_wil(wiphy
);
936 if (params
->ap_isolate
>= 0) {
937 wil_dbg_misc(wil
, "%s(ap_isolate %d => %d)\n", __func__
,
938 wil
->ap_isolate
, params
->ap_isolate
);
939 wil
->ap_isolate
= params
->ap_isolate
;
945 static struct cfg80211_ops wil_cfg80211_ops
= {
946 .scan
= wil_cfg80211_scan
,
947 .connect
= wil_cfg80211_connect
,
948 .disconnect
= wil_cfg80211_disconnect
,
949 .change_virtual_intf
= wil_cfg80211_change_iface
,
950 .get_station
= wil_cfg80211_get_station
,
951 .dump_station
= wil_cfg80211_dump_station
,
952 .remain_on_channel
= wil_remain_on_channel
,
953 .cancel_remain_on_channel
= wil_cancel_remain_on_channel
,
954 .mgmt_tx
= wil_cfg80211_mgmt_tx
,
955 .set_monitor_channel
= wil_cfg80211_set_channel
,
956 .add_key
= wil_cfg80211_add_key
,
957 .del_key
= wil_cfg80211_del_key
,
958 .set_default_key
= wil_cfg80211_set_default_key
,
960 .change_beacon
= wil_cfg80211_change_beacon
,
961 .start_ap
= wil_cfg80211_start_ap
,
962 .stop_ap
= wil_cfg80211_stop_ap
,
963 .del_station
= wil_cfg80211_del_station
,
964 .probe_client
= wil_cfg80211_probe_client
,
965 .change_bss
= wil_cfg80211_change_bss
,
968 static void wil_wiphy_init(struct wiphy
*wiphy
)
970 /* TODO: set real value */
971 wiphy
->max_scan_ssids
= 10;
972 wiphy
->max_scan_ie_len
= WMI_MAX_IE_LEN
;
973 wiphy
->max_num_pmkids
= 0 /* TODO: */;
974 wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
975 BIT(NL80211_IFTYPE_AP
) |
976 BIT(NL80211_IFTYPE_MONITOR
);
977 /* TODO: enable P2P when integrated with supplicant:
978 * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO)
980 wiphy
->flags
|= WIPHY_FLAG_HAVE_AP_SME
|
981 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
;
982 dev_dbg(wiphy_dev(wiphy
), "%s : flags = 0x%08x\n",
983 __func__
, wiphy
->flags
);
984 wiphy
->probe_resp_offload
=
985 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS
|
986 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2
|
987 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P
;
989 wiphy
->bands
[IEEE80211_BAND_60GHZ
] = &wil_band_60ghz
;
991 /* TODO: figure this out */
992 wiphy
->signal_type
= CFG80211_SIGNAL_TYPE_UNSPEC
;
994 wiphy
->cipher_suites
= wil_cipher_suites
;
995 wiphy
->n_cipher_suites
= ARRAY_SIZE(wil_cipher_suites
);
996 wiphy
->mgmt_stypes
= wil_mgmt_stypes
;
997 wiphy
->features
|= NL80211_FEATURE_SK_TX_STATUS
;
1000 struct wireless_dev
*wil_cfg80211_init(struct device
*dev
)
1003 struct wireless_dev
*wdev
;
1005 dev_dbg(dev
, "%s()\n", __func__
);
1007 wdev
= kzalloc(sizeof(*wdev
), GFP_KERNEL
);
1009 return ERR_PTR(-ENOMEM
);
1011 wdev
->wiphy
= wiphy_new(&wil_cfg80211_ops
,
1012 sizeof(struct wil6210_priv
));
1018 set_wiphy_dev(wdev
->wiphy
, dev
);
1019 wil_wiphy_init(wdev
->wiphy
);
1021 rc
= wiphy_register(wdev
->wiphy
);
1023 goto out_failed_reg
;
1028 wiphy_free(wdev
->wiphy
);
1035 void wil_wdev_free(struct wil6210_priv
*wil
)
1037 struct wireless_dev
*wdev
= wil_to_wdev(wil
);
1039 dev_dbg(wil_to_dev(wil
), "%s()\n", __func__
);
1044 wiphy_unregister(wdev
->wiphy
);
1045 wiphy_free(wdev
->wiphy
);