drivers/net/wireless/ath/wil6210/main.c

   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/moduleparam.h>
  18 #include <linux/if_arp.h>
  19 #include <linux/etherdevice.h>
  20
  21 #include "wil6210.h"
  22 #include "txrx.h"
  23
  24 static bool no_fw_recovery;
  25 module_param(no_fw_recovery, bool, S_IRUGO | S_IWUSR);
  26 MODULE_PARM_DESC(no_fw_recovery, " disable FW error recovery");
  27
  28 /*
  29  * Due to a hardware issue,
  30  * one has to read/write to/from NIC in 32-bit chunks;
  31  * regular memcpy_fromio and siblings will
  32  * not work on 64-bit platform - it uses 64-bit transactions
  33  *
  34  * Force 32-bit transactions to enable NIC on 64-bit platforms
  35  *
  36  * To avoid byte swap on big endian host, __raw_{read|write}l
  37  * should be used - {read|write}l would swap bytes to provide
  38  * little endian on PCI value in host endianness.
  39  */
  40 void wil_memcpy_fromio_32(void *dst, const volatile void __iomem *src,
  41                           size_t count)
  42 {
  43         u32 *d = dst;
  44         const volatile u32 __iomem *s = src;
  45
  46         /* size_t is unsigned, if (count%4 != 0) it will wrap */
  47         for (count += 4; count > 4; count -= 4)
  48                 *d++ = __raw_readl(s++);
  49 }
  50
  51 void wil_memcpy_toio_32(volatile void __iomem *dst, const void *src,
  52                         size_t count)
  53 {
  54         volatile u32 __iomem *d = dst;
  55         const u32 *s = src;
  56
  57         for (count += 4; count > 4; count -= 4)
  58                 __raw_writel(*s++, d++);
  59 }
  60
  61 static void wil_disconnect_cid(struct wil6210_priv *wil, int cid)
  62 {
  63         uint i;
  64         struct net_device *ndev = wil_to_ndev(wil);
  65         struct wireless_dev *wdev = wil->wdev;
  66         struct wil_sta_info *sta = &wil->sta[cid];
  67         wil_dbg_misc(wil, "%s(CID %d, status %d)\n", __func__, cid,
  68                      sta->status);
  69
  70         sta->data_port_open = false;
  71         if (sta->status != wil_sta_unused) {
  72                 wmi_disconnect_sta(wil, sta->addr, WLAN_REASON_DEAUTH_LEAVING);
  73                 switch (wdev->iftype) {
  74                 case NL80211_IFTYPE_AP:
  75                 case NL80211_IFTYPE_P2P_GO:
  76                         /* AP-like interface */
  77                         cfg80211_del_sta(ndev, sta->addr, GFP_KERNEL);
  78                         break;
  79                 default:
  80                         break;
  81                 }
  82                 sta->status = wil_sta_unused;
  83         }
  84
  85         for (i = 0; i < WIL_STA_TID_NUM; i++) {
  86                 struct wil_tid_ampdu_rx *r = sta->tid_rx[i];
  87                 sta->tid_rx[i] = NULL;
  88                 wil_tid_ampdu_rx_free(wil, r);
  89         }
  90         for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) {
  91                 if (wil->vring2cid_tid[i][0] == cid)
  92                         wil_vring_fini_tx(wil, i);
  93         }
  94         memset(&sta->stats, 0, sizeof(sta->stats));
  95 }
  96
  97 static void _wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid)
  98 {
  99         int cid = -ENOENT;
 100         struct net_device *ndev = wil_to_ndev(wil);
 101         struct wireless_dev *wdev = wil->wdev;
 102
 103         might_sleep();
 104         if (bssid) {
 105                 cid = wil_find_cid(wil, bssid);
 106                 wil_dbg_misc(wil, "%s(%pM, CID %d)\n", __func__, bssid, cid);
 107         } else {
 108                 wil_dbg_misc(wil, "%s(all)\n", __func__);
 109         }
 110
 111         if (cid >= 0) /* disconnect 1 peer */
 112                 wil_disconnect_cid(wil, cid);
 113         else /* disconnect all */
 114                 for (cid = 0; cid < WIL6210_MAX_CID; cid++)
 115                         wil_disconnect_cid(wil, cid);
 116
 117         /* link state */
 118         switch (wdev->iftype) {
 119         case NL80211_IFTYPE_STATION:
 120         case NL80211_IFTYPE_P2P_CLIENT:
 121                 wil_link_off(wil);
 122                 if (test_bit(wil_status_fwconnected, &wil->status)) {
 123                         clear_bit(wil_status_fwconnected, &wil->status);
 124                         cfg80211_disconnected(ndev,
 125                                               WLAN_STATUS_UNSPECIFIED_FAILURE,
 126                                               NULL, 0, GFP_KERNEL);
 127                 } else if (test_bit(wil_status_fwconnecting, &wil->status)) {
 128                         cfg80211_connect_result(ndev, bssid, NULL, 0, NULL, 0,
 129                                                 WLAN_STATUS_UNSPECIFIED_FAILURE,
 130                                                 GFP_KERNEL);
 131                 }
 132                 clear_bit(wil_status_fwconnecting, &wil->status);
 133                 break;
 134         default:
 135                 break;
 136         }
 137 }
 138
 139 static void wil_disconnect_worker(struct work_struct *work)
 140 {
 141         struct wil6210_priv *wil = container_of(work,
 142                         struct wil6210_priv, disconnect_worker);
 143
 144         mutex_lock(&wil->mutex);
 145         _wil6210_disconnect(wil, NULL);
 146         mutex_unlock(&wil->mutex);
 147 }
 148
 149 static void wil_connect_timer_fn(ulong x)
 150 {
 151         struct wil6210_priv *wil = (void *)x;
 152
 153         wil_dbg_misc(wil, "Connect timeout\n");
 154
 155         /* reschedule to thread context - disconnect won't
 156          * run from atomic context
 157          */
 158         schedule_work(&wil->disconnect_worker);
 159 }
 160
 161 static void wil_scan_timer_fn(ulong x)
 162 {
 163         struct wil6210_priv *wil = (void *)x;
 164
 165         clear_bit(wil_status_fwready, &wil->status);
 166         wil_err(wil, "Scan timeout detected, start fw error recovery\n");
 167         schedule_work(&wil->fw_error_worker);
 168 }
 169
 170 static void wil_fw_error_worker(struct work_struct *work)
 171 {
 172         struct wil6210_priv *wil = container_of(work,
 173                         struct wil6210_priv, fw_error_worker);
 174         struct wireless_dev *wdev = wil->wdev;
 175
 176         wil_dbg_misc(wil, "fw error worker\n");
 177
 178         if (no_fw_recovery)
 179                 return;
 180
 181         /* increment @recovery_count if less then WIL6210_FW_RECOVERY_TO
 182          * passed since last recovery attempt
 183          */
 184         if (time_is_after_jiffies(wil->last_fw_recovery +
 185                                   WIL6210_FW_RECOVERY_TO))
 186                 wil->recovery_count++;
 187         else
 188                 wil->recovery_count = 1; /* fw was alive for a long time */
 189
 190         if (wil->recovery_count > WIL6210_FW_RECOVERY_RETRIES) {
 191                 wil_err(wil, "too many recovery attempts (%d), giving up\n",
 192                         wil->recovery_count);
 193                 return;
 194         }
 195
 196         wil->last_fw_recovery = jiffies;
 197
 198         mutex_lock(&wil->mutex);
 199         switch (wdev->iftype) {
 200         case NL80211_IFTYPE_STATION:
 201         case NL80211_IFTYPE_P2P_CLIENT:
 202         case NL80211_IFTYPE_MONITOR:
 203                 wil_info(wil, "fw error recovery started (try %d)...\n",
 204                          wil->recovery_count);
 205                 wil_reset(wil);
 206
 207                 /* need to re-allocate Rx ring after reset */
 208                 wil_rx_init(wil);
 209                 break;
 210         case NL80211_IFTYPE_AP:
 211         case NL80211_IFTYPE_P2P_GO:
 212                 /* recovery in these modes is done by upper layers */
 213                 break;
 214         default:
 215                 break;
 216         }
 217         mutex_unlock(&wil->mutex);
 218 }
 219
 220 static int wil_find_free_vring(struct wil6210_priv *wil)
 221 {
 222         int i;
 223         for (i = 0; i < WIL6210_MAX_TX_RINGS; i++) {
 224                 if (!wil->vring_tx[i].va)
 225                         return i;
 226         }
 227         return -EINVAL;
 228 }
 229
 230 static void wil_connect_worker(struct work_struct *work)
 231 {
 232         int rc;
 233         struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
 234                                                 connect_worker);
 235         int cid = wil->pending_connect_cid;
 236         int ringid = wil_find_free_vring(wil);
 237
 238         if (cid < 0) {
 239                 wil_err(wil, "No connection pending\n");
 240                 return;
 241         }
 242
 243         wil_dbg_wmi(wil, "Configure for connection CID %d\n", cid);
 244
 245         rc = wil_vring_init_tx(wil, ringid, WIL6210_TX_RING_SIZE, cid, 0);
 246         wil->pending_connect_cid = -1;
 247         if (rc == 0) {
 248                 wil->sta[cid].status = wil_sta_connected;
 249                 wil_link_on(wil);
 250         } else {
 251                 wil->sta[cid].status = wil_sta_unused;
 252         }
 253 }
 254
 255 int wil_priv_init(struct wil6210_priv *wil)
 256 {
 257         wil_dbg_misc(wil, "%s()\n", __func__);
 258
 259         memset(wil->sta, 0, sizeof(wil->sta));
 260
 261         mutex_init(&wil->mutex);
 262         mutex_init(&wil->wmi_mutex);
 263
 264         init_completion(&wil->wmi_ready);
 265
 266         wil->pending_connect_cid = -1;
 267         setup_timer(&wil->connect_timer, wil_connect_timer_fn, (ulong)wil);
 268         setup_timer(&wil->scan_timer, wil_scan_timer_fn, (ulong)wil);
 269
 270         INIT_WORK(&wil->connect_worker, wil_connect_worker);
 271         INIT_WORK(&wil->disconnect_worker, wil_disconnect_worker);
 272         INIT_WORK(&wil->wmi_event_worker, wmi_event_worker);
 273         INIT_WORK(&wil->fw_error_worker, wil_fw_error_worker);
 274
 275         INIT_LIST_HEAD(&wil->pending_wmi_ev);
 276         spin_lock_init(&wil->wmi_ev_lock);
 277
 278         wil->wmi_wq = create_singlethread_workqueue(WIL_NAME"_wmi");
 279         if (!wil->wmi_wq)
 280                 return -EAGAIN;
 281
 282         wil->wmi_wq_conn = create_singlethread_workqueue(WIL_NAME"_connect");
 283         if (!wil->wmi_wq_conn) {
 284                 destroy_workqueue(wil->wmi_wq);
 285                 return -EAGAIN;
 286         }
 287
 288         wil->last_fw_recovery = jiffies;
 289
 290         return 0;
 291 }
 292
 293 void wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid)
 294 {
 295         del_timer_sync(&wil->connect_timer);
 296         _wil6210_disconnect(wil, bssid);
 297 }
 298
 299 void wil_priv_deinit(struct wil6210_priv *wil)
 300 {
 301         del_timer_sync(&wil->scan_timer);
 302         cancel_work_sync(&wil->disconnect_worker);
 303         cancel_work_sync(&wil->fw_error_worker);
 304         mutex_lock(&wil->mutex);
 305         wil6210_disconnect(wil, NULL);
 306         mutex_unlock(&wil->mutex);
 307         wmi_event_flush(wil);
 308         destroy_workqueue(wil->wmi_wq_conn);
 309         destroy_workqueue(wil->wmi_wq);
 310 }
 311
 312 static void wil_target_reset(struct wil6210_priv *wil)
 313 {
 314         int delay = 0;
 315         u32 hw_state;
 316         u32 rev_id;
 317         bool is_sparrow = (wil->board->board == WIL_BOARD_SPARROW);
 318
 319         wil_dbg_misc(wil, "Resetting \"%s\"...\n", wil->board->name);
 320
 321         /* register read */
 322 #define R(a) ioread32(wil->csr + HOSTADDR(a))
 323         /* register write */
 324 #define W(a, v) iowrite32(v, wil->csr + HOSTADDR(a))
 325         /* register set = read, OR, write */
 326 #define S(a, v) W(a, R(a) | v)
 327         /* register clear = read, AND with inverted, write */
 328 #define C(a, v) W(a, R(a) & ~v)
 329
 330         wil->hw_version = R(RGF_USER_FW_REV_ID);
 331         rev_id = wil->hw_version & 0xff;
 332
 333         /* Clear MAC link up */
 334         S(RGF_HP_CTRL, BIT(15));
 335         /* hpal_perst_from_pad_src_n_mask */
 336         S(RGF_USER_CLKS_CTL_SW_RST_MASK_0, BIT(6));
 337         /* car_perst_rst_src_n_mask */
 338         S(RGF_USER_CLKS_CTL_SW_RST_MASK_0, BIT(7));
 339         wmb(); /* order is important here */
 340
 341         if (is_sparrow) {
 342                 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0, 0x3ff81f);
 343                 wmb(); /* order is important here */
 344         }
 345
 346         W(RGF_USER_MAC_CPU_0,  BIT(1)); /* mac_cpu_man_rst */
 347         W(RGF_USER_USER_CPU_0, BIT(1)); /* user_cpu_man_rst */
 348         wmb(); /* order is important here */
 349
 350         W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0xFE000000);
 351         W(RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0x0000003F);
 352         W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, is_sparrow ? 0x000000B0 : 0x00000170);
 353         W(RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0xFFE7FC00);
 354         wmb(); /* order is important here */
 355
 356         if (is_sparrow) {
 357                 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0, 0x0);
 358                 wmb(); /* order is important here */
 359         }
 360
 361         W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0);
 362         W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0);
 363         W(RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0);
 364         W(RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0);
 365         wmb(); /* order is important here */
 366
 367         if (is_sparrow) {
 368                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0x00000003);
 369                 /* reset A2 PCIE AHB */
 370                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x00008000);
 371
 372         } else {
 373                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0x00000001);
 374                 if (rev_id == 1) {
 375                         /* reset A1 BOTH PCIE AHB & PCIE RGF */
 376                         W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x00000080);
 377                 } else {
 378                         W(RGF_PCIE_LOS_COUNTER_CTL, BIT(6) | BIT(8));
 379                         W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x00008000);
 380                 }
 381
 382         }
 383
 384         /* TODO: check order here!!! Erez code is different */
 385         W(RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0);
 386         wmb(); /* order is important here */
 387
 388         /* wait until device ready */
 389         do {
 390                 msleep(1);
 391                 hw_state = R(RGF_USER_HW_MACHINE_STATE);
 392                 if (delay++ > 100) {
 393                         wil_err(wil, "Reset not completed, hw_state 0x%08x\n",
 394                                 hw_state);
 395                         return;
 396                 }
 397         } while (hw_state != HW_MACHINE_BOOT_DONE);
 398
 399         /* TODO: Erez check rev_id != 1 */
 400         if (!is_sparrow && (rev_id != 1))
 401                 W(RGF_PCIE_LOS_COUNTER_CTL, BIT(8));
 402
 403         C(RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD);
 404         wmb(); /* order is important here */
 405
 406         wil_dbg_misc(wil, "Reset completed in %d ms\n", delay);
 407
 408 #undef R
 409 #undef W
 410 #undef S
 411 #undef C
 412 }
 413
 414 void wil_mbox_ring_le2cpus(struct wil6210_mbox_ring *r)
 415 {
 416         le32_to_cpus(&r->base);
 417         le16_to_cpus(&r->entry_size);
 418         le16_to_cpus(&r->size);
 419         le32_to_cpus(&r->tail);
 420         le32_to_cpus(&r->head);
 421 }
 422
 423 static int wil_wait_for_fw_ready(struct wil6210_priv *wil)
 424 {
 425         ulong to = msecs_to_jiffies(1000);
 426         ulong left = wait_for_completion_timeout(&wil->wmi_ready, to);
 427         if (0 == left) {
 428                 wil_err(wil, "Firmware not ready\n");
 429                 return -ETIME;
 430         } else {
 431                 wil_info(wil, "FW ready after %d ms. HW version 0x%08x\n",
 432                          jiffies_to_msecs(to-left), wil->hw_version);
 433         }
 434         return 0;
 435 }
 436
 437 /*
 438  * We reset all the structures, and we reset the UMAC.
 439  * After calling this routine, you're expected to reload
 440  * the firmware.
 441  */
 442 int wil_reset(struct wil6210_priv *wil)
 443 {
 444         int rc;
 445
 446         WARN_ON(!mutex_is_locked(&wil->mutex));
 447
 448         cancel_work_sync(&wil->disconnect_worker);
 449         wil6210_disconnect(wil, NULL);
 450
 451         wil->status = 0; /* prevent NAPI from being scheduled */
 452         if (test_bit(wil_status_napi_en, &wil->status)) {
 453                 napi_synchronize(&wil->napi_rx);
 454         }
 455
 456         if (wil->scan_request) {
 457                 wil_dbg_misc(wil, "Abort scan_request 0x%p\n",
 458                              wil->scan_request);
 459                 del_timer_sync(&wil->scan_timer);
 460                 cfg80211_scan_done(wil->scan_request, true);
 461                 wil->scan_request = NULL;
 462         }
 463
 464         wil6210_disable_irq(wil);
 465
 466         wmi_event_flush(wil);
 467
 468         flush_workqueue(wil->wmi_wq_conn);
 469         flush_workqueue(wil->wmi_wq);
 470
 471         /* TODO: put MAC in reset */
 472         wil_target_reset(wil);
 473
 474         wil_rx_fini(wil);
 475
 476         /* init after reset */
 477         wil->pending_connect_cid = -1;
 478         reinit_completion(&wil->wmi_ready);
 479
 480         /* TODO: release MAC reset */
 481         wil6210_enable_irq(wil);
 482
 483         /* we just started MAC, wait for FW ready */
 484         rc = wil_wait_for_fw_ready(wil);
 485
 486         return rc;
 487 }
 488
 489 void wil_fw_error_recovery(struct wil6210_priv *wil)
 490 {
 491         wil_dbg_misc(wil, "starting fw error recovery\n");
 492         schedule_work(&wil->fw_error_worker);
 493 }
 494
 495 void wil_link_on(struct wil6210_priv *wil)
 496 {
 497         struct net_device *ndev = wil_to_ndev(wil);
 498
 499         wil_dbg_misc(wil, "%s()\n", __func__);
 500
 501         netif_carrier_on(ndev);
 502         wil_dbg_misc(wil, "netif_tx_wake : link on\n");
 503         netif_tx_wake_all_queues(ndev);
 504 }
 505
 506 void wil_link_off(struct wil6210_priv *wil)
 507 {
 508         struct net_device *ndev = wil_to_ndev(wil);
 509
 510         wil_dbg_misc(wil, "%s()\n", __func__);
 511
 512         netif_tx_stop_all_queues(ndev);
 513         wil_dbg_misc(wil, "netif_tx_stop : link off\n");
 514         netif_carrier_off(ndev);
 515 }
 516
 517 static int __wil_up(struct wil6210_priv *wil)
 518 {
 519         struct net_device *ndev = wil_to_ndev(wil);
 520         struct wireless_dev *wdev = wil->wdev;
 521         int rc;
 522
 523         WARN_ON(!mutex_is_locked(&wil->mutex));
 524
 525         rc = wil_reset(wil);
 526         if (rc)
 527                 return rc;
 528
 529         /* Rx VRING. After MAC and beacon */
 530         rc = wil_rx_init(wil);
 531         if (rc)
 532                 return rc;
 533
 534         switch (wdev->iftype) {
 535         case NL80211_IFTYPE_STATION:
 536                 wil_dbg_misc(wil, "type: STATION\n");
 537                 ndev->type = ARPHRD_ETHER;
 538                 break;
 539         case NL80211_IFTYPE_AP:
 540                 wil_dbg_misc(wil, "type: AP\n");
 541                 ndev->type = ARPHRD_ETHER;
 542                 break;
 543         case NL80211_IFTYPE_P2P_CLIENT:
 544                 wil_dbg_misc(wil, "type: P2P_CLIENT\n");
 545                 ndev->type = ARPHRD_ETHER;
 546                 break;
 547         case NL80211_IFTYPE_P2P_GO:
 548                 wil_dbg_misc(wil, "type: P2P_GO\n");
 549                 ndev->type = ARPHRD_ETHER;
 550                 break;
 551         case NL80211_IFTYPE_MONITOR:
 552                 wil_dbg_misc(wil, "type: Monitor\n");
 553                 ndev->type = ARPHRD_IEEE80211_RADIOTAP;
 554                 /* ARPHRD_IEEE80211 or ARPHRD_IEEE80211_RADIOTAP ? */
 555                 break;
 556         default:
 557                 return -EOPNOTSUPP;
 558         }
 559
 560         /* MAC address - pre-requisite for other commands */
 561         wmi_set_mac_address(wil, ndev->dev_addr);
 562
 563
 564         napi_enable(&wil->napi_rx);
 565         napi_enable(&wil->napi_tx);
 566         set_bit(wil_status_napi_en, &wil->status);
 567
 568         return 0;
 569 }
 570
 571 int wil_up(struct wil6210_priv *wil)
 572 {
 573         int rc;
 574
 575         mutex_lock(&wil->mutex);
 576         rc = __wil_up(wil);
 577         mutex_unlock(&wil->mutex);
 578
 579         return rc;
 580 }
 581
 582 static int __wil_down(struct wil6210_priv *wil)
 583 {
 584         WARN_ON(!mutex_is_locked(&wil->mutex));
 585
 586         clear_bit(wil_status_napi_en, &wil->status);
 587         napi_disable(&wil->napi_rx);
 588         napi_disable(&wil->napi_tx);
 589
 590         if (wil->scan_request) {
 591                 wil_dbg_misc(wil, "Abort scan_request 0x%p\n",
 592                              wil->scan_request);
 593                 del_timer_sync(&wil->scan_timer);
 594                 cfg80211_scan_done(wil->scan_request, true);
 595                 wil->scan_request = NULL;
 596         }
 597
 598         wil6210_disconnect(wil, NULL);
 599         wil_rx_fini(wil);
 600
 601         return 0;
 602 }
 603
 604 int wil_down(struct wil6210_priv *wil)
 605 {
 606         int rc;
 607
 608         mutex_lock(&wil->mutex);
 609         rc = __wil_down(wil);
 610         mutex_unlock(&wil->mutex);
 611
 612         return rc;
 613 }
 614
 615 int wil_find_cid(struct wil6210_priv *wil, const u8 *mac)
 616 {
 617         int i;
 618         int rc = -ENOENT;
 619
 620         for (i = 0; i < ARRAY_SIZE(wil->sta); i++) {
 621                 if ((wil->sta[i].status != wil_sta_unused) &&
 622                     ether_addr_equal(wil->sta[i].addr, mac)) {
 623                         rc = i;
 624                         break;
 625                 }
 626         }
 627
 628         return rc;
 629 }