1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2016 Broadcom 4 */ 5 #include <linux/netdevice.h> 6 #include <linux/gcd.h> 7 #include <net/cfg80211.h> 8 9 #include "core.h" 10 #include "debug.h" 11 #include "fwil.h" 12 #include "fwil_types.h" 13 #include "cfg80211.h" 14 #include "pno.h" 15 16 #define BRCMF_PNO_VERSION 2 17 #define BRCMF_PNO_REPEAT 4 18 #define BRCMF_PNO_FREQ_EXPO_MAX 3 19 #define BRCMF_PNO_IMMEDIATE_SCAN_BIT 3 20 #define BRCMF_PNO_ENABLE_BD_SCAN_BIT 5 21 #define BRCMF_PNO_ENABLE_ADAPTSCAN_BIT 6 22 #define BRCMF_PNO_REPORT_SEPARATELY_BIT 11 23 #define BRCMF_PNO_SCAN_INCOMPLETE 0 24 #define BRCMF_PNO_WPA_AUTH_ANY 0xFFFFFFFF 25 #define BRCMF_PNO_HIDDEN_BIT 2 26 #define BRCMF_PNO_SCHED_SCAN_PERIOD 30 27 28 #define BRCMF_PNO_MAX_BUCKETS 16 29 #define GSCAN_BATCH_NO_THR_SET 101 30 #define GSCAN_RETRY_THRESHOLD 3 31 32 struct brcmf_pno_info { 33 int n_reqs; 34 struct cfg80211_sched_scan_request *reqs[BRCMF_PNO_MAX_BUCKETS]; 35 struct mutex req_lock; 36 }; 37 38 #define ifp_to_pno(_ifp) ((_ifp)->drvr->config->pno) 39 40 static int brcmf_pno_store_request(struct brcmf_pno_info *pi, 41 struct cfg80211_sched_scan_request *req) 42 { 43 if (WARN(pi->n_reqs == BRCMF_PNO_MAX_BUCKETS, 44 "pno request storage full\n")) 45 return -ENOSPC; 46 47 brcmf_dbg(SCAN, "reqid=%llu\n", req->reqid); 48 mutex_lock(&pi->req_lock); 49 pi->reqs[pi->n_reqs++] = req; 50 mutex_unlock(&pi->req_lock); 51 return 0; 52 } 53 54 static int brcmf_pno_remove_request(struct brcmf_pno_info *pi, u64 reqid) 55 { 56 int i, err = 0; 57 58 mutex_lock(&pi->req_lock); 59 60 /* Nothing to do if we have no requests */ 61 if (pi->n_reqs == 0) 62 goto done; 63 64 /* find request */ 65 for (i = 0; i < pi->n_reqs; i++) { 66 if (pi->reqs[i]->reqid == reqid) 67 break; 68 } 69 /* request not found */ 70 if (WARN(i == pi->n_reqs, "reqid not found\n")) { 71 err = -ENOENT; 72 goto done; 73 } 74 75 brcmf_dbg(SCAN, "reqid=%llu\n", reqid); 76 pi->n_reqs--; 77 78 /* if last we are done */ 79 if (!pi->n_reqs || i == pi->n_reqs) 80 goto done; 81 82 /* fill the gap with remaining requests */ 83 while (i <= pi->n_reqs - 1) { 84 pi->reqs[i] = pi->reqs[i + 1]; 85 i++; 86 } 87 88 done: 89 mutex_unlock(&pi->req_lock); 90 return err; 91 } 92 93 static int brcmf_pno_channel_config(struct brcmf_if *ifp, 94 struct brcmf_pno_config_le *cfg) 95 { 96 cfg->reporttype = 0; 97 cfg->flags = 0; 98 99 return brcmf_fil_iovar_data_set(ifp, "pfn_cfg", cfg, sizeof(*cfg)); 100 } 101 102 static int brcmf_pno_config(struct brcmf_if *ifp, u32 scan_freq, 103 u32 mscan, u32 bestn) 104 { 105 struct brcmf_pub *drvr = ifp->drvr; 106 struct brcmf_pno_param_le pfn_param; 107 u16 flags; 108 u32 pfnmem; 109 s32 err; 110 111 memset(&pfn_param, 0, sizeof(pfn_param)); 112 pfn_param.version = cpu_to_le32(BRCMF_PNO_VERSION); 113 114 /* set extra pno params */ 115 flags = BIT(BRCMF_PNO_IMMEDIATE_SCAN_BIT) | 116 BIT(BRCMF_PNO_ENABLE_ADAPTSCAN_BIT); 117 pfn_param.repeat = BRCMF_PNO_REPEAT; 118 pfn_param.exp = BRCMF_PNO_FREQ_EXPO_MAX; 119 120 /* set up pno scan fr */ 121 pfn_param.scan_freq = cpu_to_le32(scan_freq); 122 123 if (mscan) { 124 pfnmem = bestn; 125 126 /* set bestn in firmware */ 127 err = brcmf_fil_iovar_int_set(ifp, "pfnmem", pfnmem); 128 if (err < 0) { 129 bphy_err(drvr, "failed to set pfnmem\n"); 130 goto exit; 131 } 132 /* get max mscan which the firmware supports */ 133 err = brcmf_fil_iovar_int_get(ifp, "pfnmem", &pfnmem); 134 if (err < 0) { 135 bphy_err(drvr, "failed to get pfnmem\n"); 136 goto exit; 137 } 138 mscan = min_t(u32, mscan, pfnmem); 139 pfn_param.mscan = mscan; 140 pfn_param.bestn = bestn; 141 flags |= BIT(BRCMF_PNO_ENABLE_BD_SCAN_BIT); 142 brcmf_dbg(INFO, "mscan=%d, bestn=%d\n", mscan, bestn); 143 } 144 145 pfn_param.flags = cpu_to_le16(flags); 146 err = brcmf_fil_iovar_data_set(ifp, "pfn_set", &pfn_param, 147 sizeof(pfn_param)); 148 if (err) 149 bphy_err(drvr, "pfn_set failed, err=%d\n", err); 150 151 exit: 152 return err; 153 } 154 155 static int brcmf_pno_set_random(struct brcmf_if *ifp, struct brcmf_pno_info *pi) 156 { 157 struct brcmf_pub *drvr = ifp->drvr; 158 struct brcmf_pno_macaddr_le pfn_mac; 159 u8 *mac_addr = NULL; 160 u8 *mac_mask = NULL; 161 int err, i, ri; 162 163 for (ri = 0; ri < pi->n_reqs; ri++) 164 if (pi->reqs[ri]->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 165 mac_addr = pi->reqs[ri]->mac_addr; 166 mac_mask = pi->reqs[ri]->mac_addr_mask; 167 break; 168 } 169 170 /* no random mac requested */ 171 if (!mac_addr) 172 return 0; 173 174 pfn_mac.version = BRCMF_PFN_MACADDR_CFG_VER; 175 pfn_mac.flags = BRCMF_PFN_MAC_OUI_ONLY | BRCMF_PFN_SET_MAC_UNASSOC; 176 177 memcpy(pfn_mac.mac, mac_addr, ETH_ALEN); 178 for (i = 0; i < ETH_ALEN; i++) { 179 pfn_mac.mac[i] &= mac_mask[i]; 180 pfn_mac.mac[i] |= get_random_u8() & ~(mac_mask[i]); 181 } 182 /* Clear multi bit */ 183 pfn_mac.mac[0] &= 0xFE; 184 /* Set locally administered */ 185 pfn_mac.mac[0] |= 0x02; 186 187 brcmf_dbg(SCAN, "enabling random mac: reqid=%llu mac=%pM\n", 188 pi->reqs[ri]->reqid, pfn_mac.mac); 189 err = brcmf_fil_iovar_data_set(ifp, "pfn_macaddr", &pfn_mac, 190 sizeof(pfn_mac)); 191 if (err) 192 bphy_err(drvr, "pfn_macaddr failed, err=%d\n", err); 193 194 return err; 195 } 196 197 static int brcmf_pno_add_ssid(struct brcmf_if *ifp, struct cfg80211_ssid *ssid, 198 bool active) 199 { 200 struct brcmf_pub *drvr = ifp->drvr; 201 struct brcmf_pno_net_param_le pfn; 202 int err; 203 204 pfn.auth = cpu_to_le32(WLAN_AUTH_OPEN); 205 pfn.wpa_auth = cpu_to_le32(BRCMF_PNO_WPA_AUTH_ANY); 206 pfn.wsec = cpu_to_le32(0); 207 pfn.infra = cpu_to_le32(1); 208 pfn.flags = 0; 209 if (active) 210 pfn.flags = cpu_to_le32(1 << BRCMF_PNO_HIDDEN_BIT); 211 pfn.ssid.SSID_len = cpu_to_le32(ssid->ssid_len); 212 memcpy(pfn.ssid.SSID, ssid->ssid, ssid->ssid_len); 213 214 brcmf_dbg(SCAN, "adding ssid=%.32s (active=%d)\n", ssid->ssid, active); 215 err = brcmf_fil_iovar_data_set(ifp, "pfn_add", &pfn, sizeof(pfn)); 216 if (err < 0) 217 bphy_err(drvr, "adding failed: err=%d\n", err); 218 return err; 219 } 220 221 static int brcmf_pno_add_bssid(struct brcmf_if *ifp, const u8 *bssid) 222 { 223 struct brcmf_pub *drvr = ifp->drvr; 224 struct brcmf_pno_bssid_le bssid_cfg; 225 int err; 226 227 memcpy(bssid_cfg.bssid, bssid, ETH_ALEN); 228 bssid_cfg.flags = 0; 229 230 brcmf_dbg(SCAN, "adding bssid=%pM\n", bssid); 231 err = brcmf_fil_iovar_data_set(ifp, "pfn_add_bssid", &bssid_cfg, 232 sizeof(bssid_cfg)); 233 if (err < 0) 234 bphy_err(drvr, "adding failed: err=%d\n", err); 235 return err; 236 } 237 238 static bool brcmf_is_ssid_active(struct cfg80211_ssid *ssid, 239 struct cfg80211_sched_scan_request *req) 240 { 241 int i; 242 243 if (!ssid || !req->ssids || !req->n_ssids) 244 return false; 245 246 for (i = 0; i < req->n_ssids; i++) { 247 if (ssid->ssid_len == req->ssids[i].ssid_len) { 248 if (!strncmp(ssid->ssid, req->ssids[i].ssid, 249 ssid->ssid_len)) 250 return true; 251 } 252 } 253 return false; 254 } 255 256 static int brcmf_pno_clean(struct brcmf_if *ifp) 257 { 258 struct brcmf_pub *drvr = ifp->drvr; 259 int ret; 260 261 /* Disable pfn */ 262 ret = brcmf_fil_iovar_int_set(ifp, "pfn", 0); 263 if (ret == 0) { 264 /* clear pfn */ 265 ret = brcmf_fil_iovar_data_set(ifp, "pfnclear", NULL, 0); 266 } 267 if (ret < 0) 268 bphy_err(drvr, "failed code %d\n", ret); 269 270 return ret; 271 } 272 273 static int brcmf_pno_get_bucket_channels(struct cfg80211_sched_scan_request *r, 274 struct brcmf_pno_config_le *pno_cfg) 275 { 276 u32 n_chan = le32_to_cpu(pno_cfg->channel_num); 277 u16 chan; 278 int i, err = 0; 279 280 for (i = 0; i < r->n_channels; i++) { 281 if (n_chan >= BRCMF_NUMCHANNELS) { 282 err = -ENOSPC; 283 goto done; 284 } 285 chan = r->channels[i]->hw_value; 286 brcmf_dbg(SCAN, "[%d] Chan : %u\n", n_chan, chan); 287 pno_cfg->channel_list[n_chan++] = cpu_to_le16(chan); 288 } 289 /* return number of channels */ 290 err = n_chan; 291 done: 292 pno_cfg->channel_num = cpu_to_le32(n_chan); 293 return err; 294 } 295 296 static int brcmf_pno_prep_fwconfig(struct brcmf_pno_info *pi, 297 struct brcmf_pno_config_le *pno_cfg, 298 struct brcmf_gscan_bucket_config **buckets, 299 u32 *scan_freq) 300 { 301 struct cfg80211_sched_scan_request *sr; 302 struct brcmf_gscan_bucket_config *fw_buckets; 303 int i, err, chidx; 304 305 brcmf_dbg(SCAN, "n_reqs=%d\n", pi->n_reqs); 306 if (WARN_ON(!pi->n_reqs)) 307 return -ENODATA; 308 309 /* 310 * actual scan period is determined using gcd() for each 311 * scheduled scan period. 312 */ 313 *scan_freq = pi->reqs[0]->scan_plans[0].interval; 314 for (i = 1; i < pi->n_reqs; i++) { 315 sr = pi->reqs[i]; 316 *scan_freq = gcd(sr->scan_plans[0].interval, *scan_freq); 317 } 318 if (*scan_freq < BRCMF_PNO_SCHED_SCAN_MIN_PERIOD) { 319 brcmf_dbg(SCAN, "scan period too small, using minimum\n"); 320 *scan_freq = BRCMF_PNO_SCHED_SCAN_MIN_PERIOD; 321 } 322 323 *buckets = NULL; 324 fw_buckets = kcalloc(pi->n_reqs, sizeof(*fw_buckets), GFP_KERNEL); 325 if (!fw_buckets) 326 return -ENOMEM; 327 328 memset(pno_cfg, 0, sizeof(*pno_cfg)); 329 for (i = 0; i < pi->n_reqs; i++) { 330 sr = pi->reqs[i]; 331 chidx = brcmf_pno_get_bucket_channels(sr, pno_cfg); 332 if (chidx < 0) { 333 err = chidx; 334 goto fail; 335 } 336 fw_buckets[i].bucket_end_index = chidx - 1; 337 fw_buckets[i].bucket_freq_multiple = 338 sr->scan_plans[0].interval / *scan_freq; 339 /* assure period is non-zero */ 340 if (!fw_buckets[i].bucket_freq_multiple) 341 fw_buckets[i].bucket_freq_multiple = 1; 342 fw_buckets[i].flag = BRCMF_PNO_REPORT_NO_BATCH; 343 } 344 345 if (BRCMF_SCAN_ON()) { 346 brcmf_err("base period=%u\n", *scan_freq); 347 for (i = 0; i < pi->n_reqs; i++) { 348 brcmf_err("[%d] period %u max %u repeat %u flag %x idx %u\n", 349 i, fw_buckets[i].bucket_freq_multiple, 350 le16_to_cpu(fw_buckets[i].max_freq_multiple), 351 fw_buckets[i].repeat, fw_buckets[i].flag, 352 fw_buckets[i].bucket_end_index); 353 } 354 } 355 *buckets = fw_buckets; 356 return pi->n_reqs; 357 358 fail: 359 kfree(fw_buckets); 360 return err; 361 } 362 363 static int brcmf_pno_config_networks(struct brcmf_if *ifp, 364 struct brcmf_pno_info *pi) 365 { 366 struct cfg80211_sched_scan_request *r; 367 struct cfg80211_match_set *ms; 368 bool active; 369 int i, j, err = 0; 370 371 for (i = 0; i < pi->n_reqs; i++) { 372 r = pi->reqs[i]; 373 374 for (j = 0; j < r->n_match_sets; j++) { 375 ms = &r->match_sets[j]; 376 if (ms->ssid.ssid_len) { 377 active = brcmf_is_ssid_active(&ms->ssid, r); 378 err = brcmf_pno_add_ssid(ifp, &ms->ssid, 379 active); 380 } 381 if (!err && is_valid_ether_addr(ms->bssid)) 382 err = brcmf_pno_add_bssid(ifp, ms->bssid); 383 384 if (err < 0) 385 return err; 386 } 387 } 388 return 0; 389 } 390 391 static int brcmf_pno_config_sched_scans(struct brcmf_if *ifp) 392 { 393 struct brcmf_pub *drvr = ifp->drvr; 394 struct brcmf_pno_info *pi; 395 struct brcmf_gscan_config *gscan_cfg; 396 struct brcmf_gscan_bucket_config *buckets; 397 struct brcmf_pno_config_le pno_cfg; 398 size_t gsz; 399 u32 scan_freq; 400 int err, n_buckets; 401 402 pi = ifp_to_pno(ifp); 403 n_buckets = brcmf_pno_prep_fwconfig(pi, &pno_cfg, &buckets, 404 &scan_freq); 405 if (n_buckets < 0) 406 return n_buckets; 407 408 gsz = struct_size(gscan_cfg, bucket, n_buckets); 409 gscan_cfg = kzalloc(gsz, GFP_KERNEL); 410 if (!gscan_cfg) { 411 err = -ENOMEM; 412 goto free_buckets; 413 } 414 415 /* clean up everything */ 416 err = brcmf_pno_clean(ifp); 417 if (err < 0) { 418 bphy_err(drvr, "failed error=%d\n", err); 419 goto free_gscan; 420 } 421 422 /* configure pno */ 423 err = brcmf_pno_config(ifp, scan_freq, 0, 0); 424 if (err < 0) 425 goto free_gscan; 426 427 err = brcmf_pno_channel_config(ifp, &pno_cfg); 428 if (err < 0) 429 goto clean; 430 431 gscan_cfg->version = cpu_to_le16(BRCMF_GSCAN_CFG_VERSION); 432 gscan_cfg->retry_threshold = GSCAN_RETRY_THRESHOLD; 433 gscan_cfg->buffer_threshold = GSCAN_BATCH_NO_THR_SET; 434 gscan_cfg->flags = BRCMF_GSCAN_CFG_ALL_BUCKETS_IN_1ST_SCAN; 435 436 gscan_cfg->count_of_channel_buckets = n_buckets; 437 memcpy(gscan_cfg->bucket, buckets, 438 array_size(n_buckets, sizeof(*buckets))); 439 440 err = brcmf_fil_iovar_data_set(ifp, "pfn_gscan_cfg", gscan_cfg, gsz); 441 442 if (err < 0) 443 goto clean; 444 445 /* configure random mac */ 446 err = brcmf_pno_set_random(ifp, pi); 447 if (err < 0) 448 goto clean; 449 450 err = brcmf_pno_config_networks(ifp, pi); 451 if (err < 0) 452 goto clean; 453 454 /* Enable the PNO */ 455 err = brcmf_fil_iovar_int_set(ifp, "pfn", 1); 456 457 clean: 458 if (err < 0) 459 brcmf_pno_clean(ifp); 460 free_gscan: 461 kfree(gscan_cfg); 462 free_buckets: 463 kfree(buckets); 464 return err; 465 } 466 467 int brcmf_pno_start_sched_scan(struct brcmf_if *ifp, 468 struct cfg80211_sched_scan_request *req) 469 { 470 struct brcmf_pno_info *pi; 471 int ret; 472 473 brcmf_dbg(TRACE, "reqid=%llu\n", req->reqid); 474 475 pi = ifp_to_pno(ifp); 476 ret = brcmf_pno_store_request(pi, req); 477 if (ret < 0) 478 return ret; 479 480 ret = brcmf_pno_config_sched_scans(ifp); 481 if (ret < 0) { 482 brcmf_pno_remove_request(pi, req->reqid); 483 if (pi->n_reqs) 484 (void)brcmf_pno_config_sched_scans(ifp); 485 return ret; 486 } 487 return 0; 488 } 489 490 int brcmf_pno_stop_sched_scan(struct brcmf_if *ifp, u64 reqid) 491 { 492 struct brcmf_pno_info *pi; 493 int err; 494 495 brcmf_dbg(TRACE, "reqid=%llu\n", reqid); 496 497 pi = ifp_to_pno(ifp); 498 499 /* No PNO request */ 500 if (!pi->n_reqs) 501 return 0; 502 503 err = brcmf_pno_remove_request(pi, reqid); 504 if (err) 505 return err; 506 507 brcmf_pno_clean(ifp); 508 509 if (pi->n_reqs) 510 (void)brcmf_pno_config_sched_scans(ifp); 511 512 return 0; 513 } 514 515 int brcmf_pno_attach(struct brcmf_cfg80211_info *cfg) 516 { 517 struct brcmf_pno_info *pi; 518 519 brcmf_dbg(TRACE, "enter\n"); 520 pi = kzalloc(sizeof(*pi), GFP_KERNEL); 521 if (!pi) 522 return -ENOMEM; 523 524 cfg->pno = pi; 525 mutex_init(&pi->req_lock); 526 return 0; 527 } 528 529 void brcmf_pno_detach(struct brcmf_cfg80211_info *cfg) 530 { 531 struct brcmf_pno_info *pi; 532 533 brcmf_dbg(TRACE, "enter\n"); 534 pi = cfg->pno; 535 cfg->pno = NULL; 536 537 WARN_ON(pi->n_reqs); 538 mutex_destroy(&pi->req_lock); 539 kfree(pi); 540 } 541 542 void brcmf_pno_wiphy_params(struct wiphy *wiphy, bool gscan) 543 { 544 /* scheduled scan settings */ 545 wiphy->max_sched_scan_reqs = gscan ? BRCMF_PNO_MAX_BUCKETS : 1; 546 wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT; 547 wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT; 548 wiphy->max_sched_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX; 549 wiphy->max_sched_scan_plan_interval = BRCMF_PNO_SCHED_SCAN_MAX_PERIOD; 550 } 551 552 u64 brcmf_pno_find_reqid_by_bucket(struct brcmf_pno_info *pi, u32 bucket) 553 { 554 u64 reqid = 0; 555 556 mutex_lock(&pi->req_lock); 557 558 if (bucket < pi->n_reqs) 559 reqid = pi->reqs[bucket]->reqid; 560 561 mutex_unlock(&pi->req_lock); 562 return reqid; 563 } 564 565 u32 brcmf_pno_get_bucket_map(struct brcmf_pno_info *pi, 566 struct brcmf_pno_net_info_le *ni) 567 { 568 struct cfg80211_sched_scan_request *req; 569 struct cfg80211_match_set *ms; 570 u32 bucket_map = 0; 571 int i, j; 572 573 mutex_lock(&pi->req_lock); 574 for (i = 0; i < pi->n_reqs; i++) { 575 req = pi->reqs[i]; 576 577 if (!req->n_match_sets) 578 continue; 579 for (j = 0; j < req->n_match_sets; j++) { 580 ms = &req->match_sets[j]; 581 if (ms->ssid.ssid_len == ni->SSID_len && 582 !memcmp(ms->ssid.ssid, ni->SSID, ni->SSID_len)) { 583 bucket_map |= BIT(i); 584 break; 585 } 586 if (is_valid_ether_addr(ms->bssid) && 587 !memcmp(ms->bssid, ni->bssid, ETH_ALEN)) { 588 bucket_map |= BIT(i); 589 break; 590 } 591 } 592 } 593 mutex_unlock(&pi->req_lock); 594 return bucket_map; 595 } 596