2 * Copyright (c) 2012-2014 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/moduleparam.h>
18 #include <linux/if_arp.h>
19 #include <linux/etherdevice.h>
25 #define WAIT_FOR_DISCONNECT_TIMEOUT_MS 2000
26 #define WAIT_FOR_DISCONNECT_INTERVAL_MS 10
28 static bool no_fw_recovery
;
29 module_param(no_fw_recovery
, bool, S_IRUGO
| S_IWUSR
);
30 MODULE_PARM_DESC(no_fw_recovery
, " disable FW error recovery");
32 static bool no_fw_load
= true;
33 module_param(no_fw_load
, bool, S_IRUGO
| S_IWUSR
);
34 MODULE_PARM_DESC(no_fw_load
, " do not download FW, use one in on-card flash.");
36 #define RST_DELAY (20) /* msec, for loop in @wil_target_reset */
37 #define RST_COUNT (1 + 1000/RST_DELAY) /* round up to be above 1 sec total */
40 * Due to a hardware issue,
41 * one has to read/write to/from NIC in 32-bit chunks;
42 * regular memcpy_fromio and siblings will
43 * not work on 64-bit platform - it uses 64-bit transactions
45 * Force 32-bit transactions to enable NIC on 64-bit platforms
47 * To avoid byte swap on big endian host, __raw_{read|write}l
48 * should be used - {read|write}l would swap bytes to provide
49 * little endian on PCI value in host endianness.
51 void wil_memcpy_fromio_32(void *dst
, const volatile void __iomem
*src
,
55 const volatile u32 __iomem
*s
= src
;
57 /* size_t is unsigned, if (count%4 != 0) it will wrap */
58 for (count
+= 4; count
> 4; count
-= 4)
59 *d
++ = __raw_readl(s
++);
62 void wil_memcpy_toio_32(volatile void __iomem
*dst
, const void *src
,
65 volatile u32 __iomem
*d
= dst
;
68 for (count
+= 4; count
> 4; count
-= 4)
69 __raw_writel(*s
++, d
++);
72 static void wil_disconnect_cid(struct wil6210_priv
*wil
, int cid
)
75 struct net_device
*ndev
= wil_to_ndev(wil
);
76 struct wireless_dev
*wdev
= wil
->wdev
;
77 struct wil_sta_info
*sta
= &wil
->sta
[cid
];
79 wil_dbg_misc(wil
, "%s(CID %d, status %d)\n", __func__
, cid
,
82 sta
->data_port_open
= false;
83 if (sta
->status
!= wil_sta_unused
) {
84 wmi_disconnect_sta(wil
, sta
->addr
, WLAN_REASON_DEAUTH_LEAVING
);
85 switch (wdev
->iftype
) {
86 case NL80211_IFTYPE_AP
:
87 case NL80211_IFTYPE_P2P_GO
:
88 /* AP-like interface */
89 cfg80211_del_sta(ndev
, sta
->addr
, GFP_KERNEL
);
94 sta
->status
= wil_sta_unused
;
97 for (i
= 0; i
< WIL_STA_TID_NUM
; i
++) {
98 struct wil_tid_ampdu_rx
*r
;
101 spin_lock_irqsave(&sta
->tid_rx_lock
, flags
);
104 sta
->tid_rx
[i
] = NULL
;
105 wil_tid_ampdu_rx_free(wil
, r
);
107 spin_unlock_irqrestore(&sta
->tid_rx_lock
, flags
);
109 for (i
= 0; i
< ARRAY_SIZE(wil
->vring_tx
); i
++) {
110 if (wil
->vring2cid_tid
[i
][0] == cid
)
111 wil_vring_fini_tx(wil
, i
);
113 memset(&sta
->stats
, 0, sizeof(sta
->stats
));
116 static void _wil6210_disconnect(struct wil6210_priv
*wil
, const u8
*bssid
)
119 struct net_device
*ndev
= wil_to_ndev(wil
);
120 struct wireless_dev
*wdev
= wil
->wdev
;
124 cid
= wil_find_cid(wil
, bssid
);
125 wil_dbg_misc(wil
, "%s(%pM, CID %d)\n", __func__
, bssid
, cid
);
127 wil_dbg_misc(wil
, "%s(all)\n", __func__
);
130 if (cid
>= 0) /* disconnect 1 peer */
131 wil_disconnect_cid(wil
, cid
);
132 else /* disconnect all */
133 for (cid
= 0; cid
< WIL6210_MAX_CID
; cid
++)
134 wil_disconnect_cid(wil
, cid
);
137 switch (wdev
->iftype
) {
138 case NL80211_IFTYPE_STATION
:
139 case NL80211_IFTYPE_P2P_CLIENT
:
141 if (test_bit(wil_status_fwconnected
, &wil
->status
)) {
142 clear_bit(wil_status_fwconnected
, &wil
->status
);
143 cfg80211_disconnected(ndev
,
144 WLAN_STATUS_UNSPECIFIED_FAILURE
,
145 NULL
, 0, GFP_KERNEL
);
146 } else if (test_bit(wil_status_fwconnecting
, &wil
->status
)) {
147 cfg80211_connect_result(ndev
, bssid
, NULL
, 0, NULL
, 0,
148 WLAN_STATUS_UNSPECIFIED_FAILURE
,
151 clear_bit(wil_status_fwconnecting
, &wil
->status
);
158 static void wil_disconnect_worker(struct work_struct
*work
)
160 struct wil6210_priv
*wil
= container_of(work
,
161 struct wil6210_priv
, disconnect_worker
);
163 mutex_lock(&wil
->mutex
);
164 _wil6210_disconnect(wil
, NULL
);
165 mutex_unlock(&wil
->mutex
);
168 static void wil_connect_timer_fn(ulong x
)
170 struct wil6210_priv
*wil
= (void *)x
;
172 wil_dbg_misc(wil
, "Connect timeout\n");
174 /* reschedule to thread context - disconnect won't
175 * run from atomic context
177 schedule_work(&wil
->disconnect_worker
);
180 static void wil_scan_timer_fn(ulong x
)
182 struct wil6210_priv
*wil
= (void *)x
;
184 clear_bit(wil_status_fwready
, &wil
->status
);
185 wil_err(wil
, "Scan timeout detected, start fw error recovery\n");
186 schedule_work(&wil
->fw_error_worker
);
189 static void wil_fw_error_worker(struct work_struct
*work
)
191 struct wil6210_priv
*wil
= container_of(work
,
192 struct wil6210_priv
, fw_error_worker
);
193 struct wireless_dev
*wdev
= wil
->wdev
;
195 wil_dbg_misc(wil
, "fw error worker\n");
200 /* increment @recovery_count if less then WIL6210_FW_RECOVERY_TO
201 * passed since last recovery attempt
203 if (time_is_after_jiffies(wil
->last_fw_recovery
+
204 WIL6210_FW_RECOVERY_TO
))
205 wil
->recovery_count
++;
207 wil
->recovery_count
= 1; /* fw was alive for a long time */
209 if (wil
->recovery_count
> WIL6210_FW_RECOVERY_RETRIES
) {
210 wil_err(wil
, "too many recovery attempts (%d), giving up\n",
211 wil
->recovery_count
);
215 wil
->last_fw_recovery
= jiffies
;
217 mutex_lock(&wil
->mutex
);
218 switch (wdev
->iftype
) {
219 case NL80211_IFTYPE_STATION
:
220 case NL80211_IFTYPE_P2P_CLIENT
:
221 case NL80211_IFTYPE_MONITOR
:
222 wil_info(wil
, "fw error recovery started (try %d)...\n",
223 wil
->recovery_count
);
226 /* need to re-allocate Rx ring after reset */
229 case NL80211_IFTYPE_AP
:
230 case NL80211_IFTYPE_P2P_GO
:
231 /* recovery in these modes is done by upper layers */
236 mutex_unlock(&wil
->mutex
);
239 static int wil_find_free_vring(struct wil6210_priv
*wil
)
243 for (i
= 0; i
< WIL6210_MAX_TX_RINGS
; i
++) {
244 if (!wil
->vring_tx
[i
].va
)
250 static void wil_connect_worker(struct work_struct
*work
)
253 struct wil6210_priv
*wil
= container_of(work
, struct wil6210_priv
,
255 int cid
= wil
->pending_connect_cid
;
256 int ringid
= wil_find_free_vring(wil
);
259 wil_err(wil
, "No connection pending\n");
263 wil_dbg_wmi(wil
, "Configure for connection CID %d\n", cid
);
265 rc
= wil_vring_init_tx(wil
, ringid
, WIL6210_TX_RING_SIZE
, cid
, 0);
266 wil
->pending_connect_cid
= -1;
268 wil
->sta
[cid
].status
= wil_sta_connected
;
271 wil
->sta
[cid
].status
= wil_sta_unused
;
275 int wil_priv_init(struct wil6210_priv
*wil
)
279 wil_dbg_misc(wil
, "%s()\n", __func__
);
281 memset(wil
->sta
, 0, sizeof(wil
->sta
));
282 for (i
= 0; i
< WIL6210_MAX_CID
; i
++)
283 spin_lock_init(&wil
->sta
[i
].tid_rx_lock
);
285 mutex_init(&wil
->mutex
);
286 mutex_init(&wil
->wmi_mutex
);
288 init_completion(&wil
->wmi_ready
);
290 wil
->pending_connect_cid
= -1;
291 setup_timer(&wil
->connect_timer
, wil_connect_timer_fn
, (ulong
)wil
);
292 setup_timer(&wil
->scan_timer
, wil_scan_timer_fn
, (ulong
)wil
);
294 INIT_WORK(&wil
->connect_worker
, wil_connect_worker
);
295 INIT_WORK(&wil
->disconnect_worker
, wil_disconnect_worker
);
296 INIT_WORK(&wil
->wmi_event_worker
, wmi_event_worker
);
297 INIT_WORK(&wil
->fw_error_worker
, wil_fw_error_worker
);
299 INIT_LIST_HEAD(&wil
->pending_wmi_ev
);
300 spin_lock_init(&wil
->wmi_ev_lock
);
302 wil
->wmi_wq
= create_singlethread_workqueue(WIL_NAME
"_wmi");
306 wil
->wmi_wq_conn
= create_singlethread_workqueue(WIL_NAME
"_connect");
307 if (!wil
->wmi_wq_conn
) {
308 destroy_workqueue(wil
->wmi_wq
);
312 wil
->last_fw_recovery
= jiffies
;
317 void wil6210_disconnect(struct wil6210_priv
*wil
, const u8
*bssid
)
319 wil_dbg_misc(wil
, "%s()\n", __func__
);
321 del_timer_sync(&wil
->connect_timer
);
322 _wil6210_disconnect(wil
, bssid
);
325 void wil_priv_deinit(struct wil6210_priv
*wil
)
327 wil_dbg_misc(wil
, "%s()\n", __func__
);
329 del_timer_sync(&wil
->scan_timer
);
330 cancel_work_sync(&wil
->disconnect_worker
);
331 cancel_work_sync(&wil
->fw_error_worker
);
332 mutex_lock(&wil
->mutex
);
333 wil6210_disconnect(wil
, NULL
);
334 mutex_unlock(&wil
->mutex
);
335 wmi_event_flush(wil
);
336 destroy_workqueue(wil
->wmi_wq_conn
);
337 destroy_workqueue(wil
->wmi_wq
);
340 /* target operations */
342 #define R(a) ioread32(wil->csr + HOSTADDR(a))
343 /* register write. wmb() to make sure it is completed */
344 #define W(a, v) do { iowrite32(v, wil->csr + HOSTADDR(a)); wmb(); } while (0)
345 /* register set = read, OR, write */
346 #define S(a, v) W(a, R(a) | v)
347 /* register clear = read, AND with inverted, write */
348 #define C(a, v) W(a, R(a) & ~v)
350 static inline void wil_halt_cpu(struct wil6210_priv
*wil
)
352 W(RGF_USER_USER_CPU_0
, BIT_USER_USER_CPU_MAN_RST
);
353 W(RGF_USER_MAC_CPU_0
, BIT_USER_MAC_CPU_MAN_RST
);
356 static inline void wil_release_cpu(struct wil6210_priv
*wil
)
359 W(RGF_USER_USER_CPU_0
, 1);
362 static int wil_target_reset(struct wil6210_priv
*wil
)
367 bool is_sparrow
= (wil
->board
->board
== WIL_BOARD_SPARROW
);
369 wil_dbg_misc(wil
, "Resetting \"%s\"...\n", wil
->board
->name
);
371 wil
->hw_version
= R(RGF_USER_FW_REV_ID
);
372 rev_id
= wil
->hw_version
& 0xff;
374 /* Clear MAC link up */
375 S(RGF_HP_CTRL
, BIT(15));
376 S(RGF_USER_CLKS_CTL_SW_RST_MASK_0
, BIT_HPAL_PERST_FROM_PAD
);
377 S(RGF_USER_CLKS_CTL_SW_RST_MASK_0
, BIT_CAR_PERST_RST
);
380 C(RGF_USER_CLKS_CTL_0
, BIT_USER_CLKS_CAR_AHB_SW_SEL
); /* 40 MHz */
383 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0
, 0x3ff81f);
384 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_1
, 0xf);
387 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0xFE000000);
388 W(RGF_USER_CLKS_CTL_SW_RST_VEC_1
, 0x0000003F);
389 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, is_sparrow
? 0x000000f0 : 0x00000170);
390 W(RGF_USER_CLKS_CTL_SW_RST_VEC_0
, 0xFFE7FE00);
393 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0
, 0x0);
394 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_1
, 0x0);
397 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0);
398 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0);
399 W(RGF_USER_CLKS_CTL_SW_RST_VEC_1
, 0);
400 W(RGF_USER_CLKS_CTL_SW_RST_VEC_0
, 0);
403 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0x00000003);
404 /* reset A2 PCIE AHB */
405 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00008000);
407 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0x00000001);
409 /* reset A1 BOTH PCIE AHB & PCIE RGF */
410 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00000080);
412 W(RGF_PCIE_LOS_COUNTER_CTL
, BIT(6) | BIT(8));
413 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00008000);
417 /* TODO: check order here!!! Erez code is different */
418 W(RGF_USER_CLKS_CTL_SW_RST_VEC_0
, 0);
420 /* wait until device ready. typical time is 200..250 msec */
423 hw_state
= R(RGF_USER_HW_MACHINE_STATE
);
424 if (delay
++ > RST_COUNT
) {
425 wil_err(wil
, "Reset not completed, hw_state 0x%08x\n",
429 } while (hw_state
!= HW_MACHINE_BOOT_DONE
);
431 /* TODO: Erez check rev_id != 1 */
432 if (!is_sparrow
&& (rev_id
!= 1))
433 W(RGF_PCIE_LOS_COUNTER_CTL
, BIT(8));
435 C(RGF_USER_CLKS_CTL_0
, BIT_USER_CLKS_RST_PWGD
);
437 wil_dbg_misc(wil
, "Reset completed in %d ms\n", delay
* RST_DELAY
);
446 void wil_mbox_ring_le2cpus(struct wil6210_mbox_ring
*r
)
448 le32_to_cpus(&r
->base
);
449 le16_to_cpus(&r
->entry_size
);
450 le16_to_cpus(&r
->size
);
451 le32_to_cpus(&r
->tail
);
452 le32_to_cpus(&r
->head
);
455 static int wil_wait_for_fw_ready(struct wil6210_priv
*wil
)
457 ulong to
= msecs_to_jiffies(1000);
458 ulong left
= wait_for_completion_timeout(&wil
->wmi_ready
, to
);
461 wil_err(wil
, "Firmware not ready\n");
464 wil_info(wil
, "FW ready after %d ms. HW version 0x%08x\n",
465 jiffies_to_msecs(to
-left
), wil
->hw_version
);
471 * We reset all the structures, and we reset the UMAC.
472 * After calling this routine, you're expected to reload
475 int wil_reset(struct wil6210_priv
*wil
)
479 wil_dbg_misc(wil
, "%s()\n", __func__
);
481 WARN_ON(!mutex_is_locked(&wil
->mutex
));
483 cancel_work_sync(&wil
->disconnect_worker
);
484 wil6210_disconnect(wil
, NULL
);
486 wil
->status
= 0; /* prevent NAPI from being scheduled */
487 if (test_bit(wil_status_napi_en
, &wil
->status
))
488 napi_synchronize(&wil
->napi_rx
);
490 if (wil
->scan_request
) {
491 wil_dbg_misc(wil
, "Abort scan_request 0x%p\n",
493 del_timer_sync(&wil
->scan_timer
);
494 cfg80211_scan_done(wil
->scan_request
, true);
495 wil
->scan_request
= NULL
;
498 wil6210_disable_irq(wil
);
500 wmi_event_flush(wil
);
502 flush_workqueue(wil
->wmi_wq_conn
);
503 flush_workqueue(wil
->wmi_wq
);
505 rc
= wil_target_reset(wil
);
511 wil_info(wil
, "Use firmware <%s>\n", WIL_FW_NAME
);
513 /* Loading f/w from the file */
514 rc
= wil_request_firmware(wil
, WIL_FW_NAME
);
518 /* clear any interrupts which on-card-firmware may have set */
519 wil6210_clear_irq(wil
);
520 { /* CAF_ICR - clear and mask */
521 u32 a
= HOSTADDR(RGF_CAF_ICR
) +
522 offsetof(struct RGF_ICR
, ICR
);
523 u32 m
= HOSTADDR(RGF_CAF_ICR
) +
524 offsetof(struct RGF_ICR
, IMV
);
525 u32 icr
= ioread32(wil
->csr
+ a
);
527 iowrite32(icr
, wil
->csr
+ a
); /* W1C */
528 iowrite32(~0, wil
->csr
+ m
);
529 wmb(); /* wait for completion */
531 wil_release_cpu(wil
);
533 wil_info(wil
, "Use firmware from on-card flash\n");
536 /* init after reset */
537 wil
->pending_connect_cid
= -1;
538 reinit_completion(&wil
->wmi_ready
);
540 wil6210_enable_irq(wil
);
542 /* we just started MAC, wait for FW ready */
543 rc
= wil_wait_for_fw_ready(wil
);
548 void wil_fw_error_recovery(struct wil6210_priv
*wil
)
550 wil_dbg_misc(wil
, "starting fw error recovery\n");
551 schedule_work(&wil
->fw_error_worker
);
554 void wil_link_on(struct wil6210_priv
*wil
)
556 struct net_device
*ndev
= wil_to_ndev(wil
);
558 wil_dbg_misc(wil
, "%s()\n", __func__
);
560 netif_carrier_on(ndev
);
561 wil_dbg_misc(wil
, "netif_tx_wake : link on\n");
562 netif_tx_wake_all_queues(ndev
);
565 void wil_link_off(struct wil6210_priv
*wil
)
567 struct net_device
*ndev
= wil_to_ndev(wil
);
569 wil_dbg_misc(wil
, "%s()\n", __func__
);
571 netif_tx_stop_all_queues(ndev
);
572 wil_dbg_misc(wil
, "netif_tx_stop : link off\n");
573 netif_carrier_off(ndev
);
576 static int __wil_up(struct wil6210_priv
*wil
)
578 struct net_device
*ndev
= wil_to_ndev(wil
);
579 struct wireless_dev
*wdev
= wil
->wdev
;
582 WARN_ON(!mutex_is_locked(&wil
->mutex
));
588 /* Rx VRING. After MAC and beacon */
589 rc
= wil_rx_init(wil
);
593 switch (wdev
->iftype
) {
594 case NL80211_IFTYPE_STATION
:
595 wil_dbg_misc(wil
, "type: STATION\n");
596 ndev
->type
= ARPHRD_ETHER
;
598 case NL80211_IFTYPE_AP
:
599 wil_dbg_misc(wil
, "type: AP\n");
600 ndev
->type
= ARPHRD_ETHER
;
602 case NL80211_IFTYPE_P2P_CLIENT
:
603 wil_dbg_misc(wil
, "type: P2P_CLIENT\n");
604 ndev
->type
= ARPHRD_ETHER
;
606 case NL80211_IFTYPE_P2P_GO
:
607 wil_dbg_misc(wil
, "type: P2P_GO\n");
608 ndev
->type
= ARPHRD_ETHER
;
610 case NL80211_IFTYPE_MONITOR
:
611 wil_dbg_misc(wil
, "type: Monitor\n");
612 ndev
->type
= ARPHRD_IEEE80211_RADIOTAP
;
613 /* ARPHRD_IEEE80211 or ARPHRD_IEEE80211_RADIOTAP ? */
619 /* MAC address - pre-requisite for other commands */
620 wmi_set_mac_address(wil
, ndev
->dev_addr
);
623 napi_enable(&wil
->napi_rx
);
624 napi_enable(&wil
->napi_tx
);
625 set_bit(wil_status_napi_en
, &wil
->status
);
627 if (wil
->platform_ops
.bus_request
)
628 wil
->platform_ops
.bus_request(wil
->platform_handle
,
629 WIL_MAX_BUS_REQUEST_KBPS
);
634 int wil_up(struct wil6210_priv
*wil
)
638 wil_dbg_misc(wil
, "%s()\n", __func__
);
640 mutex_lock(&wil
->mutex
);
642 mutex_unlock(&wil
->mutex
);
647 static int __wil_down(struct wil6210_priv
*wil
)
649 int iter
= WAIT_FOR_DISCONNECT_TIMEOUT_MS
/
650 WAIT_FOR_DISCONNECT_INTERVAL_MS
;
652 WARN_ON(!mutex_is_locked(&wil
->mutex
));
654 if (wil
->platform_ops
.bus_request
)
655 wil
->platform_ops
.bus_request(wil
->platform_handle
, 0);
657 clear_bit(wil_status_napi_en
, &wil
->status
);
658 napi_disable(&wil
->napi_rx
);
659 napi_disable(&wil
->napi_tx
);
661 if (wil
->scan_request
) {
662 wil_dbg_misc(wil
, "Abort scan_request 0x%p\n",
664 del_timer_sync(&wil
->scan_timer
);
665 cfg80211_scan_done(wil
->scan_request
, true);
666 wil
->scan_request
= NULL
;
669 if (test_bit(wil_status_fwconnected
, &wil
->status
) ||
670 test_bit(wil_status_fwconnecting
, &wil
->status
))
671 wmi_send(wil
, WMI_DISCONNECT_CMDID
, NULL
, 0);
673 /* make sure wil is idle (not connected) */
674 mutex_unlock(&wil
->mutex
);
676 int idle
= !test_bit(wil_status_fwconnected
, &wil
->status
) &&
677 !test_bit(wil_status_fwconnecting
, &wil
->status
);
680 msleep(WAIT_FOR_DISCONNECT_INTERVAL_MS
);
682 mutex_lock(&wil
->mutex
);
685 wil_err(wil
, "timeout waiting for idle FW/HW\n");
692 int wil_down(struct wil6210_priv
*wil
)
696 wil_dbg_misc(wil
, "%s()\n", __func__
);
698 mutex_lock(&wil
->mutex
);
699 rc
= __wil_down(wil
);
700 mutex_unlock(&wil
->mutex
);
705 int wil_find_cid(struct wil6210_priv
*wil
, const u8
*mac
)
710 for (i
= 0; i
< ARRAY_SIZE(wil
->sta
); i
++) {
711 if ((wil
->sta
[i
].status
!= wil_sta_unused
) &&
712 ether_addr_equal(wil
->sta
[i
].addr
, mac
)) {