Lines Matching refs:wil
179 int wil_mem_access_lock(struct wil6210_priv *wil)
181 if (!down_read_trylock(&wil->mem_lock))
184 if (test_bit(wil_status_suspending, wil->status) ||
185 test_bit(wil_status_suspended, wil->status)) {
186 up_read(&wil->mem_lock);
193 void wil_mem_access_unlock(struct wil6210_priv *wil)
195 up_read(&wil->mem_lock);
198 static void wil_ring_fini_tx(struct wil6210_priv *wil, int id)
200 struct wil_ring *ring = &wil->ring_tx[id];
201 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[id];
203 lockdep_assert_held(&wil->mutex);
208 wil_dbg_misc(wil, "vring_fini_tx: id=%d\n", id);
223 if (test_bit(wil_status_napi_en, wil->status))
224 napi_synchronize(&wil->napi_tx);
226 wil->txrx_ops.ring_fini_tx(wil, ring);
229 static bool wil_vif_is_connected(struct wil6210_priv *wil, u8 mid)
233 for (i = 0; i < wil->max_assoc_sta; i++) {
234 if (wil->sta[i].mid == mid &&
235 wil->sta[i].status == wil_sta_connected)
247 struct wil6210_priv *wil = vif_to_wil(vif);
250 struct wil_sta_info *sta = &wil->sta[cid];
251 int min_ring_id = wil_get_min_tx_ring_id(wil);
254 wil_dbg_misc(wil,
260 wil_err(wil, "STA MID mismatch with VIF MID(%d)\n",
284 wil_tid_ampdu_rx_free(wil, r);
292 for (i = min_ring_id; i < ARRAY_SIZE(wil->ring_tx); i++) {
293 if (wil->ring2cid_tid[i][0] == cid)
294 wil_ring_fini_tx(wil, i);
304 struct wil6210_priv *wil = vif_to_wil(vif);
313 wil_info(wil, "disconnect_complete: bssid=%pM, reason=%d\n",
328 cid = wil_find_cid(wil, vif->mid, bssid);
329 wil_dbg_misc(wil,
332 if (wil_cid_valid(wil, cid)) /* disconnect 1 peer */
335 wil_dbg_misc(wil, "Disconnect complete all\n");
336 for (cid = 0; cid < wil->max_assoc_sta; cid++)
345 wil_update_net_queues_bh(wil, vif, NULL, true);
347 if (!wil_has_other_active_ifaces(wil, ndev, false, true))
348 wil6210_bus_request(wil, WIL_DEFAULT_BUS_REQUEST_KBPS);
351 atomic_dec(&wil->connected_vifs);
370 if (!wil_vif_is_connected(wil, vif->mid)) {
371 wil_update_net_queues_bh(wil, vif, NULL, true);
374 atomic_dec(&wil->connected_vifs);
376 wil_update_net_queues_bh(wil, vif, NULL, false);
387 struct wil6210_priv *wil = vif_to_wil(vif);
389 struct wil_sta_info *sta = &wil->sta[cid];
393 wil_dbg_misc(wil, "disconnect_cid: CID %d, MID %d, status %d\n",
400 wil_err(wil, "STA MID mismatch with VIF MID(%d)\n", vif->mid);
417 struct wil6210_priv *wil;
424 wil = vif_to_wil(vif);
428 wil_info(wil, "disconnect bssid=%pM, reason=%d\n", bssid, reason_code);
442 cid = wil_find_cid(wil, vif->mid, bssid);
443 wil_dbg_misc(wil, "Disconnect %pM, CID=%d, reason=%d\n",
445 if (wil_cid_valid(wil, cid)) /* disconnect 1 peer */
448 wil_dbg_misc(wil, "Disconnect all\n");
449 for (cid = 0; cid < wil->max_assoc_sta; cid++)
455 * wil->mutex while it is already held here
464 struct wil6210_priv *wil = vif_to_wil(vif);
482 rc = wmi_call(wil, WMI_DISCONNECT_CMDID, vif->mid, NULL, 0,
486 wil_err(wil, "disconnect error %d\n", rc);
490 wil_update_net_queues_bh(wil, vif, NULL, true);
497 static int wil_wait_for_recovery(struct wil6210_priv *wil)
499 if (wait_event_interruptible(wil->wq, wil->recovery_state !=
501 wil_err(wil, "Interrupt, canceling recovery\n");
504 if (wil->recovery_state != fw_recovery_running) {
505 wil_info(wil, "Recovery cancelled\n");
508 wil_info(wil, "Proceed with recovery\n");
512 void wil_set_recovery_state(struct wil6210_priv *wil, int state)
514 wil_dbg_misc(wil, "set_recovery_state: %d -> %d\n",
515 wil->recovery_state, state);
517 wil->recovery_state = state;
518 wake_up_interruptible(&wil->wq);
521 bool wil_is_recovery_blocked(struct wil6210_priv *wil)
523 return no_fw_recovery && (wil->recovery_state == fw_recovery_pending);
528 struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
530 struct net_device *ndev = wil->main_ndev;
533 wil_dbg_misc(wil, "fw error worker\n");
536 wil_info(wil, "No recovery - interface is down\n");
544 if (time_is_after_jiffies(wil->last_fw_recovery +
546 wil->recovery_count++;
548 wil->recovery_count = 1; /* fw was alive for a long time */
550 if (wil->recovery_count > WIL6210_FW_RECOVERY_RETRIES) {
551 wil_err(wil, "too many recovery attempts (%d), giving up\n",
552 wil->recovery_count);
556 wil->last_fw_recovery = jiffies;
558 wil_info(wil, "fw error recovery requested (try %d)...\n",
559 wil->recovery_count);
561 wil->recovery_state = fw_recovery_running;
562 if (wil_wait_for_recovery(wil) != 0)
566 mutex_lock(&wil->mutex);
576 __wil_down(wil);
577 __wil_up(wil);
584 __wil_down(wil);
585 __wil_up(wil);
586 mutex_unlock(&wil->mutex);
587 wil_cfg80211_ap_recovery(wil);
588 mutex_lock(&wil->mutex);
589 wil_info(wil, "... completed\n");
592 wil_err(wil, "No recovery - unknown interface type %d\n",
597 mutex_unlock(&wil->mutex);
601 static int wil_find_free_ring(struct wil6210_priv *wil)
604 int min_ring_id = wil_get_min_tx_ring_id(wil);
607 if (!wil->ring_tx[i].va)
615 struct wil6210_priv *wil = vif_to_wil(vif);
619 wil_err(wil, "No connection pending\n");
622 ringid = wil_find_free_ring(wil);
624 wil_err(wil, "No free vring found\n");
628 wil_dbg_wmi(wil, "Configure for connection CID %d MID %d ring %d\n",
631 rc = wil->txrx_ops.ring_init_tx(vif, ringid, 1 << tx_ring_order,
634 wil_err(wil, "init TX for CID %d MID %d vring %d failed\n",
643 struct wil6210_priv *wil = vif_to_wil(vif);
646 if (ri >= 0 && wil->ring_tx[ri].va)
649 ri = wil_find_free_ring(wil);
654 rc = wil->txrx_ops.ring_init_bcast(vif, ri, 1 << bcast_ring_order);
663 struct wil6210_priv *wil = vif_to_wil(vif);
670 wil_ring_fini_tx(wil, ri);
673 void wil_bcast_fini_all(struct wil6210_priv *wil)
678 for (i = 0; i < GET_MAX_VIFS(wil); i++) {
679 vif = wil->vifs[i];
685 int wil_priv_init(struct wil6210_priv *wil)
689 wil_dbg_misc(wil, "priv_init\n");
691 memset(wil->sta, 0, sizeof(wil->sta));
693 spin_lock_init(&wil->sta[i].tid_rx_lock);
694 wil->sta[i].mid = U8_MAX;
698 spin_lock_init(&wil->ring_tx_data[i].lock);
699 wil->ring2cid_tid[i][0] = WIL6210_MAX_CID;
702 mutex_init(&wil->mutex);
703 mutex_init(&wil->vif_mutex);
704 mutex_init(&wil->wmi_mutex);
705 mutex_init(&wil->halp.lock);
707 init_completion(&wil->wmi_ready);
708 init_completion(&wil->wmi_call);
709 init_completion(&wil->halp.comp);
711 INIT_WORK(&wil->wmi_event_worker, wmi_event_worker);
712 INIT_WORK(&wil->fw_error_worker, wil_fw_error_worker);
714 INIT_LIST_HEAD(&wil->pending_wmi_ev);
715 spin_lock_init(&wil->wmi_ev_lock);
716 spin_lock_init(&wil->net_queue_lock);
717 spin_lock_init(&wil->eap_lock);
719 init_waitqueue_head(&wil->wq);
720 init_rwsem(&wil->mem_lock);
722 wil->wmi_wq = create_singlethread_workqueue(WIL_NAME "_wmi");
723 if (!wil->wmi_wq)
726 wil->wq_service = create_singlethread_workqueue(WIL_NAME "_service");
727 if (!wil->wq_service)
730 wil->last_fw_recovery = jiffies;
731 wil->tx_interframe_timeout = WIL6210_ITR_TX_INTERFRAME_TIMEOUT_DEFAULT;
732 wil->rx_interframe_timeout = WIL6210_ITR_RX_INTERFRAME_TIMEOUT_DEFAULT;
733 wil->tx_max_burst_duration = WIL6210_ITR_TX_MAX_BURST_DURATION_DEFAULT;
734 wil->rx_max_burst_duration = WIL6210_ITR_RX_MAX_BURST_DURATION_DEFAULT;
739 wil->ps_profile = WMI_PS_PROFILE_TYPE_DEFAULT;
741 wil->wakeup_trigger = WMI_WAKEUP_TRIGGER_UCAST |
743 memset(&wil->suspend_stats, 0, sizeof(wil->suspend_stats));
744 wil->ring_idle_trsh = 16;
746 wil->reply_mid = U8_MAX;
747 wil->max_vifs = 1;
748 wil->max_assoc_sta = max_assoc_sta;
751 wil->num_rx_status_rings = WIL_DEFAULT_NUM_RX_STATUS_RINGS;
752 wil->tx_status_ring_order = WIL_TX_SRING_SIZE_ORDER_DEFAULT;
758 wil->rx_status_ring_order = WIL_RX_SRING_SIZE_ORDER_DEFAULT;
763 wil->rx_buff_id_count = WIL_RX_BUFF_ARR_SIZE_DEFAULT;
765 wil->amsdu_en = true;
770 destroy_workqueue(wil->wmi_wq);
775 void wil6210_bus_request(struct wil6210_priv *wil, u32 kbps)
777 if (wil->platform_ops.bus_request) {
778 wil->bus_request_kbps = kbps;
779 wil->platform_ops.bus_request(wil->platform_handle, kbps);
797 struct wil6210_priv *wil = vif_to_wil(vif);
799 wil_dbg_misc(wil, "disconnecting\n");
817 struct wil6210_priv *wil = vif_to_wil(vif);
819 wil_dbg_misc(wil, "got disconnect\n");
825 void wil_priv_deinit(struct wil6210_priv *wil)
827 wil_dbg_misc(wil, "priv_deinit\n");
829 wil_set_recovery_state(wil, fw_recovery_idle);
830 cancel_work_sync(&wil->fw_error_worker);
831 wmi_event_flush(wil);
832 destroy_workqueue(wil->wq_service);
833 destroy_workqueue(wil->wmi_wq);
834 kfree(wil->brd_info);
837 static void wil_shutdown_bl(struct wil6210_priv *wil)
841 wil_s(wil, RGF_USER_BL +
847 val = wil_r(wil, RGF_USER_BL +
851 wil_dbg_misc(wil, "BL is ready for halt\n");
855 wil_err(wil, "BL did not report ready for halt\n");
869 static void wil_freeze_bl(struct wil6210_priv *wil)
874 jal = wil_r(wil, wil->iccm_base + ivt3);
876 wil_dbg_misc(wil, "invalid IVT entry found, skipping\n");
883 saved = wil_r(wil, RGF_USER_USAGE_8);
884 wil_w(wil, RGF_USER_USAGE_8, saved | BIT_USER_PREVENT_DEEP_SLEEP);
888 wil_w(wil, wil->iccm_base + ivt3 + 4, ARC_me_imm32(ivt3));
892 upc = wil_r(wil, RGF_USER_CPU_PC);
894 wil_dbg_misc(wil, "BL freeze failed, PC=0x%08X\n", upc);
896 wil_w(wil, RGF_USER_USAGE_8, saved);
899 static void wil_bl_prepare_halt(struct wil6210_priv *wil)
910 tmp = wil_r(wil, RGF_USER_BL +
914 wil_dbg_misc(wil, "old BL, skipping halt preparation\n");
918 tmp = wil_r(wil, RGF_USER_BL +
924 wil_shutdown_bl(wil);
926 wil_freeze_bl(wil);
929 static inline void wil_halt_cpu(struct wil6210_priv *wil)
931 if (wil->hw_version >= HW_VER_TALYN_MB) {
932 wil_w(wil, RGF_USER_USER_CPU_0_TALYN_MB,
934 wil_w(wil, RGF_USER_MAC_CPU_0_TALYN_MB,
937 wil_w(wil, RGF_USER_USER_CPU_0, BIT_USER_USER_CPU_MAN_RST);
938 wil_w(wil, RGF_USER_MAC_CPU_0, BIT_USER_MAC_CPU_MAN_RST);
942 static inline void wil_release_cpu(struct wil6210_priv *wil)
945 if (wil->hw_version >= HW_VER_TALYN_MB)
946 wil_w(wil, RGF_USER_USER_CPU_0_TALYN_MB, 1);
948 wil_w(wil, RGF_USER_USER_CPU_0, 1);
951 static void wil_set_oob_mode(struct wil6210_priv *wil, u8 mode)
953 wil_info(wil, "oob_mode to %d\n", mode);
956 wil_c(wil, RGF_USER_USAGE_6, BIT_USER_OOB_MODE |
960 wil_c(wil, RGF_USER_USAGE_6, BIT_USER_OOB_R2_MODE);
961 wil_s(wil, RGF_USER_USAGE_6, BIT_USER_OOB_MODE);
964 wil_c(wil, RGF_USER_USAGE_6, BIT_USER_OOB_MODE);
965 wil_s(wil, RGF_USER_USAGE_6, BIT_USER_OOB_R2_MODE);
968 wil_err(wil, "invalid oob_mode: %d\n", mode);
972 static int wil_wait_device_ready(struct wil6210_priv *wil, int no_flash)
981 wil_dbg_misc(wil, "Reset completed\n");
985 x = wil_r(wil, RGF_USER_BL +
989 wil_dbg_misc(wil, "BL.ready 0x%08x => 0x%08x\n",
994 wil_err(wil, "Reset not completed, bl.ready 0x%08x\n",
1000 wil_dbg_misc(wil, "Reset completed in %d ms\n",
1007 static int wil_wait_device_ready_talyn_mb(struct wil6210_priv *wil)
1019 wil->boot_config = WIL_BOOT_ERR;
1028 otp_hw = wil_r(wil, RGF_USER_OTP_HW_RD_MACHINE_1);
1034 wil->boot_config = WIL_BOOT_VANILLA;
1039 wil->boot_config = WIL_BOOT_DEVELOPMENT;
1044 wil->boot_config = WIL_BOOT_PRODUCTION;
1055 wil->boot_config = WIL_BOOT_PRODUCTION;
1064 if (wil->boot_config == WIL_BOOT_ERR) {
1065 wil_err(wil,
1071 wil_dbg_misc(wil,
1073 delay * OTP_HW_DELAY, otp_hw, wil->boot_config);
1075 if (wil->boot_config == WIL_BOOT_VANILLA)
1085 otp_hw = wil_r(wil, RGF_USER_OTP_HW_RD_MACHINE_1);
1089 wil_err(wil, "TO waiting for hw_section_done\n");
1094 wil_dbg_misc(wil, "HW section done in %d ms\n", delay * RST_DELAY);
1096 otp_qc_secured = wil_r(wil, RGF_OTP_QC_SECURED);
1097 wil->secured_boot = otp_qc_secured & BIT_BOOT_FROM_ROM ? 1 : 0;
1098 wil_dbg_misc(wil, "secured boot is %sabled\n",
1099 wil->secured_boot ? "en" : "dis");
1102 wil_dbg_misc(wil, "Reset completed\n");
1107 static int wil_target_reset(struct wil6210_priv *wil, int no_flash)
1112 wil_dbg_misc(wil, "Resetting \"%s\"...\n", wil->hw_name);
1114 if (wil->hw_version < HW_VER_TALYN) {
1116 wil_s(wil, RGF_HP_CTRL, BIT(15));
1117 wil_s(wil, RGF_USER_CLKS_CTL_SW_RST_MASK_0,
1119 wil_s(wil, RGF_USER_CLKS_CTL_SW_RST_MASK_0, BIT_CAR_PERST_RST);
1122 wil_halt_cpu(wil);
1126 wil_w(wil, RGF_USER_BL +
1130 wil_w(wil, RGF_USER_BL +
1135 wil_c(wil, RGF_USER_USAGE_6, BIT(0));
1137 wil_s(wil, RGF_CAF_OSC_CONTROL, BIT_CAF_OSC_XTAL_EN);
1140 x = wil_r(wil, RGF_CAF_PLL_LOCK_STATUS);
1142 wil_err(wil, "Xtal stabilization timeout\n"
1147 wil_c(wil, RGF_USER_SPARROW_M_4, BIT_SPARROW_M_4_SEL_SLEEP_OR_REF);
1149 wil_c(wil, RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_CAR_AHB_SW_SEL);
1151 wil_w(wil, RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0, 0x3ff81f);
1152 wil_w(wil, RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_1, 0xf);
1154 if (wil->hw_version >= HW_VER_TALYN_MB) {
1155 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x7e000000);
1156 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0x0000003f);
1157 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0xc00000f0);
1158 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0xffe7fe00);
1160 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0xfe000000);
1161 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0x0000003f);
1162 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0x000000f0);
1163 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0xffe7fe00);
1166 wil_w(wil, RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0, 0x0);
1167 wil_w(wil, RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_1, 0x0);
1169 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0);
1170 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0);
1171 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0);
1172 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0);
1174 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0x00000003);
1176 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x00008000);
1178 wil_w(wil, RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0);
1180 if (wil->hw_version == HW_VER_TALYN_MB)
1181 rc = wil_wait_device_ready_talyn_mb(wil);
1183 rc = wil_wait_device_ready(wil, no_flash);
1187 wil_c(wil, RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD);
1190 wil_s(wil, RGF_DMA_OFUL_NID_0, BIT_DMA_OFUL_NID_0_RX_EXT_TR_EN |
1193 if (wil->hw_version < HW_VER_TALYN_MB && no_flash) {
1195 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME1, 0x60001);
1196 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME2, 0x20027);
1197 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME3, 0x1);
1198 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME4, 0x20027);
1199 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME5, 0x30003);
1200 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME6, 0x20002);
1201 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME7, 0x60001);
1202 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME8, 0x60001);
1203 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME9, 0x60001);
1204 wil_w(wil, RGF_USER_XPM_IFC_RD_TIME10, 0x60001);
1205 wil_w(wil, RGF_USER_XPM_RD_DOUT_SAMPLE_TIME, 0x57);
1211 static void wil_collect_fw_info(struct wil6210_priv *wil)
1213 struct wiphy *wiphy = wil_to_wiphy(wil);
1217 wil_refresh_fw_capabilities(wil);
1219 rc = wmi_get_mgmt_retry(wil, &retry_short);
1222 wil_dbg_misc(wil, "FW retry_short: %d\n", retry_short);
1226 void wil_refresh_fw_capabilities(struct wil6210_priv *wil)
1228 struct wiphy *wiphy = wil_to_wiphy(wil);
1231 wil->keep_radio_on_during_sleep =
1233 wil->platform_capa) &&
1234 test_bit(WMI_FW_CAPABILITY_D3_SUSPEND, wil->fw_capabilities);
1236 wil_info(wil, "keep_radio_on_during_sleep (%d)\n",
1237 wil->keep_radio_on_during_sleep);
1239 if (test_bit(WMI_FW_CAPABILITY_RSSI_REPORTING, wil->fw_capabilities))
1244 if (test_bit(WMI_FW_CAPABILITY_PNO, wil->fw_capabilities)) {
1252 if (test_bit(WMI_FW_CAPABILITY_TX_REQ_EXT, wil->fw_capabilities))
1255 if (wil->platform_ops.set_features) {
1257 wil->fw_capabilities) &&
1259 wil->platform_capa)) ?
1262 if (wil->n_msi == 3)
1265 wil->platform_ops.set_features(wil->platform_handle, features);
1269 wil->fw_capabilities)) {
1270 wil->max_agg_wsize = WIL_MAX_AGG_WSIZE_64;
1271 wil->max_ampdu_size = WIL_MAX_AMPDU_SIZE_128;
1273 wil->max_agg_wsize = WIL_MAX_AGG_WSIZE;
1274 wil->max_ampdu_size = WIL_MAX_AMPDU_SIZE;
1277 update_supported_bands(wil);
1290 void wil_get_board_file(struct wil6210_priv *wil, char *buf, size_t len)
1296 if (wil->board_file) {
1297 board_file = wil->board_file;
1302 if (strcmp(wil->wil_fw_name, wil_talyn_fw_name) == 0)
1311 static int wil_get_bl_info(struct wil6210_priv *wil)
1313 struct net_device *ndev = wil->main_ndev;
1314 struct wiphy *wiphy = wil_to_wiphy(wil);
1323 wil_memcpy_fromio_32(&bl, wil->csr + HOSTADDR(RGF_USER_BL),
1332 wil_info(wil,
1336 wil_info(wil, "Boot Loader build unknown for struct v0\n");
1343 wil_info(wil,
1348 wil_info(wil, "Boot Loader build %d.%d.%d.%d\n",
1354 wil_err(wil, "BL: Invalid MAC %pM\n", mac);
1364 wil_err(wil, "RF communication error 0x%04x",
1372 static void wil_bl_crash_info(struct wil6210_priv *wil, bool is_err)
1375 u32 bl_ver = wil_r(wil, RGF_USER_BL +
1382 bl_assert_code = wil_r(wil, RGF_USER_BL +
1385 bl_assert_blink = wil_r(wil, RGF_USER_BL +
1388 bl_magic_number = wil_r(wil, RGF_USER_BL +
1393 wil_err(wil,
1397 wil_dbg_misc(wil,
1403 static int wil_get_otp_info(struct wil6210_priv *wil)
1405 struct net_device *ndev = wil->main_ndev;
1406 struct wiphy *wiphy = wil_to_wiphy(wil);
1412 wil_memcpy_fromio_32(mac, wil->csr + HOSTADDR(mac_addr), sizeof(mac));
1415 wil_info(wil, "using OEM MAC %pM\n", mac);
1417 if (wil->hw_version >= HW_VER_TALYN_MB)
1422 wil_memcpy_fromio_32(mac, wil->csr + HOSTADDR(mac_addr),
1427 wil_err(wil, "Invalid MAC %pM\n", mac);
1439 static int wil_wait_for_fw_ready(struct wil6210_priv *wil)
1442 ulong left = wait_for_completion_timeout(&wil->wmi_ready, to);
1445 wil_err(wil, "Firmware not ready\n");
1448 wil_info(wil, "FW ready after %d ms. HW version 0x%08x\n",
1449 jiffies_to_msecs(to-left), wil->hw_version);
1456 struct wil6210_priv *wil = vif_to_wil(vif);
1462 lockdep_assert_held(&wil->vif_mutex);
1467 wil_dbg_misc(wil, "Abort scan_request 0x%p\n", vif->scan_request);
1469 mutex_unlock(&wil->vif_mutex);
1472 wait_event_interruptible_timeout(wil->wq, !vif->scan_request,
1476 mutex_lock(&wil->vif_mutex);
1483 void wil_abort_scan_all_vifs(struct wil6210_priv *wil, bool sync)
1487 lockdep_assert_held(&wil->vif_mutex);
1489 for (i = 0; i < GET_MAX_VIFS(wil); i++) {
1490 struct wil6210_vif *vif = wil->vifs[i];
1497 int wil_ps_update(struct wil6210_priv *wil, enum wmi_ps_profile_type ps_profile)
1501 if (!test_bit(WMI_FW_CAPABILITY_PS_CONFIG, wil->fw_capabilities)) {
1502 wil_err(wil, "set_power_mgmt not supported\n");
1506 rc = wmi_ps_dev_profile_cfg(wil, ps_profile);
1508 wil_err(wil, "wmi_ps_dev_profile_cfg failed (%d)\n", rc);
1510 wil->ps_profile = ps_profile;
1515 static void wil_pre_fw_config(struct wil6210_priv *wil)
1517 wil_clear_fw_log_addr(wil);
1519 wil_s(wil, RGF_USER_USAGE_6, 1);
1524 wil6210_clear_irq(wil);
1527 if (wil->hw_version < HW_VER_TALYN_MB) {
1528 wil_s(wil, RGF_CAF_ICR + offsetof(struct RGF_ICR, ICR), 0);
1529 wil_w(wil, RGF_CAF_ICR + offsetof(struct RGF_ICR, IMV), ~0);
1535 if (wil->hw_version < HW_VER_TALYN_MB)
1536 wil_s(wil, RGF_PAL_UNIT_ICR + offsetof(struct RGF_ICR, ICR),
1539 if (wil->fw_calib_result > 0) {
1540 __le32 val = cpu_to_le32(wil->fw_calib_result |
1542 wil_w(wil, RGF_USER_FW_CALIB_RESULT, (u32 __force)val);
1546 static int wil_restore_vifs(struct wil6210_priv *wil)
1553 for (i = 0; i < GET_MAX_VIFS(wil); i++) {
1554 vif = wil->vifs[i];
1561 rc = wmi_port_allocate(wil, vif->mid, ndev->dev_addr,
1564 wil_err(wil, "fail to restore VIF %d type %d, rc %d\n",
1579 void wil_clear_fw_log_addr(struct wil6210_priv *wil)
1582 wil_w(wil, RGF_USER_USAGE_1, 0);
1584 wil_w(wil, RGF_USER_USAGE_2, 0);
1585 wil_dbg_misc(wil, "Cleared FW and ucode log address");
1593 int wil_reset(struct wil6210_priv *wil, bool load_fw)
1600 wil_dbg_misc(wil, "reset\n");
1602 WARN_ON(!mutex_is_locked(&wil->mutex));
1603 WARN_ON(test_bit(wil_status_napi_en, wil->status));
1609 struct net_device *ndev = wil->main_ndev;
1616 if (wil->hw_version == HW_VER_UNKNOWN)
1619 if (test_bit(WIL_PLATFORM_CAPA_T_PWR_ON_0, wil->platform_capa) &&
1620 wil->hw_version < HW_VER_TALYN_MB) {
1621 wil_dbg_misc(wil, "Notify FW to set T_POWER_ON=0\n");
1622 wil_s(wil, RGF_USER_USAGE_8, BIT_USER_SUPPORT_T_POWER_ON_0);
1625 if (test_bit(WIL_PLATFORM_CAPA_EXT_CLK, wil->platform_capa)) {
1626 wil_dbg_misc(wil, "Notify FW on ext clock configuration\n");
1627 wil_s(wil, RGF_USER_USAGE_8, BIT_USER_EXT_CLK);
1630 if (wil->platform_ops.notify) {
1631 rc = wil->platform_ops.notify(wil->platform_handle,
1634 wil_err(wil, "PRE_RESET platform notify failed, rc %d\n",
1638 set_bit(wil_status_resetting, wil->status);
1639 mutex_lock(&wil->vif_mutex);
1640 wil_abort_scan_all_vifs(wil, false);
1641 mutex_unlock(&wil->vif_mutex);
1643 for (i = 0; i < GET_MAX_VIFS(wil); i++) {
1644 vif = wil->vifs[i];
1652 wil_bcast_fini_all(wil);
1655 wmi_led_cfg(wil, false);
1657 down_write(&wil->mem_lock);
1660 mutex_lock(&wil->wmi_mutex);
1661 if (test_bit(wil_status_suspending, wil->status))
1663 bitmap_and(wil->status, wil->status, &status_flags,
1665 wil_dbg_misc(wil, "wil->status (0x%lx)\n", *wil->status);
1666 mutex_unlock(&wil->wmi_mutex);
1668 wil_mask_irq(wil);
1670 wmi_event_flush(wil);
1672 flush_workqueue(wil->wq_service);
1673 flush_workqueue(wil->wmi_wq);
1675 no_flash = test_bit(hw_capa_no_flash, wil->hw_capa);
1677 wil_bl_crash_info(wil, false);
1678 wil_disable_irq(wil);
1679 rc = wil_target_reset(wil, no_flash);
1680 wil6210_clear_irq(wil);
1681 wil_enable_irq(wil);
1682 wil->txrx_ops.rx_fini(wil);
1683 wil->txrx_ops.tx_fini(wil);
1686 wil_bl_crash_info(wil, true);
1691 rc = wil_get_otp_info(wil);
1693 rc = wil_get_bl_info(wil);
1701 wil_set_oob_mode(wil, oob_mode);
1705 if (wil->secured_boot) {
1706 wil_err(wil, "secured boot is not supported\n");
1707 up_write(&wil->mem_lock);
1712 wil_get_board_file(wil, board_file, sizeof(board_file));
1713 wil_info(wil, "Use firmware <%s> + board <%s>\n",
1714 wil->wil_fw_name, board_file);
1717 wil_bl_prepare_halt(wil);
1719 wil_halt_cpu(wil);
1720 memset(wil->fw_version, 0, sizeof(wil->fw_version));
1722 rc = wil_request_firmware(wil, wil->wil_fw_name, true);
1725 if (wil->num_of_brd_entries)
1726 rc = wil_request_board(wil, board_file);
1728 rc = wil_request_firmware(wil, board_file, true);
1732 wil_pre_fw_config(wil);
1733 wil_release_cpu(wil);
1737 reinit_completion(&wil->wmi_ready);
1738 reinit_completion(&wil->wmi_call);
1739 reinit_completion(&wil->halp.comp);
1741 clear_bit(wil_status_resetting, wil->status);
1743 up_write(&wil->mem_lock);
1746 wil_unmask_irq(wil);
1749 rc = wil_wait_for_fw_ready(wil);
1754 rc = wmi_echo(wil);
1756 wil_err(wil, "wmi_echo failed, rc %d\n", rc);
1760 wil->txrx_ops.configure_interrupt_moderation(wil);
1765 if (wil->hw_version >= HW_VER_TALYN_MB)
1766 wil_s(wil, RGF_DMA_MISC_CTL,
1769 rc = wil_restore_vifs(wil);
1771 wil_err(wil, "failed to restore vifs, rc %d\n", rc);
1775 wil_collect_fw_info(wil);
1777 if (wil->ps_profile != WMI_PS_PROFILE_TYPE_DEFAULT)
1778 wil_ps_update(wil, wil->ps_profile);
1780 if (wil->platform_ops.notify) {
1781 rc = wil->platform_ops.notify(wil->platform_handle,
1784 wil_err(wil, "FW_RDY notify failed, rc %d\n",
1794 up_write(&wil->mem_lock);
1795 clear_bit(wil_status_resetting, wil->status);
1799 void wil_fw_error_recovery(struct wil6210_priv *wil)
1801 wil_dbg_misc(wil, "starting fw error recovery\n");
1803 if (test_bit(wil_status_resetting, wil->status)) {
1804 wil_info(wil, "Reset already in progress\n");
1808 wil->recovery_state = fw_recovery_pending;
1809 schedule_work(&wil->fw_error_worker);
1812 int __wil_up(struct wil6210_priv *wil)
1814 struct net_device *ndev = wil->main_ndev;
1818 WARN_ON(!mutex_is_locked(&wil->mutex));
1820 rc = wil_reset(wil, true);
1826 rx_ring_order = wil->hw_version < HW_VER_TALYN_MB ?
1830 rc = wil->txrx_ops.rx_init(wil, rx_ring_order);
1834 rc = wil->txrx_ops.tx_init(wil);
1840 wil_dbg_misc(wil, "type: STATION\n");
1844 wil_dbg_misc(wil, "type: AP\n");
1848 wil_dbg_misc(wil, "type: P2P_CLIENT\n");
1852 wil_dbg_misc(wil, "type: P2P_GO\n");
1856 wil_dbg_misc(wil, "type: Monitor\n");
1865 wmi_set_mac_address(wil, ndev->dev_addr);
1867 wil_dbg_misc(wil, "NAPI enable\n");
1868 napi_enable(&wil->napi_rx);
1869 napi_enable(&wil->napi_tx);
1870 set_bit(wil_status_napi_en, wil->status);
1872 wil6210_bus_request(wil, WIL_DEFAULT_BUS_REQUEST_KBPS);
1877 int wil_up(struct wil6210_priv *wil)
1881 wil_dbg_misc(wil, "up\n");
1883 mutex_lock(&wil->mutex);
1884 rc = __wil_up(wil);
1885 mutex_unlock(&wil->mutex);
1890 int __wil_down(struct wil6210_priv *wil)
1893 WARN_ON(!mutex_is_locked(&wil->mutex));
1895 set_bit(wil_status_resetting, wil->status);
1897 wil6210_bus_request(wil, 0);
1899 wil_disable_irq(wil);
1900 if (test_and_clear_bit(wil_status_napi_en, wil->status)) {
1901 napi_disable(&wil->napi_rx);
1902 napi_disable(&wil->napi_tx);
1903 wil_dbg_misc(wil, "NAPI disable\n");
1905 wil_enable_irq(wil);
1907 mutex_lock(&wil->vif_mutex);
1908 wil_p2p_stop_radio_operations(wil);
1909 wil_abort_scan_all_vifs(wil, false);
1910 mutex_unlock(&wil->vif_mutex);
1912 rc = wil_reset(wil, false);
1917 int wil_down(struct wil6210_priv *wil)
1921 wil_dbg_misc(wil, "down\n");
1923 wil_set_recovery_state(wil, fw_recovery_idle);
1924 mutex_lock(&wil->mutex);
1925 rc = __wil_down(wil);
1926 mutex_unlock(&wil->mutex);
1931 int wil_find_cid(struct wil6210_priv *wil, u8 mid, const u8 *mac)
1936 for (i = 0; i < wil->max_assoc_sta; i++) {
1937 if (wil->sta[i].mid == mid &&
1938 wil->sta[i].status != wil_sta_unused &&
1939 ether_addr_equal(wil->sta[i].addr, mac)) {
1948 void wil_halp_vote(struct wil6210_priv *wil)
1953 if (wil->hw_version >= HW_VER_TALYN_MB)
1956 mutex_lock(&wil->halp.lock);
1958 wil_dbg_irq(wil, "halp_vote: start, HALP ref_cnt (%d)\n",
1959 wil->halp.ref_cnt);
1961 if (++wil->halp.ref_cnt == 1) {
1962 reinit_completion(&wil->halp.comp);
1964 wil->halp.handle_icr = true;
1965 wil6210_set_halp(wil);
1966 rc = wait_for_completion_timeout(&wil->halp.comp, to_jiffies);
1968 wil_err(wil, "HALP vote timed out\n");
1970 wil->halp.handle_icr = false;
1971 wil6210_mask_halp(wil);
1973 wil_dbg_irq(wil,
1979 wil_dbg_irq(wil, "halp_vote: end, HALP ref_cnt (%d)\n",
1980 wil->halp.ref_cnt);
1982 mutex_unlock(&wil->halp.lock);
1985 void wil_halp_unvote(struct wil6210_priv *wil)
1987 if (wil->hw_version >= HW_VER_TALYN_MB)
1990 WARN_ON(wil->halp.ref_cnt == 0);
1992 mutex_lock(&wil->halp.lock);
1994 wil_dbg_irq(wil, "halp_unvote: start, HALP ref_cnt (%d)\n",
1995 wil->halp.ref_cnt);
1997 if (--wil->halp.ref_cnt == 0) {
1998 wil6210_clear_halp(wil);
1999 wil_dbg_irq(wil, "HALP unvote\n");
2002 wil_dbg_irq(wil, "halp_unvote:end, HALP ref_cnt (%d)\n",
2003 wil->halp.ref_cnt);
2005 mutex_unlock(&wil->halp.lock);
2008 void wil_init_txrx_ops(struct wil6210_priv *wil)
2010 if (wil->use_enhanced_dma_hw)
2011 wil_init_txrx_ops_edma(wil);
2013 wil_init_txrx_ops_legacy_dma(wil);