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 210 /* FW don't support scan after connection attempt */ 211 if (test_bit(wil_status_dontscan, &wil->status)) { 212 wil_err(wil, "Scan after connect attempt not supported\n"); 213 return -EBUSY; 214 } 215 216 wil->scan_request = request; 217 218 memset(&cmd, 0, sizeof(cmd)); 219 cmd.cmd.num_channels = 0; 220 n = min(request->n_channels, 4U); 221 for (i = 0; i < n; i++) { 222 int ch = request->channels[i]->hw_value; 223 if (ch == 0) { 224 wil_err(wil, 225 "Scan requested for unknown frequency %dMhz\n", 226 request->channels[i]->center_freq); 227 continue; 228 } 229 /* 0-based channel indexes */ 230 cmd.cmd.channel_list[cmd.cmd.num_channels++].channel = ch - 1; 231 wil_dbg(wil, "Scan for ch %d : %d MHz\n", ch, 232 request->channels[i]->center_freq); 233 } 234 235 return wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) + 236 cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0])); 237 } 238 239 static int wil_cfg80211_connect(struct wiphy *wiphy, 240 struct net_device *ndev, 241 struct cfg80211_connect_params *sme) 242 { 243 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 244 struct cfg80211_bss *bss; 245 struct wmi_connect_cmd conn; 246 const u8 *ssid_eid; 247 const u8 *rsn_eid; 248 int ch; 249 int rc = 0; 250 251 bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid, 252 sme->ssid, sme->ssid_len, 253 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS); 254 if (!bss) { 255 wil_err(wil, "Unable to find BSS\n"); 256 return -ENOENT; 257 } 258 259 ssid_eid = ieee80211_bss_get_ie(bss, WLAN_EID_SSID); 260 if (!ssid_eid) { 261 wil_err(wil, "No SSID\n"); 262 rc = -ENOENT; 263 goto out; 264 } 265 266 rsn_eid = sme->ie ? 267 cfg80211_find_ie(WLAN_EID_RSN, sme->ie, sme->ie_len) : 268 NULL; 269 if (rsn_eid) { 270 if (sme->ie_len > WMI_MAX_IE_LEN) { 271 rc = -ERANGE; 272 wil_err(wil, "IE too large (%td bytes)\n", 273 sme->ie_len); 274 goto out; 275 } 276 /* 277 * For secure assoc, send: 278 * (1) WMI_DELETE_CIPHER_KEY_CMD 279 * (2) WMI_SET_APPIE_CMD 280 */ 281 rc = wmi_del_cipher_key(wil, 0, bss->bssid); 282 if (rc) { 283 wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD failed\n"); 284 goto out; 285 } 286 /* WMI_SET_APPIE_CMD */ 287 rc = wmi_set_ie(wil, WMI_FRAME_ASSOC_REQ, sme->ie_len, sme->ie); 288 if (rc) { 289 wil_err(wil, "WMI_SET_APPIE_CMD failed\n"); 290 goto out; 291 } 292 } 293 294 /* WMI_CONNECT_CMD */ 295 memset(&conn, 0, sizeof(conn)); 296 switch (bss->capability & 0x03) { 297 case WLAN_CAPABILITY_DMG_TYPE_AP: 298 conn.network_type = WMI_NETTYPE_INFRA; 299 break; 300 case WLAN_CAPABILITY_DMG_TYPE_PBSS: 301 conn.network_type = WMI_NETTYPE_P2P; 302 break; 303 default: 304 wil_err(wil, "Unsupported BSS type, capability= 0x%04x\n", 305 bss->capability); 306 goto out; 307 } 308 if (rsn_eid) { 309 conn.dot11_auth_mode = WMI_AUTH11_SHARED; 310 conn.auth_mode = WMI_AUTH_WPA2_PSK; 311 conn.pairwise_crypto_type = WMI_CRYPT_AES_GCMP; 312 conn.pairwise_crypto_len = 16; 313 } else { 314 conn.dot11_auth_mode = WMI_AUTH11_OPEN; 315 conn.auth_mode = WMI_AUTH_NONE; 316 } 317 318 conn.ssid_len = min_t(u8, ssid_eid[1], 32); 319 memcpy(conn.ssid, ssid_eid+2, conn.ssid_len); 320 321 ch = bss->channel->hw_value; 322 if (ch == 0) { 323 wil_err(wil, "BSS at unknown frequency %dMhz\n", 324 bss->channel->center_freq); 325 rc = -EOPNOTSUPP; 326 goto out; 327 } 328 conn.channel = ch - 1; 329 330 memcpy(conn.bssid, bss->bssid, 6); 331 memcpy(conn.dst_mac, bss->bssid, 6); 332 /* 333 * FW don't support scan after connection attempt 334 */ 335 set_bit(wil_status_dontscan, &wil->status); 336 337 rc = wmi_send(wil, WMI_CONNECT_CMDID, &conn, sizeof(conn)); 338 if (rc == 0) { 339 /* Connect can take lots of time */ 340 mod_timer(&wil->connect_timer, 341 jiffies + msecs_to_jiffies(2000)); 342 } 343 344 out: 345 cfg80211_put_bss(bss); 346 347 return rc; 348 } 349 350 static int wil_cfg80211_disconnect(struct wiphy *wiphy, 351 struct net_device *ndev, 352 u16 reason_code) 353 { 354 int rc; 355 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 356 357 rc = wmi_send(wil, WMI_DISCONNECT_CMDID, NULL, 0); 358 359 return rc; 360 } 361 362 static int wil_cfg80211_set_channel(struct wiphy *wiphy, 363 struct cfg80211_chan_def *chandef) 364 { 365 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 366 struct wireless_dev *wdev = wil->wdev; 367 368 wdev->preset_chandef = *chandef; 369 370 return 0; 371 } 372 373 static int wil_cfg80211_add_key(struct wiphy *wiphy, 374 struct net_device *ndev, 375 u8 key_index, bool pairwise, 376 const u8 *mac_addr, 377 struct key_params *params) 378 { 379 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 380 381 /* group key is not used */ 382 if (!pairwise) 383 return 0; 384 385 return wmi_add_cipher_key(wil, key_index, mac_addr, 386 params->key_len, params->key); 387 } 388 389 static int wil_cfg80211_del_key(struct wiphy *wiphy, 390 struct net_device *ndev, 391 u8 key_index, bool pairwise, 392 const u8 *mac_addr) 393 { 394 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 395 396 /* group key is not used */ 397 if (!pairwise) 398 return 0; 399 400 return wmi_del_cipher_key(wil, key_index, mac_addr); 401 } 402 403 /* Need to be present or wiphy_new() will WARN */ 404 static int wil_cfg80211_set_default_key(struct wiphy *wiphy, 405 struct net_device *ndev, 406 u8 key_index, bool unicast, 407 bool multicast) 408 { 409 return 0; 410 } 411 412 static int wil_cfg80211_start_ap(struct wiphy *wiphy, 413 struct net_device *ndev, 414 struct cfg80211_ap_settings *info) 415 { 416 int rc = 0; 417 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 418 struct wireless_dev *wdev = ndev->ieee80211_ptr; 419 struct ieee80211_channel *channel = info->chandef.chan; 420 struct cfg80211_beacon_data *bcon = &info->beacon; 421 u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype); 422 423 if (!channel) { 424 wil_err(wil, "AP: No channel???\n"); 425 return -EINVAL; 426 } 427 428 wil_dbg(wil, "AP on Channel %d %d MHz, %s\n", channel->hw_value, 429 channel->center_freq, info->privacy ? "secure" : "open"); 430 print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET, 431 info->ssid, info->ssid_len); 432 433 rc = wil_reset(wil); 434 if (rc) 435 return rc; 436 437 rc = wmi_set_ssid(wil, info->ssid_len, info->ssid); 438 if (rc) 439 return rc; 440 441 rc = wmi_set_channel(wil, channel->hw_value); 442 if (rc) 443 return rc; 444 445 /* MAC address - pre-requisite for other commands */ 446 wmi_set_mac_address(wil, ndev->dev_addr); 447 448 /* IE's */ 449 /* bcon 'head IE's are not relevant for 60g band */ 450 wmi_set_ie(wil, WMI_FRAME_BEACON, bcon->beacon_ies_len, 451 bcon->beacon_ies); 452 wmi_set_ie(wil, WMI_FRAME_PROBE_RESP, bcon->proberesp_ies_len, 453 bcon->proberesp_ies); 454 wmi_set_ie(wil, WMI_FRAME_ASSOC_RESP, bcon->assocresp_ies_len, 455 bcon->assocresp_ies); 456 457 wil->secure_pcp = info->privacy; 458 459 rc = wmi_set_bcon(wil, info->beacon_interval, wmi_nettype); 460 if (rc) 461 return rc; 462 463 /* Rx VRING. After MAC and beacon */ 464 rc = wil_rx_init(wil); 465 466 netif_carrier_on(ndev); 467 468 return rc; 469 } 470 471 static int wil_cfg80211_stop_ap(struct wiphy *wiphy, 472 struct net_device *ndev) 473 { 474 int rc = 0; 475 struct wil6210_priv *wil = wiphy_to_wil(wiphy); 476 struct wireless_dev *wdev = ndev->ieee80211_ptr; 477 u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype); 478 479 /* To stop beaconing, set BI to 0 */ 480 rc = wmi_set_bcon(wil, 0, wmi_nettype); 481 482 return rc; 483 } 484 485 static struct cfg80211_ops wil_cfg80211_ops = { 486 .scan = wil_cfg80211_scan, 487 .connect = wil_cfg80211_connect, 488 .disconnect = wil_cfg80211_disconnect, 489 .change_virtual_intf = wil_cfg80211_change_iface, 490 .get_station = wil_cfg80211_get_station, 491 .set_monitor_channel = wil_cfg80211_set_channel, 492 .add_key = wil_cfg80211_add_key, 493 .del_key = wil_cfg80211_del_key, 494 .set_default_key = wil_cfg80211_set_default_key, 495 /* AP mode */ 496 .start_ap = wil_cfg80211_start_ap, 497 .stop_ap = wil_cfg80211_stop_ap, 498 }; 499 500 static void wil_wiphy_init(struct wiphy *wiphy) 501 { 502 /* TODO: set real value */ 503 wiphy->max_scan_ssids = 10; 504 wiphy->max_num_pmkids = 0 /* TODO: */; 505 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 506 BIT(NL80211_IFTYPE_AP) | 507 BIT(NL80211_IFTYPE_MONITOR); 508 /* TODO: enable P2P when integrated with supplicant: 509 * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO) 510 */ 511 wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME | 512 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 513 dev_warn(wiphy_dev(wiphy), "%s : flags = 0x%08x\n", 514 __func__, wiphy->flags); 515 wiphy->probe_resp_offload = 516 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 517 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 518 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 519 520 wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz; 521 522 /* TODO: figure this out */ 523 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 524 525 wiphy->cipher_suites = wil_cipher_suites; 526 wiphy->n_cipher_suites = ARRAY_SIZE(wil_cipher_suites); 527 wiphy->mgmt_stypes = wil_mgmt_stypes; 528 } 529 530 struct wireless_dev *wil_cfg80211_init(struct device *dev) 531 { 532 int rc = 0; 533 struct wireless_dev *wdev; 534 535 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL); 536 if (!wdev) 537 return ERR_PTR(-ENOMEM); 538 539 wdev->wiphy = wiphy_new(&wil_cfg80211_ops, 540 sizeof(struct wil6210_priv)); 541 if (!wdev->wiphy) { 542 rc = -ENOMEM; 543 goto out; 544 } 545 546 set_wiphy_dev(wdev->wiphy, dev); 547 wil_wiphy_init(wdev->wiphy); 548 549 rc = wiphy_register(wdev->wiphy); 550 if (rc < 0) 551 goto out_failed_reg; 552 553 return wdev; 554 555 out_failed_reg: 556 wiphy_free(wdev->wiphy); 557 out: 558 kfree(wdev); 559 560 return ERR_PTR(rc); 561 } 562 563 void wil_wdev_free(struct wil6210_priv *wil) 564 { 565 struct wireless_dev *wdev = wil_to_wdev(wil); 566 567 if (!wdev) 568 return; 569 570 wiphy_unregister(wdev->wiphy); 571 wiphy_free(wdev->wiphy); 572 kfree(wdev); 573 } 574