2 * Copyright (c) 2012 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 wil
->hw_version
= R(RGF_USER_FW_REV_ID
);
331 rev_id
= wil
->hw_version
& 0xff;
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 */
342 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0
, 0x3ff81f);
343 wmb(); /* order is important here */
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 */
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 */
357 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0
, 0x0);
358 wmb(); /* order is important here */
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 */
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);
373 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3
, 0x00000001);
375 /* reset A1 BOTH PCIE AHB & PCIE RGF */
376 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00000080);
378 W(RGF_PCIE_LOS_COUNTER_CTL
, BIT(6) | BIT(8));
379 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2
, 0x00008000);
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 */
388 /* wait until device ready */
391 hw_state
= R(RGF_USER_HW_MACHINE_STATE
);
393 wil_err(wil
, "Reset not completed, hw_state 0x%08x\n",
397 } while (hw_state
!= HW_MACHINE_BOOT_DONE
);
399 /* TODO: Erez check rev_id != 1 */
400 if (!is_sparrow
&& (rev_id
!= 1))
401 W(RGF_PCIE_LOS_COUNTER_CTL
, BIT(8));
403 C(RGF_USER_CLKS_CTL_0
, BIT_USER_CLKS_RST_PWGD
);
404 wmb(); /* order is important here */
406 wil_dbg_misc(wil
, "Reset completed in %d ms\n", delay
);
414 void wil_mbox_ring_le2cpus(struct wil6210_mbox_ring
*r
)
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
);
423 static int wil_wait_for_fw_ready(struct wil6210_priv
*wil
)
425 ulong to
= msecs_to_jiffies(1000);
426 ulong left
= wait_for_completion_timeout(&wil
->wmi_ready
, to
);
428 wil_err(wil
, "Firmware not ready\n");
431 wil_info(wil
, "FW ready after %d ms. HW version 0x%08x\n",
432 jiffies_to_msecs(to
-left
), wil
->hw_version
);
438 * We reset all the structures, and we reset the UMAC.
439 * After calling this routine, you're expected to reload
442 int wil_reset(struct wil6210_priv
*wil
)
446 WARN_ON(!mutex_is_locked(&wil
->mutex
));
448 cancel_work_sync(&wil
->disconnect_worker
);
449 wil6210_disconnect(wil
, NULL
);
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
);
456 if (wil
->scan_request
) {
457 wil_dbg_misc(wil
, "Abort scan_request 0x%p\n",
459 del_timer_sync(&wil
->scan_timer
);
460 cfg80211_scan_done(wil
->scan_request
, true);
461 wil
->scan_request
= NULL
;
464 wil6210_disable_irq(wil
);
466 wmi_event_flush(wil
);
468 flush_workqueue(wil
->wmi_wq_conn
);
469 flush_workqueue(wil
->wmi_wq
);
471 /* TODO: put MAC in reset */
472 wil_target_reset(wil
);
476 /* init after reset */
477 wil
->pending_connect_cid
= -1;
478 reinit_completion(&wil
->wmi_ready
);
480 /* TODO: release MAC reset */
481 wil6210_enable_irq(wil
);
483 /* we just started MAC, wait for FW ready */
484 rc
= wil_wait_for_fw_ready(wil
);
489 void wil_fw_error_recovery(struct wil6210_priv
*wil
)
491 wil_dbg_misc(wil
, "starting fw error recovery\n");
492 schedule_work(&wil
->fw_error_worker
);
495 void wil_link_on(struct wil6210_priv
*wil
)
497 struct net_device
*ndev
= wil_to_ndev(wil
);
499 wil_dbg_misc(wil
, "%s()\n", __func__
);
501 netif_carrier_on(ndev
);
502 wil_dbg_misc(wil
, "netif_tx_wake : link on\n");
503 netif_tx_wake_all_queues(ndev
);
506 void wil_link_off(struct wil6210_priv
*wil
)
508 struct net_device
*ndev
= wil_to_ndev(wil
);
510 wil_dbg_misc(wil
, "%s()\n", __func__
);
512 netif_tx_stop_all_queues(ndev
);
513 wil_dbg_misc(wil
, "netif_tx_stop : link off\n");
514 netif_carrier_off(ndev
);
517 static int __wil_up(struct wil6210_priv
*wil
)
519 struct net_device
*ndev
= wil_to_ndev(wil
);
520 struct wireless_dev
*wdev
= wil
->wdev
;
523 WARN_ON(!mutex_is_locked(&wil
->mutex
));
529 /* Rx VRING. After MAC and beacon */
530 rc
= wil_rx_init(wil
);
534 switch (wdev
->iftype
) {
535 case NL80211_IFTYPE_STATION
:
536 wil_dbg_misc(wil
, "type: STATION\n");
537 ndev
->type
= ARPHRD_ETHER
;
539 case NL80211_IFTYPE_AP
:
540 wil_dbg_misc(wil
, "type: AP\n");
541 ndev
->type
= ARPHRD_ETHER
;
543 case NL80211_IFTYPE_P2P_CLIENT
:
544 wil_dbg_misc(wil
, "type: P2P_CLIENT\n");
545 ndev
->type
= ARPHRD_ETHER
;
547 case NL80211_IFTYPE_P2P_GO
:
548 wil_dbg_misc(wil
, "type: P2P_GO\n");
549 ndev
->type
= ARPHRD_ETHER
;
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 ? */
560 /* MAC address - pre-requisite for other commands */
561 wmi_set_mac_address(wil
, ndev
->dev_addr
);
564 napi_enable(&wil
->napi_rx
);
565 napi_enable(&wil
->napi_tx
);
566 set_bit(wil_status_napi_en
, &wil
->status
);
571 int wil_up(struct wil6210_priv
*wil
)
575 mutex_lock(&wil
->mutex
);
577 mutex_unlock(&wil
->mutex
);
582 static int __wil_down(struct wil6210_priv
*wil
)
584 WARN_ON(!mutex_is_locked(&wil
->mutex
));
586 clear_bit(wil_status_napi_en
, &wil
->status
);
587 napi_disable(&wil
->napi_rx
);
588 napi_disable(&wil
->napi_tx
);
590 if (wil
->scan_request
) {
591 wil_dbg_misc(wil
, "Abort scan_request 0x%p\n",
593 del_timer_sync(&wil
->scan_timer
);
594 cfg80211_scan_done(wil
->scan_request
, true);
595 wil
->scan_request
= NULL
;
598 wil6210_disconnect(wil
, NULL
);
604 int wil_down(struct wil6210_priv
*wil
)
608 mutex_lock(&wil
->mutex
);
609 rc
= __wil_down(wil
);
610 mutex_unlock(&wil
->mutex
);
615 int wil_find_cid(struct wil6210_priv
*wil
, const u8
*mac
)
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
)) {