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>
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");
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
34 * Force 32-bit transactions to enable NIC on 64-bit platforms
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.
40 void wil_memcpy_fromio_32(void *dst
, const volatile void __iomem
*src
,
44 const volatile u32 __iomem
*s
= src
;
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
++);
51 void wil_memcpy_toio_32(volatile void __iomem
*dst
, const void *src
,
54 volatile u32 __iomem
*d
= dst
;
57 for (count
+= 4; count
> 4; count
-= 4)
58 __raw_writel(*s
++, d
++);
61 static void wil_disconnect_cid(struct wil6210_priv
*wil
, int cid
)
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
,
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
);
82 sta
->status
= wil_sta_unused
;
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
);
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
);
94 memset(&sta
->stats
, 0, sizeof(sta
->stats
));
97 static void _wil6210_disconnect(struct wil6210_priv
*wil
, const u8
*bssid
)
100 struct net_device
*ndev
= wil_to_ndev(wil
);
101 struct wireless_dev
*wdev
= wil
->wdev
;
105 cid
= wil_find_cid(wil
, bssid
);
106 wil_dbg_misc(wil
, "%s(%pM, CID %d)\n", __func__
, bssid
, cid
);
108 wil_dbg_misc(wil
, "%s(all)\n", __func__
);
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
);
118 switch (wdev
->iftype
) {
119 case NL80211_IFTYPE_STATION
:
120 case NL80211_IFTYPE_P2P_CLIENT
:
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
,
132 clear_bit(wil_status_fwconnecting
, &wil
->status
);
139 static void wil_disconnect_worker(struct work_struct
*work
)
141 struct wil6210_priv
*wil
= container_of(work
,
142 struct wil6210_priv
, disconnect_worker
);
144 mutex_lock(&wil
->mutex
);
145 _wil6210_disconnect(wil
, NULL
);
146 mutex_unlock(&wil
->mutex
);
149 static void wil_connect_timer_fn(ulong x
)
151 struct wil6210_priv
*wil
= (void *)x
;
153 wil_dbg_misc(wil
, "Connect timeout\n");
155 /* reschedule to thread context - disconnect won't
156 * run from atomic context
158 schedule_work(&wil
->disconnect_worker
);
161 static void wil_scan_timer_fn(ulong x
)
163 struct wil6210_priv
*wil
= (void *)x
;
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
);
170 static void wil_fw_error_worker(struct work_struct
*work
)
172 struct wil6210_priv
*wil
= container_of(work
,
173 struct wil6210_priv
, fw_error_worker
);
174 struct wireless_dev
*wdev
= wil
->wdev
;
176 wil_dbg_misc(wil
, "fw error worker\n");
181 /* increment @recovery_count if less then WIL6210_FW_RECOVERY_TO
182 * passed since last recovery attempt
184 if (time_is_after_jiffies(wil
->last_fw_recovery
+
185 WIL6210_FW_RECOVERY_TO
))
186 wil
->recovery_count
++;
188 wil
->recovery_count
= 1; /* fw was alive for a long time */
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
);
196 wil
->last_fw_recovery
= jiffies
;
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
);
207 /* need to re-allocate Rx ring after reset */
210 case NL80211_IFTYPE_AP
:
211 case NL80211_IFTYPE_P2P_GO
:
212 /* recovery in these modes is done by upper layers */
217 mutex_unlock(&wil
->mutex
);
220 static int wil_find_free_vring(struct wil6210_priv
*wil
)
223 for (i
= 0; i
< WIL6210_MAX_TX_RINGS
; i
++) {
224 if (!wil
->vring_tx
[i
].va
)
230 static void wil_connect_worker(struct work_struct
*work
)
233 struct wil6210_priv
*wil
= container_of(work
, struct wil6210_priv
,
235 int cid
= wil
->pending_connect_cid
;
236 int ringid
= wil_find_free_vring(wil
);
239 wil_err(wil
, "No connection pending\n");
243 wil_dbg_wmi(wil
, "Configure for connection CID %d\n", cid
);
245 rc
= wil_vring_init_tx(wil
, ringid
, WIL6210_TX_RING_SIZE
, cid
, 0);
246 wil
->pending_connect_cid
= -1;
248 wil
->sta
[cid
].status
= wil_sta_connected
;
251 wil
->sta
[cid
].status
= wil_sta_unused
;
255 int wil_priv_init(struct wil6210_priv
*wil
)
257 wil_dbg_misc(wil
, "%s()\n", __func__
);
259 memset(wil
->sta
, 0, sizeof(wil
->sta
));
261 mutex_init(&wil
->mutex
);
262 mutex_init(&wil
->wmi_mutex
);
264 init_completion(&wil
->wmi_ready
);
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
);
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
);
275 INIT_LIST_HEAD(&wil
->pending_wmi_ev
);
276 spin_lock_init(&wil
->wmi_ev_lock
);
278 wil
->wmi_wq
= create_singlethread_workqueue(WIL_NAME
"_wmi");
282 wil
->wmi_wq_conn
= create_singlethread_workqueue(WIL_NAME
"_connect");
283 if (!wil
->wmi_wq_conn
) {
284 destroy_workqueue(wil
->wmi_wq
);
288 wil
->last_fw_recovery
= jiffies
;
293 void wil6210_disconnect(struct wil6210_priv
*wil
, const u8
*bssid
)
295 del_timer_sync(&wil
->connect_timer
);
296 _wil6210_disconnect(wil
, bssid
);
299 void wil_priv_deinit(struct wil6210_priv
*wil
)
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
);
312 static void wil_target_reset(struct wil6210_priv
*wil
)
317 bool is_sparrow
= (wil
->board
->board
== WIL_BOARD_SPARROW
);
319 wil_dbg_misc(wil
, "Resetting \"%s\"...\n", wil
->board
->name
);
322 #define R(a) ioread32(wil->csr + HOSTADDR(a))
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)
330 wmb(); /* If host reorder writes here -> race in NIC */
331 W(RGF_USER_MAC_CPU_0
, BIT(1)); /* mac_cpu_man_rst */
332 wil
->hw_version
= R(RGF_USER_FW_REV_ID
);
333 rev_id
= wil
->hw_version
& 0xff;
335 /* Clear MAC link up */
336 S(RGF_HP_CTRL
, BIT(15));
337 /* hpal_perst_from_pad_src_n_mask */
338 S(RGF_USER_CLKS_CTL_SW_RST_MASK_0
, BIT(6));
339 /* car_perst_rst_src_n_mask */
340 S(RGF_USER_CLKS_CTL_SW_RST_MASK_0
, BIT(7));
341 wmb(); /* order is important here */
344 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0
, 0x3ff81f);
345 wmb(); /* order is important here */
348 W(RGF_USER_USER_CPU_0
, BIT(1)); /* user_cpu_man_rst */
349 wmb(); /* If host reorder writes here -> race in NIC */
350 W(RGF_USER_MAC_CPU_0
, BIT(1)); /* mac_cpu_man_rst */
351 wmb(); /* order is important here */
353 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0xFE000000);
354 W(RGF_USER_CLKS_CTL_SW_RST_VEC_1
, 0x0000003F);
355 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, is_sparrow
? 0x000000B0 : 0x00000170);
356 W(RGF_USER_CLKS_CTL_SW_RST_VEC_0
, 0xFFE7FC00);
357 wmb(); /* order is important here */
360 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0
, 0x0);
361 wmb(); /* order is important here */
364 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0);
365 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0);
366 W(RGF_USER_CLKS_CTL_SW_RST_VEC_1
, 0);
367 W(RGF_USER_CLKS_CTL_SW_RST_VEC_0
, 0);
368 wmb(); /* order is important here */
371 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0x00000003);
372 /* reset A2 PCIE AHB */
373 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00008000);
376 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0x00000001);
378 /* reset A1 BOTH PCIE AHB & PCIE RGF */
379 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00000080);
381 W(RGF_PCIE_LOS_COUNTER_CTL
, BIT(6) | BIT(8));
382 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00008000);
387 /* TODO: check order here!!! Erez code is different */
388 W(RGF_USER_CLKS_CTL_SW_RST_VEC_0
, 0);
389 wmb(); /* order is important here */
391 /* wait until device ready */
394 hw_state
= R(RGF_USER_HW_MACHINE_STATE
);
396 wil_err(wil
, "Reset not completed, hw_state 0x%08x\n",
400 } while (hw_state
!= HW_MACHINE_BOOT_DONE
);
402 /* TODO: Erez check rev_id != 1 */
403 if (!is_sparrow
&& (rev_id
!= 1))
404 W(RGF_PCIE_LOS_COUNTER_CTL
, BIT(8));
406 C(RGF_USER_CLKS_CTL_0
, BIT_USER_CLKS_RST_PWGD
);
407 wmb(); /* order is important here */
409 wil_dbg_misc(wil
, "Reset completed in %d ms\n", delay
);
417 void wil_mbox_ring_le2cpus(struct wil6210_mbox_ring
*r
)
419 le32_to_cpus(&r
->base
);
420 le16_to_cpus(&r
->entry_size
);
421 le16_to_cpus(&r
->size
);
422 le32_to_cpus(&r
->tail
);
423 le32_to_cpus(&r
->head
);
426 static int wil_wait_for_fw_ready(struct wil6210_priv
*wil
)
428 ulong to
= msecs_to_jiffies(1000);
429 ulong left
= wait_for_completion_timeout(&wil
->wmi_ready
, to
);
431 wil_err(wil
, "Firmware not ready\n");
434 wil_info(wil
, "FW ready after %d ms. HW version 0x%08x\n",
435 jiffies_to_msecs(to
-left
), wil
->hw_version
);
441 * We reset all the structures, and we reset the UMAC.
442 * After calling this routine, you're expected to reload
445 int wil_reset(struct wil6210_priv
*wil
)
449 WARN_ON(!mutex_is_locked(&wil
->mutex
));
451 cancel_work_sync(&wil
->disconnect_worker
);
452 wil6210_disconnect(wil
, NULL
);
454 wil
->status
= 0; /* prevent NAPI from being scheduled */
455 if (test_bit(wil_status_napi_en
, &wil
->status
)) {
456 napi_synchronize(&wil
->napi_rx
);
459 if (wil
->scan_request
) {
460 wil_dbg_misc(wil
, "Abort scan_request 0x%p\n",
462 del_timer_sync(&wil
->scan_timer
);
463 cfg80211_scan_done(wil
->scan_request
, true);
464 wil
->scan_request
= NULL
;
467 wil6210_disable_irq(wil
);
469 wmi_event_flush(wil
);
471 flush_workqueue(wil
->wmi_wq_conn
);
472 flush_workqueue(wil
->wmi_wq
);
474 /* TODO: put MAC in reset */
475 wil_target_reset(wil
);
479 /* init after reset */
480 wil
->pending_connect_cid
= -1;
481 reinit_completion(&wil
->wmi_ready
);
483 /* TODO: release MAC reset */
484 wil6210_enable_irq(wil
);
486 /* we just started MAC, wait for FW ready */
487 rc
= wil_wait_for_fw_ready(wil
);
492 void wil_fw_error_recovery(struct wil6210_priv
*wil
)
494 wil_dbg_misc(wil
, "starting fw error recovery\n");
495 schedule_work(&wil
->fw_error_worker
);
498 void wil_link_on(struct wil6210_priv
*wil
)
500 struct net_device
*ndev
= wil_to_ndev(wil
);
502 wil_dbg_misc(wil
, "%s()\n", __func__
);
504 netif_carrier_on(ndev
);
505 wil_dbg_misc(wil
, "netif_tx_wake : link on\n");
506 netif_tx_wake_all_queues(ndev
);
509 void wil_link_off(struct wil6210_priv
*wil
)
511 struct net_device
*ndev
= wil_to_ndev(wil
);
513 wil_dbg_misc(wil
, "%s()\n", __func__
);
515 netif_tx_stop_all_queues(ndev
);
516 wil_dbg_misc(wil
, "netif_tx_stop : link off\n");
517 netif_carrier_off(ndev
);
520 static int __wil_up(struct wil6210_priv
*wil
)
522 struct net_device
*ndev
= wil_to_ndev(wil
);
523 struct wireless_dev
*wdev
= wil
->wdev
;
526 WARN_ON(!mutex_is_locked(&wil
->mutex
));
532 /* Rx VRING. After MAC and beacon */
533 rc
= wil_rx_init(wil
);
537 switch (wdev
->iftype
) {
538 case NL80211_IFTYPE_STATION
:
539 wil_dbg_misc(wil
, "type: STATION\n");
540 ndev
->type
= ARPHRD_ETHER
;
542 case NL80211_IFTYPE_AP
:
543 wil_dbg_misc(wil
, "type: AP\n");
544 ndev
->type
= ARPHRD_ETHER
;
546 case NL80211_IFTYPE_P2P_CLIENT
:
547 wil_dbg_misc(wil
, "type: P2P_CLIENT\n");
548 ndev
->type
= ARPHRD_ETHER
;
550 case NL80211_IFTYPE_P2P_GO
:
551 wil_dbg_misc(wil
, "type: P2P_GO\n");
552 ndev
->type
= ARPHRD_ETHER
;
554 case NL80211_IFTYPE_MONITOR
:
555 wil_dbg_misc(wil
, "type: Monitor\n");
556 ndev
->type
= ARPHRD_IEEE80211_RADIOTAP
;
557 /* ARPHRD_IEEE80211 or ARPHRD_IEEE80211_RADIOTAP ? */
563 /* MAC address - pre-requisite for other commands */
564 wmi_set_mac_address(wil
, ndev
->dev_addr
);
567 napi_enable(&wil
->napi_rx
);
568 napi_enable(&wil
->napi_tx
);
569 set_bit(wil_status_napi_en
, &wil
->status
);
574 int wil_up(struct wil6210_priv
*wil
)
578 mutex_lock(&wil
->mutex
);
580 mutex_unlock(&wil
->mutex
);
585 static int __wil_down(struct wil6210_priv
*wil
)
587 WARN_ON(!mutex_is_locked(&wil
->mutex
));
589 clear_bit(wil_status_napi_en
, &wil
->status
);
590 napi_disable(&wil
->napi_rx
);
591 napi_disable(&wil
->napi_tx
);
593 if (wil
->scan_request
) {
594 wil_dbg_misc(wil
, "Abort scan_request 0x%p\n",
596 del_timer_sync(&wil
->scan_timer
);
597 cfg80211_scan_done(wil
->scan_request
, true);
598 wil
->scan_request
= NULL
;
601 wil6210_disconnect(wil
, NULL
);
607 int wil_down(struct wil6210_priv
*wil
)
611 mutex_lock(&wil
->mutex
);
612 rc
= __wil_down(wil
);
613 mutex_unlock(&wil
->mutex
);
618 int wil_find_cid(struct wil6210_priv
*wil
, const u8
*mac
)
623 for (i
= 0; i
< ARRAY_SIZE(wil
->sta
); i
++) {
624 if ((wil
->sta
[i
].status
!= wil_sta_unused
) &&
625 ether_addr_equal(wil
->sta
[i
].addr
, mac
)) {