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 <linux/kernel.h> 18 #include <linux/netdevice.h> 19 #include <linux/sched.h> 20 #include <linux/etherdevice.h> 21 #include <linux/wireless.h> 22 #include <linux/ieee80211.h> 23 #include <linux/slab.h> 24 #include <linux/version.h> 25 #include <net/cfg80211.h> 26 27 #include "wil6210.h" 28 #include "wmi.h" 29 30 #define CHAN60G(_channel, _flags) { \ 31 .band = IEEE80211_BAND_60GHZ, \ 32 .center_freq = 56160 + (2160 * (_channel)), \ 33 .hw_value = (_channel), \ 34 .flags = (_flags), \ 35 .max_antenna_gain = 0, \ 36 .max_power = 40, \ 37 } 38 39 static struct ieee80211_channel wil_60ghz_channels[] = { 40 CHAN60G(1, 0), 41 CHAN60G(2, 0), 42 CHAN60G(3, 0), 43 /* channel 4 not supported yet */ 44 }; 45 46 static struct ieee80211_supported_band wil_band_60ghz = { 47 .channels = wil_60ghz_channels, 48 .n_channels = ARRAY_SIZE(wil_60ghz_channels), 49 .ht_cap = { 50 .ht_supported = true, 51 .cap = 0, /* TODO */ 52 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, /* TODO */ 53 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, /* TODO */ 54 .mcs = { 55 /* MCS 1..12 - SC PHY */ 56 .rx_mask = {0xfe, 0x1f}, /* 1..12 */ 57 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, /* TODO */ 58 }, 59 }, 60 }; 61 62 static const struct ieee80211_txrx_stypes 63 wil_mgmt_stypes[NUM_NL80211_IFTYPES] = { 64 [NL80211_IFTYPE_STATION] = { 65 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 66 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 67 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 68 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 69 }, 70 [NL80211_IFTYPE_AP] = { 71 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 72 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 73 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 74 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 75 }, 76 [NL80211_IFTYPE_P2P_CLIENT] = { 77 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 78 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 79 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 80 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 81 }, 82 [NL80211_IFTYPE_P2P_GO] = { 83 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 84 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 85 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 86 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 87 }, 88 }; 89 90 static const u32 wil_cipher_suites[] = { 91 WLAN_CIPHER_SUITE_GCMP, 92 }; 93 94 int wil_iftype_nl2wmi(enum nl80211_iftype type) 95 { 96 static const struct { 97 enum nl80211_iftype nl; 98 enum wmi_network_type wmi; 99 } __nl2wmi[] = { 100 {NL80211_IFTYPE_ADHOC, WMI_NETTYPE_ADHOC}, 101 {NL80211_IFTYPE_STATION, WMI_NETTYPE_INFRA}, 102 {NL80211_IFTYPE_AP, WMI_NETTYPE_AP}, 103 {NL80211_IFTYPE_P2P_CLIENT, WMI_NETTYPE_P2P}, 104 {NL80211_IFTYPE_P2P_GO, WMI_NETTYPE_P2P}, 105 {NL80211_IFTYPE_MONITOR, WMI_NETTYPE_ADHOC}, /* FIXME */ 106 }; 107 uint i; 108 109 for (i = 0; i < ARRAY_SIZE(__nl2wmi); i++) { 110 if (__nl2wmi[i].nl == type) 111 return __nl2wmi[i].wmi; 112 } 113 114 return -EOPNOTSUPP; 115 } 116 117 static int wil_cfg80211_get_station(struct wiphy *wiphy, 118 struct net_device *ndev, 119 u8 *mac, struct station_info *sinfo) 120 { 121 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 122 int rc; 123 struct wmi_notify_req_cmd cmd = { 124 .cid = 0, 125 .interval_usec = 0, 126 }; 127 128 if (memcmp(mac, wil->dst_addr[0], ETH_ALEN)) 129 return -ENOENT; 130 131 /* WMI_NOTIFY_REQ_DONE_EVENTID handler fills wil->stats.bf_mcs */ 132 rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd), 133 WMI_NOTIFY_REQ_DONE_EVENTID, NULL, 0, 20); 134 if (rc) 135 return rc; 136 137 sinfo->generation = wil->sinfo_gen; 138 139 sinfo->filled |= STATION_INFO_TX_BITRATE; 140 sinfo->txrate.flags = RATE_INFO_FLAGS_MCS | RATE_INFO_FLAGS_60G; 141 sinfo->txrate.mcs = wil->stats.bf_mcs; 142 sinfo->filled |= STATION_INFO_RX_BITRATE; 143 sinfo->rxrate.flags = RATE_INFO_FLAGS_MCS | RATE_INFO_FLAGS_60G; 144 sinfo->rxrate.mcs = wil->stats.last_mcs_rx; 145 146 if (test_bit(wil_status_fwconnected, &wil->status)) { 147 sinfo->filled |= STATION_INFO_SIGNAL; 148 sinfo->signal = 12; /* TODO: provide real value */ 149 } 150 151 return 0; 152 } 153 154 static int wil_cfg80211_change_iface(struct wiphy *wiphy, 155 struct net_device *ndev, 156 enum nl80211_iftype type, u32 *flags, 157 struct vif_params *params) 158 { 159 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 160 struct wireless_dev *wdev = wil->wdev; 161 162 switch (type) { 163 case NL80211_IFTYPE_STATION: 164 case NL80211_IFTYPE_AP: 165 case NL80211_IFTYPE_P2P_CLIENT: 166 case NL80211_IFTYPE_P2P_GO: 167 break; 168 case NL80211_IFTYPE_MONITOR: 169 if (flags) 170 wil->monitor_flags = *flags; 171 else 172 wil->monitor_flags = 0; 173 174 break; 175 default: 176 return -EOPNOTSUPP; 177 } 178 179 wdev->iftype = type; 180 181 return 0; 182 } 183 184 static int wil_cfg80211_scan(struct wiphy *wiphy, 185 struct cfg80211_scan_request *request) 186 { 187 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 188 struct wireless_dev *wdev = wil->wdev; 189 struct { 190 struct wmi_start_scan_cmd cmd; 191 u16 chnl[4]; 192 } __packed cmd; 193 uint i, n; 194 195 if (wil->scan_request) { 196 wil_err(wil, "Already scanning\n"); 197 return -EAGAIN; 198 } 199 200 /* check we are client side */ 201 switch (wdev->iftype) { 202 case NL80211_IFTYPE_STATION: 203 case NL80211_IFTYPE_P2P_CLIENT: 204 break; 205 default: 206 return -EOPNOTSUPP; 207 } 208 209 /* FW don't support scan after connection attempt */ 210 if (test_bit(wil_status_dontscan, &wil->status)) { 211 wil_err(wil, "Scan after connect attempt not supported\n"); 212 return -EBUSY; 213 } 214 215 wil->scan_request = request; 216 217 memset(&cmd, 0, sizeof(cmd)); 218 cmd.cmd.num_channels = 0; 219 n = min(request->n_channels, 4U); 220 for (i = 0; i < n; i++) { 221 int ch = request->channels[i]->hw_value; 222 if (ch == 0) { 223 wil_err(wil, 224 "Scan requested for unknown frequency %dMhz\n", 225 request->channels[i]->center_freq); 226 continue; 227 } 228 /* 0-based channel indexes */ 229 cmd.cmd.channel_list[cmd.cmd.num_channels++].channel = ch - 1; 230 wil_dbg_misc(wil, "Scan for ch %d : %d MHz\n", ch, 231 request->channels[i]->center_freq); 232 } 233 234 return wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) + 235 cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0])); 236 } 237 238 static int wil_cfg80211_connect(struct wiphy *wiphy, 239 struct net_device *ndev, 240 struct cfg80211_connect_params *sme) 241 { 242 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 243 struct cfg80211_bss *bss; 244 struct wmi_connect_cmd conn; 245 const u8 *ssid_eid; 246 const u8 *rsn_eid; 247 int ch; 248 int rc = 0; 249 250 bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid, 251 sme->ssid, sme->ssid_len, 252 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS); 253 if (!bss) { 254 wil_err(wil, "Unable to find BSS\n"); 255 return -ENOENT; 256 } 257 258 ssid_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SSID); 259 if (!ssid_eid) { 260 wil_err(wil, "No SSID\n"); 261 rc = -ENOENT; 262 goto out; 263 } 264 265 rsn_eid = sme->ie ? 266 cfg80211_find_ie(WLAN_EID_RSN, sme->ie, sme->ie_len) : 267 NULL; 268 if (rsn_eid) { 269 if (sme->ie_len > WMI_MAX_IE_LEN) { 270 rc = -ERANGE; 271 wil_err(wil, "IE too large (%td bytes)\n", 272 sme->ie_len); 273 goto out; 274 } 275 /* 276 * For secure assoc, send: 277 * (1) WMI_DELETE_CIPHER_KEY_CMD 278 * (2) WMI_SET_APPIE_CMD 279 */ 280 rc = wmi_del_cipher_key(wil, 0, bss->bssid); 281 if (rc) { 282 wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD failed\n"); 283 goto out; 284 } 285 /* WMI_SET_APPIE_CMD */ 286 rc = wmi_set_ie(wil, WMI_FRAME_ASSOC_REQ, sme->ie_len, sme->ie); 287 if (rc) { 288 wil_err(wil, "WMI_SET_APPIE_CMD failed\n"); 289 goto out; 290 } 291 } 292 293 /* WMI_CONNECT_CMD */ 294 memset(&conn, 0, sizeof(conn)); 295 switch (bss->capability & 0x03) { 296 case WLAN_CAPABILITY_DMG_TYPE_AP: 297 conn.network_type = WMI_NETTYPE_INFRA; 298 break; 299 case WLAN_CAPABILITY_DMG_TYPE_PBSS: 300 conn.network_type = WMI_NETTYPE_P2P; 301 break; 302 default: 303 wil_err(wil, "Unsupported BSS type, capability= 0x%04x\n", 304 bss->capability); 305 goto out; 306 } 307 if (rsn_eid) { 308 conn.dot11_auth_mode = WMI_AUTH11_SHARED; 309 conn.auth_mode = WMI_AUTH_WPA2_PSK; 310 conn.pairwise_crypto_type = WMI_CRYPT_AES_GCMP; 311 conn.pairwise_crypto_len = 16; 312 } else { 313 conn.dot11_auth_mode = WMI_AUTH11_OPEN; 314 conn.auth_mode = WMI_AUTH_NONE; 315 } 316 317 conn.ssid_len = min_t(u8, ssid_eid[1], 32); 318 memcpy(conn.ssid, ssid_eid+2, conn.ssid_len); 319 320 ch = bss->channel->hw_value; 321 if (ch == 0) { 322 wil_err(wil, "BSS at unknown frequency %dMhz\n", 323 bss->channel->center_freq); 324 rc = -EOPNOTSUPP; 325 goto out; 326 } 327 conn.channel = ch - 1; 328 329 memcpy(conn.bssid, bss->bssid, 6); 330 memcpy(conn.dst_mac, bss->bssid, 6); 331 /* 332 * FW don't support scan after connection attempt 333 */ 334 set_bit(wil_status_dontscan, &wil->status); 335 336 rc = wmi_send(wil, WMI_CONNECT_CMDID, &conn, sizeof(conn)); 337 if (rc == 0) { 338 /* Connect can take lots of time */ 339 mod_timer(&wil->connect_timer, 340 jiffies + msecs_to_jiffies(2000)); 341 } 342 343 out: 344 cfg80211_put_bss(wiphy, bss); 345 346 return rc; 347 } 348 349 static int wil_cfg80211_disconnect(struct wiphy *wiphy, 350 struct net_device *ndev, 351 u16 reason_code) 352 { 353 int rc; 354 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 355 356 rc = wmi_send(wil, WMI_DISCONNECT_CMDID, NULL, 0); 357 358 return rc; 359 } 360 361 static int wil_cfg80211_set_channel(struct wiphy *wiphy, 362 struct cfg80211_chan_def *chandef) 363 { 364 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 365 struct wireless_dev *wdev = wil->wdev; 366 367 wdev->preset_chandef = *chandef; 368 369 return 0; 370 } 371 372 static int wil_cfg80211_add_key(struct wiphy *wiphy, 373 struct net_device *ndev, 374 u8 key_index, bool pairwise, 375 const u8 *mac_addr, 376 struct key_params *params) 377 { 378 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 379 380 /* group key is not used */ 381 if (!pairwise) 382 return 0; 383 384 return wmi_add_cipher_key(wil, key_index, mac_addr, 385 params->key_len, params->key); 386 } 387 388 static int wil_cfg80211_del_key(struct wiphy *wiphy, 389 struct net_device *ndev, 390 u8 key_index, bool pairwise, 391 const u8 *mac_addr) 392 { 393 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 394 395 /* group key is not used */ 396 if (!pairwise) 397 return 0; 398 399 return wmi_del_cipher_key(wil, key_index, mac_addr); 400 } 401 402 /* Need to be present or wiphy_new() will WARN */ 403 static int wil_cfg80211_set_default_key(struct wiphy *wiphy, 404 struct net_device *ndev, 405 u8 key_index, bool unicast, 406 bool multicast) 407 { 408 return 0; 409 } 410 411 static int wil_cfg80211_start_ap(struct wiphy *wiphy, 412 struct net_device *ndev, 413 struct cfg80211_ap_settings *info) 414 { 415 int rc = 0; 416 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 417 struct wireless_dev *wdev = ndev->ieee80211_ptr; 418 struct ieee80211_channel *channel = info->chandef.chan; 419 struct cfg80211_beacon_data *bcon = &info->beacon; 420 u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype); 421 422 if (!channel) { 423 wil_err(wil, "AP: No channel???\n"); 424 return -EINVAL; 425 } 426 427 wil_dbg_misc(wil, "AP on Channel %d %d MHz, %s\n", channel->hw_value, 428 channel->center_freq, info->privacy ? "secure" : "open"); 429 print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET, 430 info->ssid, info->ssid_len); 431 432 rc = wil_reset(wil); 433 if (rc) 434 return rc; 435 436 rc = wmi_set_ssid(wil, info->ssid_len, info->ssid); 437 if (rc) 438 return rc; 439 440 rc = wmi_set_channel(wil, channel->hw_value); 441 if (rc) 442 return rc; 443 444 /* MAC address - pre-requisite for other commands */ 445 wmi_set_mac_address(wil, ndev->dev_addr); 446 447 /* IE's */ 448 /* bcon 'head IE's are not relevant for 60g band */ 449 wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len, 450 bcon->beacon_ies); 451 wmi_set_ie(wil, WMI_FRAME_PROBE_RESP, bcon->proberesp_ies_len, 452 bcon->proberesp_ies); 453 wmi_set_ie(wil, WMI_FRAME_ASSOC_RESP, bcon->assocresp_ies_len, 454 bcon->assocresp_ies); 455 456 wil->secure_pcp = info->privacy; 457 458 rc = wmi_set_bcon(wil, info->beacon_interval, wmi_nettype); 459 if (rc) 460 return rc; 461 462 /* Rx VRING. After MAC and beacon */ 463 rc = wil_rx_init(wil); 464 465 netif_carrier_on(ndev); 466 467 return rc; 468 } 469 470 static int wil_cfg80211_stop_ap(struct wiphy *wiphy, 471 struct net_device *ndev) 472 { 473 int rc = 0; 474 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 475 struct wireless_dev *wdev = ndev->ieee80211_ptr; 476 u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype); 477 478 /* To stop beaconing, set BI to 0 */ 479 rc = wmi_set_bcon(wil, 0, wmi_nettype); 480 481 return rc; 482 } 483 484 static struct cfg80211_ops wil_cfg80211_ops = { 485 .scan = wil_cfg80211_scan, 486 .connect = wil_cfg80211_connect, 487 .disconnect = wil_cfg80211_disconnect, 488 .change_virtual_intf = wil_cfg80211_change_iface, 489 .get_station = wil_cfg80211_get_station, 490 .set_monitor_channel = wil_cfg80211_set_channel, 491 .add_key = wil_cfg80211_add_key, 492 .del_key = wil_cfg80211_del_key, 493 .set_default_key = wil_cfg80211_set_default_key, 494 /* AP mode */ 495 .start_ap = wil_cfg80211_start_ap, 496 .stop_ap = wil_cfg80211_stop_ap, 497 }; 498 499 static void wil_wiphy_init(struct wiphy *wiphy) 500 { 501 /* TODO: set real value */ 502 wiphy->max_scan_ssids = 10; 503 wiphy->max_num_pmkids = 0 /* TODO: */; 504 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 505 BIT(NL80211_IFTYPE_AP) | 506 BIT(NL80211_IFTYPE_MONITOR); 507 /* TODO: enable P2P when integrated with supplicant: 508 * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO) 509 */ 510 wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME | 511 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 512 dev_warn(wiphy_dev(wiphy), "%s : flags = 0x%08x\n", 513 __func__, wiphy->flags); 514 wiphy->probe_resp_offload = 515 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 516 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 517 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 518 519 wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz; 520 521 /* TODO: figure this out */ 522 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 523 524 wiphy->cipher_suites = wil_cipher_suites; 525 wiphy->n_cipher_suites = ARRAY_SIZE(wil_cipher_suites); 526 wiphy->mgmt_stypes = wil_mgmt_stypes; 527 } 528 529 struct wireless_dev *wil_cfg80211_init(struct device *dev) 530 { 531 int rc = 0; 532 struct wireless_dev *wdev; 533 534 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL); 535 if (!wdev) 536 return ERR_PTR(-ENOMEM); 537 538 wdev->wiphy = wiphy_new(&wil_cfg80211_ops, 539 sizeof(struct wil6210_priv)); 540 if (!wdev->wiphy) { 541 rc = -ENOMEM; 542 goto out; 543 } 544 545 set_wiphy_dev(wdev->wiphy, dev); 546 wil_wiphy_init(wdev->wiphy); 547 548 rc = wiphy_register(wdev->wiphy); 549 if (rc < 0) 550 goto out_failed_reg; 551 552 return wdev; 553 554 out_failed_reg: 555 wiphy_free(wdev->wiphy); 556 out: 557 kfree(wdev); 558 559 return ERR_PTR(rc); 560 } 561 562 void wil_wdev_free(struct wil6210_priv *wil) 563 { 564 struct wireless_dev *wdev = wil_to_wdev(wil); 565 566 if (!wdev) 567 return; 568 569 wiphy_unregister(wdev->wiphy); 570 wiphy_free(wdev->wiphy); 571 kfree(wdev); 572 } 573