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

   1 /*
   2  * Copyright (c) 2012-2015 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 #include "wmi.h"
  24
  25 #define WAIT_FOR_DISCONNECT_TIMEOUT_MS 2000
  26 #define WAIT_FOR_DISCONNECT_INTERVAL_MS 10
  27
  28 bool no_fw_recovery;
  29 module_param(no_fw_recovery, bool, S_IRUGO | S_IWUSR);
  30 MODULE_PARM_DESC(no_fw_recovery, " disable automatic FW error recovery");
  31
  32 /* if not set via modparam, will be set to default value of 1/8 of
  33  * rx ring size during init flow
  34  */
  35 unsigned short rx_ring_overflow_thrsh = WIL6210_RX_HIGH_TRSH_INIT;
  36 module_param(rx_ring_overflow_thrsh, ushort, S_IRUGO);
  37 MODULE_PARM_DESC(rx_ring_overflow_thrsh,
  38                  " RX ring overflow threshold in descriptors.");
  39
  40 /* We allow allocation of more than 1 page buffers to support large packets.
  41  * It is suboptimal behavior performance wise in case MTU above page size.
  42  */
  43 unsigned int mtu_max = TXRX_BUF_LEN_DEFAULT - WIL_MAX_MPDU_OVERHEAD;
  44 static int mtu_max_set(const char *val, const struct kernel_param *kp)
  45 {
  46         int ret;
  47
  48         /* sets mtu_max directly. no need to restore it in case of
  49          * illegal value since we assume this will fail insmod
  50          */
  51         ret = param_set_uint(val, kp);
  52         if (ret)
  53                 return ret;
  54
  55         if (mtu_max < 68 || mtu_max > WIL_MAX_ETH_MTU)
  56                 ret = -EINVAL;
  57
  58         return ret;
  59 }
  60
  61 static struct kernel_param_ops mtu_max_ops = {
  62         .set = mtu_max_set,
  63         .get = param_get_uint,
  64 };
  65
  66 module_param_cb(mtu_max, &mtu_max_ops, &mtu_max, S_IRUGO);
  67 MODULE_PARM_DESC(mtu_max, " Max MTU value.");
  68
  69 static uint rx_ring_order = WIL_RX_RING_SIZE_ORDER_DEFAULT;
  70 static uint tx_ring_order = WIL_TX_RING_SIZE_ORDER_DEFAULT;
  71
  72 static int ring_order_set(const char *val, const struct kernel_param *kp)
  73 {
  74         int ret;
  75         uint x;
  76
  77         ret = kstrtouint(val, 0, &x);
  78         if (ret)
  79                 return ret;
  80
  81         if ((x < WIL_RING_SIZE_ORDER_MIN) || (x > WIL_RING_SIZE_ORDER_MAX))
  82                 return -EINVAL;
  83
  84         *((uint *)kp->arg) = x;
  85
  86         return 0;
  87 }
  88
  89 static struct kernel_param_ops ring_order_ops = {
  90         .set = ring_order_set,
  91         .get = param_get_uint,
  92 };
  93
  94 module_param_cb(rx_ring_order, &ring_order_ops, &rx_ring_order, S_IRUGO);
  95 MODULE_PARM_DESC(rx_ring_order, " Rx ring order; size = 1 << order");
  96 module_param_cb(tx_ring_order, &ring_order_ops, &tx_ring_order, S_IRUGO);
  97 MODULE_PARM_DESC(tx_ring_order, " Tx ring order; size = 1 << order");
  98
  99 #define RST_DELAY (20) /* msec, for loop in @wil_target_reset */
 100 #define RST_COUNT (1 + 1000/RST_DELAY) /* round up to be above 1 sec total */
 101
 102 /*
 103  * Due to a hardware issue,
 104  * one has to read/write to/from NIC in 32-bit chunks;
 105  * regular memcpy_fromio and siblings will
 106  * not work on 64-bit platform - it uses 64-bit transactions
 107  *
 108  * Force 32-bit transactions to enable NIC on 64-bit platforms
 109  *
 110  * To avoid byte swap on big endian host, __raw_{read|write}l
 111  * should be used - {read|write}l would swap bytes to provide
 112  * little endian on PCI value in host endianness.
 113  */
 114 void wil_memcpy_fromio_32(void *dst, const volatile void __iomem *src,
 115                           size_t count)
 116 {
 117         u32 *d = dst;
 118         const volatile u32 __iomem *s = src;
 119
 120         /* size_t is unsigned, if (count%4 != 0) it will wrap */
 121         for (count += 4; count > 4; count -= 4)
 122                 *d++ = __raw_readl(s++);
 123 }
 124
 125 void wil_memcpy_toio_32(volatile void __iomem *dst, const void *src,
 126                         size_t count)
 127 {
 128         volatile u32 __iomem *d = dst;
 129         const u32 *s = src;
 130
 131         for (count += 4; count > 4; count -= 4)
 132                 __raw_writel(*s++, d++);
 133 }
 134
 135 static void wil_disconnect_cid(struct wil6210_priv *wil, int cid,
 136                                u16 reason_code, bool from_event)
 137 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
 138 {
 139         uint i;
 140         struct net_device *ndev = wil_to_ndev(wil);
 141         struct wireless_dev *wdev = wil->wdev;
 142         struct wil_sta_info *sta = &wil->sta[cid];
 143
 144         might_sleep();
 145         wil_dbg_misc(wil, "%s(CID %d, status %d)\n", __func__, cid,
 146                      sta->status);
 147
 148         sta->data_port_open = false;
 149         if (sta->status != wil_sta_unused) {
 150                 if (!from_event)
 151                         wmi_disconnect_sta(wil, sta->addr, reason_code);
 152
 153                 switch (wdev->iftype) {
 154                 case NL80211_IFTYPE_AP:
 155                 case NL80211_IFTYPE_P2P_GO:
 156                         /* AP-like interface */
 157                         cfg80211_del_sta(ndev, sta->addr, GFP_KERNEL);
 158                         break;
 159                 default:
 160                         break;
 161                 }
 162                 sta->status = wil_sta_unused;
 163         }
 164
 165         for (i = 0; i < WIL_STA_TID_NUM; i++) {
 166                 struct wil_tid_ampdu_rx *r;
 167
 168                 spin_lock_bh(&sta->tid_rx_lock);
 169
 170                 r = sta->tid_rx[i];
 171                 sta->tid_rx[i] = NULL;
 172                 wil_tid_ampdu_rx_free(wil, r);
 173
 174                 spin_unlock_bh(&sta->tid_rx_lock);
 175         }
 176         for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) {
 177                 if (wil->vring2cid_tid[i][0] == cid)
 178                         wil_vring_fini_tx(wil, i);
 179         }
 180         memset(&sta->stats, 0, sizeof(sta->stats));
 181 }
 182
 183 static void _wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
 184                                 u16 reason_code, bool from_event)
 185 {
 186         int cid = -ENOENT;
 187         struct net_device *ndev = wil_to_ndev(wil);
 188         struct wireless_dev *wdev = wil->wdev;
 189
 190         might_sleep();
 191         wil_dbg_misc(wil, "%s(bssid=%pM, reason=%d, ev%s)\n", __func__, bssid,
 192                      reason_code, from_event ? "+" : "-");
 193
 194         /* Cases are:
 195          * - disconnect single STA, still connected
 196          * - disconnect single STA, already disconnected
 197          * - disconnect all
 198          *
 199          * For "disconnect all", there are 2 options:
 200          * - bssid == NULL
 201          * - bssid is our MAC address
 202          */
 203         if (bssid && memcmp(ndev->dev_addr, bssid, ETH_ALEN)) {
 204                 cid = wil_find_cid(wil, bssid);
 205                 wil_dbg_misc(wil, "Disconnect %pM, CID=%d, reason=%d\n",
 206                              bssid, cid, reason_code);
 207                 if (cid >= 0) /* disconnect 1 peer */
 208                         wil_disconnect_cid(wil, cid, reason_code, from_event);
 209         } else { /* all */
 210                 wil_dbg_misc(wil, "Disconnect all\n");
 211                 for (cid = 0; cid < WIL6210_MAX_CID; cid++)
 212                         wil_disconnect_cid(wil, cid, reason_code, from_event);
 213         }
 214
 215         /* link state */
 216         switch (wdev->iftype) {
 217         case NL80211_IFTYPE_STATION:
 218         case NL80211_IFTYPE_P2P_CLIENT:
 219                 netif_tx_stop_all_queues(ndev);
 220                 netif_carrier_off(ndev);
 221
 222                 if (test_bit(wil_status_fwconnected, wil->status)) {
 223                         clear_bit(wil_status_fwconnected, wil->status);
 224                         cfg80211_disconnected(ndev, reason_code,
 225                                               NULL, 0, GFP_KERNEL);
 226                 } else if (test_bit(wil_status_fwconnecting, wil->status)) {
 227                         cfg80211_connect_result(ndev, bssid, NULL, 0, NULL, 0,
 228                                                 WLAN_STATUS_UNSPECIFIED_FAILURE,
 229                                                 GFP_KERNEL);
 230                 }
 231                 clear_bit(wil_status_fwconnecting, wil->status);
 232                 break;
 233         default:
 234                 break;
 235         }
 236 }
 237
 238 static void wil_disconnect_worker(struct work_struct *work)
 239 {
 240         struct wil6210_priv *wil = container_of(work,
 241                         struct wil6210_priv, disconnect_worker);
 242
 243         mutex_lock(&wil->mutex);
 244         _wil6210_disconnect(wil, NULL, WLAN_REASON_UNSPECIFIED, false);
 245         mutex_unlock(&wil->mutex);
 246 }
 247
 248 static void wil_connect_timer_fn(ulong x)
 249 {
 250         struct wil6210_priv *wil = (void *)x;
 251
 252         wil_dbg_misc(wil, "Connect timeout\n");
 253
 254         /* reschedule to thread context - disconnect won't
 255          * run from atomic context
 256          */
 257         schedule_work(&wil->disconnect_worker);
 258 }
 259
 260 static void wil_scan_timer_fn(ulong x)
 261 {
 262         struct wil6210_priv *wil = (void *)x;
 263
 264         clear_bit(wil_status_fwready, wil->status);
 265         wil_err(wil, "Scan timeout detected, start fw error recovery\n");
 266         wil->recovery_state = fw_recovery_pending;
 267         schedule_work(&wil->fw_error_worker);
 268 }
 269
 270 static int wil_wait_for_recovery(struct wil6210_priv *wil)
 271 {
 272         if (wait_event_interruptible(wil->wq, wil->recovery_state !=
 273                                      fw_recovery_pending)) {
 274                 wil_err(wil, "Interrupt, canceling recovery\n");
 275                 return -ERESTARTSYS;
 276         }
 277         if (wil->recovery_state != fw_recovery_running) {
 278                 wil_info(wil, "Recovery cancelled\n");
 279                 return -EINTR;
 280         }
 281         wil_info(wil, "Proceed with recovery\n");
 282         return 0;
 283 }
 284
 285 void wil_set_recovery_state(struct wil6210_priv *wil, int state)
 286 {
 287         wil_dbg_misc(wil, "%s(%d -> %d)\n", __func__,
 288                      wil->recovery_state, state);
 289
 290         wil->recovery_state = state;
 291         wake_up_interruptible(&wil->wq);
 292 }
 293
 294 static void wil_fw_error_worker(struct work_struct *work)
 295 {
 296         struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
 297                                                 fw_error_worker);
 298         struct wireless_dev *wdev = wil->wdev;
 299
 300         wil_dbg_misc(wil, "fw error worker\n");
 301
 302         if (!netif_running(wil_to_ndev(wil))) {
 303                 wil_info(wil, "No recovery - interface is down\n");
 304                 return;
 305         }
 306
 307         /* increment @recovery_count if less then WIL6210_FW_RECOVERY_TO
 308          * passed since last recovery attempt
 309          */
 310         if (time_is_after_jiffies(wil->last_fw_recovery +
 311                                   WIL6210_FW_RECOVERY_TO))
 312                 wil->recovery_count++;
 313         else
 314                 wil->recovery_count = 1; /* fw was alive for a long time */
 315
 316         if (wil->recovery_count > WIL6210_FW_RECOVERY_RETRIES) {
 317                 wil_err(wil, "too many recovery attempts (%d), giving up\n",
 318                         wil->recovery_count);
 319                 return;
 320         }
 321
 322         wil->last_fw_recovery = jiffies;
 323
 324         mutex_lock(&wil->mutex);
 325         switch (wdev->iftype) {
 326         case NL80211_IFTYPE_STATION:
 327         case NL80211_IFTYPE_P2P_CLIENT:
 328         case NL80211_IFTYPE_MONITOR:
 329                 wil_info(wil, "fw error recovery requested (try %d)...\n",
 330                          wil->recovery_count);
 331                 if (!no_fw_recovery)
 332                         wil->recovery_state = fw_recovery_running;
 333                 if (0 != wil_wait_for_recovery(wil))
 334                         break;
 335
 336                 __wil_down(wil);
 337                 __wil_up(wil);
 338                 break;
 339         case NL80211_IFTYPE_AP:
 340         case NL80211_IFTYPE_P2P_GO:
 341                 wil_info(wil, "No recovery for AP-like interface\n");
 342                 /* recovery in these modes is done by upper layers */
 343                 break;
 344         default:
 345                 wil_err(wil, "No recovery - unknown interface type %d\n",
 346                         wdev->iftype);
 347                 break;
 348         }
 349         mutex_unlock(&wil->mutex);
 350 }
 351
 352 static int wil_find_free_vring(struct wil6210_priv *wil)
 353 {
 354         int i;
 355
 356         for (i = 0; i < WIL6210_MAX_TX_RINGS; i++) {
 357                 if (!wil->vring_tx[i].va)
 358                         return i;
 359         }
 360         return -EINVAL;
 361 }
 362
 363 static void wil_connect_worker(struct work_struct *work)
 364 {
 365         int rc;
 366         struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
 367                                                 connect_worker);
 368         struct net_device *ndev = wil_to_ndev(wil);
 369
 370         int cid = wil->pending_connect_cid;
 371         int ringid = wil_find_free_vring(wil);
 372
 373         if (cid < 0) {
 374                 wil_err(wil, "No connection pending\n");
 375                 return;
 376         }
 377
 378         wil_dbg_wmi(wil, "Configure for connection CID %d\n", cid);
 379
 380         rc = wil_vring_init_tx(wil, ringid, 1 << tx_ring_order, cid, 0);
 381         wil->pending_connect_cid = -1;
 382         if (rc == 0) {
 383                 wil->sta[cid].status = wil_sta_connected;
 384                 netif_tx_wake_all_queues(ndev);
 385         } else {
 386                 wil->sta[cid].status = wil_sta_unused;
 387         }
 388 }
 389
 390 int wil_priv_init(struct wil6210_priv *wil)
 391 {
 392         uint i;
 393
 394         wil_dbg_misc(wil, "%s()\n", __func__);
 395
 396         memset(wil->sta, 0, sizeof(wil->sta));
 397         for (i = 0; i < WIL6210_MAX_CID; i++)
 398                 spin_lock_init(&wil->sta[i].tid_rx_lock);
 399
 400         mutex_init(&wil->mutex);
 401         mutex_init(&wil->wmi_mutex);
 402         mutex_init(&wil->back_rx_mutex);
 403         mutex_init(&wil->back_tx_mutex);
 404         mutex_init(&wil->probe_client_mutex);
 405
 406         init_completion(&wil->wmi_ready);
 407         init_completion(&wil->wmi_call);
 408
 409         wil->pending_connect_cid = -1;
 410         setup_timer(&wil->connect_timer, wil_connect_timer_fn, (ulong)wil);
 411         setup_timer(&wil->scan_timer, wil_scan_timer_fn, (ulong)wil);
 412
 413         INIT_WORK(&wil->connect_worker, wil_connect_worker);
 414         INIT_WORK(&wil->disconnect_worker, wil_disconnect_worker);
 415         INIT_WORK(&wil->wmi_event_worker, wmi_event_worker);
 416         INIT_WORK(&wil->fw_error_worker, wil_fw_error_worker);
 417         INIT_WORK(&wil->back_rx_worker, wil_back_rx_worker);
 418         INIT_WORK(&wil->back_tx_worker, wil_back_tx_worker);
 419         INIT_WORK(&wil->probe_client_worker, wil_probe_client_worker);
 420
 421         INIT_LIST_HEAD(&wil->pending_wmi_ev);
 422         INIT_LIST_HEAD(&wil->back_rx_pending);
 423         INIT_LIST_HEAD(&wil->back_tx_pending);
 424         INIT_LIST_HEAD(&wil->probe_client_pending);
 425         spin_lock_init(&wil->wmi_ev_lock);
 426         init_waitqueue_head(&wil->wq);
 427
 428         wil->wmi_wq = create_singlethread_workqueue(WIL_NAME "_wmi");
 429         if (!wil->wmi_wq)
 430                 return -EAGAIN;
 431
 432         wil->wq_service = create_singlethread_workqueue(WIL_NAME "_service");
 433         if (!wil->wq_service)
 434                 goto out_wmi_wq;
 435
 436         wil->last_fw_recovery = jiffies;
 437         wil->tx_interframe_timeout = WIL6210_ITR_TX_INTERFRAME_TIMEOUT_DEFAULT;
 438         wil->rx_interframe_timeout = WIL6210_ITR_RX_INTERFRAME_TIMEOUT_DEFAULT;
 439         wil->tx_max_burst_duration = WIL6210_ITR_TX_MAX_BURST_DURATION_DEFAULT;
 440         wil->rx_max_burst_duration = WIL6210_ITR_RX_MAX_BURST_DURATION_DEFAULT;
 441
 442         if (rx_ring_overflow_thrsh == WIL6210_RX_HIGH_TRSH_INIT)
 443                 rx_ring_overflow_thrsh = WIL6210_RX_HIGH_TRSH_DEFAULT;
 444         return 0;
 445
 446 out_wmi_wq:
 447         destroy_workqueue(wil->wmi_wq);
 448
 449         return -EAGAIN;
 450 }
 451
 452 /**
 453  * wil6210_disconnect - disconnect one connection
 454  * @wil: driver context
 455  * @bssid: peer to disconnect, NULL to disconnect all
 456  * @reason_code: Reason code for the Disassociation frame
 457  * @from_event: whether is invoked from FW event handler
 458  *
 459  * Disconnect and release associated resources. If invoked not from the
 460  * FW event handler, issue WMI command(s) to trigger MAC disconnect.
 461  */
 462 void wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
 463                         u16 reason_code, bool from_event)
 464 {
 465         wil_dbg_misc(wil, "%s()\n", __func__);
 466
 467         del_timer_sync(&wil->connect_timer);
 468         _wil6210_disconnect(wil, bssid, reason_code, from_event);
 469 }
 470
 471 void wil_priv_deinit(struct wil6210_priv *wil)
 472 {
 473         wil_dbg_misc(wil, "%s()\n", __func__);
 474
 475         wil_set_recovery_state(wil, fw_recovery_idle);
 476         del_timer_sync(&wil->scan_timer);
 477         cancel_work_sync(&wil->disconnect_worker);
 478         cancel_work_sync(&wil->fw_error_worker);
 479         mutex_lock(&wil->mutex);
 480         wil6210_disconnect(wil, NULL, WLAN_REASON_DEAUTH_LEAVING, false);
 481         mutex_unlock(&wil->mutex);
 482         wmi_event_flush(wil);
 483         wil_back_rx_flush(wil);
 484         cancel_work_sync(&wil->back_rx_worker);
 485         wil_back_tx_flush(wil);
 486         cancel_work_sync(&wil->back_tx_worker);
 487         wil_probe_client_flush(wil);
 488         cancel_work_sync(&wil->probe_client_worker);
 489         destroy_workqueue(wil->wq_service);
 490         destroy_workqueue(wil->wmi_wq);
 491 }
 492
 493 /* target operations */
 494 /* register read */
 495 #define R(a) ioread32(wil->csr + HOSTADDR(a))
 496 /* register write. wmb() to make sure it is completed */
 497 #define W(a, v) do { iowrite32(v, wil->csr + HOSTADDR(a)); wmb(); } while (0)
 498 /* register set = read, OR, write */
 499 #define S(a, v) W(a, R(a) | v)
 500 /* register clear = read, AND with inverted, write */
 501 #define C(a, v) W(a, R(a) & ~v)
 502
 503 static inline void wil_halt_cpu(struct wil6210_priv *wil)
 504 {
 505         W(RGF_USER_USER_CPU_0, BIT_USER_USER_CPU_MAN_RST);
 506         W(RGF_USER_MAC_CPU_0,  BIT_USER_MAC_CPU_MAN_RST);
 507 }
 508
 509 static inline void wil_release_cpu(struct wil6210_priv *wil)
 510 {
 511         /* Start CPU */
 512         W(RGF_USER_USER_CPU_0, 1);
 513 }
 514
 515 static int wil_target_reset(struct wil6210_priv *wil)
 516 {
 517         int delay = 0;
 518         u32 x;
 519         bool is_reset_v2 = test_bit(hw_capability_reset_v2,
 520                                     wil->hw_capabilities);
 521
 522         wil_dbg_misc(wil, "Resetting \"%s\"...\n", wil->hw_name);
 523
 524         /* Clear MAC link up */
 525         S(RGF_HP_CTRL, BIT(15));
 526         S(RGF_USER_CLKS_CTL_SW_RST_MASK_0, BIT_HPAL_PERST_FROM_PAD);
 527         S(RGF_USER_CLKS_CTL_SW_RST_MASK_0, BIT_CAR_PERST_RST);
 528
 529         wil_halt_cpu(wil);
 530
 531         /* clear all boot loader "ready" bits */
 532         W(RGF_USER_BL + offsetof(struct RGF_BL, ready), 0);
 533         /* Clear Fw Download notification */
 534         C(RGF_USER_USAGE_6, BIT(0));
 535
 536         if (is_reset_v2) {
 537                 S(RGF_CAF_OSC_CONTROL, BIT_CAF_OSC_XTAL_EN);
 538                 /* XTAL stabilization should take about 3ms */
 539                 usleep_range(5000, 7000);
 540                 x = R(RGF_CAF_PLL_LOCK_STATUS);
 541                 if (!(x & BIT_CAF_OSC_DIG_XTAL_STABLE)) {
 542                         wil_err(wil, "Xtal stabilization timeout\n"
 543                                 "RGF_CAF_PLL_LOCK_STATUS = 0x%08x\n", x);
 544                         return -ETIME;
 545                 }
 546                 /* switch 10k to XTAL*/
 547                 C(RGF_USER_SPARROW_M_4, BIT_SPARROW_M_4_SEL_SLEEP_OR_REF);
 548                 /* 40 MHz */
 549                 C(RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_CAR_AHB_SW_SEL);
 550
 551                 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0, 0x3ff81f);
 552                 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_1, 0xf);
 553         }
 554
 555         W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0xFE000000);
 556         W(RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0x0000003F);
 557         W(RGF_USER_CLKS_CTL_SW_RST_VEC_3,
 558           is_reset_v2 ? 0x000000f0 : 0x00000170);
 559         W(RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0xFFE7FE00);
 560
 561         if (is_reset_v2) {
 562                 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_0, 0x0);
 563                 W(RGF_USER_CLKS_CTL_EXT_SW_RST_VEC_1, 0x0);
 564         }
 565
 566         W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0);
 567         W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0);
 568         W(RGF_USER_CLKS_CTL_SW_RST_VEC_1, 0);
 569         W(RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0);
 570
 571         if (is_reset_v2) {
 572                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0x00000003);
 573                 /* reset A2 PCIE AHB */
 574                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x00008000);
 575         } else {
 576                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_3, 0x00000001);
 577                 W(RGF_PCIE_LOS_COUNTER_CTL, BIT(6) | BIT(8));
 578                 W(RGF_USER_CLKS_CTL_SW_RST_VEC_2, 0x00008000);
 579         }
 580
 581         /* TODO: check order here!!! Erez code is different */
 582         W(RGF_USER_CLKS_CTL_SW_RST_VEC_0, 0);
 583
 584         /* wait until device ready. typical time is 20..80 msec */
 585         do {
 586                 msleep(RST_DELAY);
 587                 x = R(RGF_USER_BL + offsetof(struct RGF_BL, ready));
 588                 if (delay++ > RST_COUNT) {
 589                         wil_err(wil, "Reset not completed, bl.ready 0x%08x\n",
 590                                 x);
 591                         return -ETIME;
 592                 }
 593         } while (!(x & BIT_BL_READY));
 594
 595         if (!is_reset_v2)
 596                 W(RGF_PCIE_LOS_COUNTER_CTL, BIT(8));
 597
 598         C(RGF_USER_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD);
 599
 600         wil_dbg_misc(wil, "Reset completed in %d ms\n", delay * RST_DELAY);
 601         return 0;
 602 }
 603
 604 void wil_mbox_ring_le2cpus(struct wil6210_mbox_ring *r)
 605 {
 606         le32_to_cpus(&r->base);
 607         le16_to_cpus(&r->entry_size);
 608         le16_to_cpus(&r->size);
 609         le32_to_cpus(&r->tail);
 610         le32_to_cpus(&r->head);
 611 }
 612
 613 static int wil_get_bl_info(struct wil6210_priv *wil)
 614 {
 615         struct net_device *ndev = wil_to_ndev(wil);
 616         struct RGF_BL bl;
 617
 618         wil_memcpy_fromio_32(&bl, wil->csr + HOSTADDR(RGF_USER_BL), sizeof(bl));
 619         le32_to_cpus(&bl.ready);
 620         le32_to_cpus(&bl.version);
 621         le32_to_cpus(&bl.rf_type);
 622         le32_to_cpus(&bl.baseband_type);
 623
 624         if (!is_valid_ether_addr(bl.mac_address)) {
 625                 wil_err(wil, "BL: Invalid MAC %pM\n", bl.mac_address);
 626                 return -EINVAL;
 627         }
 628
 629         ether_addr_copy(ndev->perm_addr, bl.mac_address);
 630         if (!is_valid_ether_addr(ndev->dev_addr))
 631                 ether_addr_copy(ndev->dev_addr, bl.mac_address);
 632         wil_info(wil,
 633                  "Boot Loader: ver = %d MAC = %pM RF = 0x%08x bband = 0x%08x\n",
 634                  bl.version, bl.mac_address, bl.rf_type, bl.baseband_type);
 635
 636         return 0;
 637 }
 638
 639 static int wil_wait_for_fw_ready(struct wil6210_priv *wil)
 640 {
 641         ulong to = msecs_to_jiffies(1000);
 642         ulong left = wait_for_completion_timeout(&wil->wmi_ready, to);
 643
 644         if (0 == left) {
 645                 wil_err(wil, "Firmware not ready\n");
 646                 return -ETIME;
 647         } else {
 648                 wil_info(wil, "FW ready after %d ms. HW version 0x%08x\n",
 649                          jiffies_to_msecs(to-left), wil->hw_version);
 650         }
 651         return 0;
 652 }
 653
 654 /*
 655  * We reset all the structures, and we reset the UMAC.
 656  * After calling this routine, you're expected to reload
 657  * the firmware.
 658  */
 659 int wil_reset(struct wil6210_priv *wil, bool load_fw)
 660 {
 661         int rc;
 662
 663         wil_dbg_misc(wil, "%s()\n", __func__);
 664
 665         if (wil->hw_version == HW_VER_UNKNOWN)
 666                 return -ENODEV;
 667
 668         WARN_ON(!mutex_is_locked(&wil->mutex));
 669         WARN_ON(test_bit(wil_status_napi_en, wil->status));
 670
 671         cancel_work_sync(&wil->disconnect_worker);
 672         wil6210_disconnect(wil, NULL, WLAN_REASON_DEAUTH_LEAVING, false);
 673
 674         /* prevent NAPI from being scheduled */
 675         bitmap_zero(wil->status, wil_status_last);
 676
 677         if (wil->scan_request) {
 678                 wil_dbg_misc(wil, "Abort scan_request 0x%p\n",
 679                              wil->scan_request);
 680                 del_timer_sync(&wil->scan_timer);
 681                 cfg80211_scan_done(wil->scan_request, true);
 682                 wil->scan_request = NULL;
 683         }
 684
 685         wil_mask_irq(wil);
 686
 687         wmi_event_flush(wil);
 688
 689         flush_workqueue(wil->wq_service);
 690         flush_workqueue(wil->wmi_wq);
 691
 692         rc = wil_target_reset(wil);
 693         wil_rx_fini(wil);
 694         if (rc)
 695                 return rc;
 696
 697         rc = wil_get_bl_info(wil);
 698         if (rc)
 699                 return rc;
 700
 701         if (load_fw) {
 702                 wil_info(wil, "Use firmware <%s> + board <%s>\n", WIL_FW_NAME,
 703                          WIL_FW2_NAME);
 704
 705                 wil_halt_cpu(wil);
 706                 /* Loading f/w from the file */
 707                 rc = wil_request_firmware(wil, WIL_FW_NAME);
 708                 if (rc)
 709                         return rc;
 710                 rc = wil_request_firmware(wil, WIL_FW2_NAME);
 711                 if (rc)
 712                         return rc;
 713
 714                 /* Mark FW as loaded from host */
 715                 S(RGF_USER_USAGE_6, 1);
 716
 717                 /* clear any interrupts which on-card-firmware
 718                  * may have set
 719                  */
 720                 wil6210_clear_irq(wil);
 721                 /* CAF_ICR - clear and mask */
 722                 /* it is W1C, clear by writing back same value */
 723                 S(RGF_CAF_ICR + offsetof(struct RGF_ICR, ICR), 0);
 724                 W(RGF_CAF_ICR + offsetof(struct RGF_ICR, IMV), ~0);
 725
 726                 wil_release_cpu(wil);
 727         }
 728
 729         /* init after reset */
 730         wil->pending_connect_cid = -1;
 731         reinit_completion(&wil->wmi_ready);
 732         reinit_completion(&wil->wmi_call);
 733
 734         if (load_fw) {
 735                 wil_configure_interrupt_moderation(wil);
 736                 wil_unmask_irq(wil);
 737
 738                 /* we just started MAC, wait for FW ready */
 739                 rc = wil_wait_for_fw_ready(wil);
 740         }
 741
 742         return rc;
 743 }
 744
 745 #undef R
 746 #undef W
 747 #undef S
 748 #undef C
 749
 750 void wil_fw_error_recovery(struct wil6210_priv *wil)
 751 {
 752         wil_dbg_misc(wil, "starting fw error recovery\n");
 753         wil->recovery_state = fw_recovery_pending;
 754         schedule_work(&wil->fw_error_worker);
 755 }
 756
 757 int __wil_up(struct wil6210_priv *wil)
 758 {
 759         struct net_device *ndev = wil_to_ndev(wil);
 760         struct wireless_dev *wdev = wil->wdev;
 761         int rc;
 762
 763         WARN_ON(!mutex_is_locked(&wil->mutex));
 764
 765         rc = wil_reset(wil, true);
 766         if (rc)
 767                 return rc;
 768
 769         /* Rx VRING. After MAC and beacon */
 770         rc = wil_rx_init(wil, 1 << rx_ring_order);
 771         if (rc)
 772                 return rc;
 773
 774         switch (wdev->iftype) {
 775         case NL80211_IFTYPE_STATION:
 776                 wil_dbg_misc(wil, "type: STATION\n");
 777                 ndev->type = ARPHRD_ETHER;
 778                 break;
 779         case NL80211_IFTYPE_AP:
 780                 wil_dbg_misc(wil, "type: AP\n");
 781                 ndev->type = ARPHRD_ETHER;
 782                 break;
 783         case NL80211_IFTYPE_P2P_CLIENT:
 784                 wil_dbg_misc(wil, "type: P2P_CLIENT\n");
 785                 ndev->type = ARPHRD_ETHER;
 786                 break;
 787         case NL80211_IFTYPE_P2P_GO:
 788                 wil_dbg_misc(wil, "type: P2P_GO\n");
 789                 ndev->type = ARPHRD_ETHER;
 790                 break;
 791         case NL80211_IFTYPE_MONITOR:
 792                 wil_dbg_misc(wil, "type: Monitor\n");
 793                 ndev->type = ARPHRD_IEEE80211_RADIOTAP;
 794                 /* ARPHRD_IEEE80211 or ARPHRD_IEEE80211_RADIOTAP ? */
 795                 break;
 796         default:
 797                 return -EOPNOTSUPP;
 798         }
 799
 800         /* MAC address - pre-requisite for other commands */
 801         wmi_set_mac_address(wil, ndev->dev_addr);
 802
 803         wil_dbg_misc(wil, "NAPI enable\n");
 804         napi_enable(&wil->napi_rx);
 805         napi_enable(&wil->napi_tx);
 806         set_bit(wil_status_napi_en, wil->status);
 807
 808         if (wil->platform_ops.bus_request)
 809                 wil->platform_ops.bus_request(wil->platform_handle,
 810                                               WIL_MAX_BUS_REQUEST_KBPS);
 811
 812         return 0;
 813 }
 814
 815 int wil_up(struct wil6210_priv *wil)
 816 {
 817         int rc;
 818
 819         wil_dbg_misc(wil, "%s()\n", __func__);
 820
 821         mutex_lock(&wil->mutex);
 822         rc = __wil_up(wil);
 823         mutex_unlock(&wil->mutex);
 824
 825         return rc;
 826 }
 827
 828 int __wil_down(struct wil6210_priv *wil)
 829 {
 830         int iter = WAIT_FOR_DISCONNECT_TIMEOUT_MS /
 831                         WAIT_FOR_DISCONNECT_INTERVAL_MS;
 832
 833         WARN_ON(!mutex_is_locked(&wil->mutex));
 834
 835         if (wil->platform_ops.bus_request)
 836                 wil->platform_ops.bus_request(wil->platform_handle, 0);
 837
 838         wil_disable_irq(wil);
 839         if (test_and_clear_bit(wil_status_napi_en, wil->status)) {
 840                 napi_disable(&wil->napi_rx);
 841                 napi_disable(&wil->napi_tx);
 842                 wil_dbg_misc(wil, "NAPI disable\n");
 843         }
 844         wil_enable_irq(wil);
 845
 846         if (wil->scan_request) {
 847                 wil_dbg_misc(wil, "Abort scan_request 0x%p\n",
 848                              wil->scan_request);
 849                 del_timer_sync(&wil->scan_timer);
 850                 cfg80211_scan_done(wil->scan_request, true);
 851                 wil->scan_request = NULL;
 852         }
 853
 854         if (test_bit(wil_status_fwconnected, wil->status) ||
 855             test_bit(wil_status_fwconnecting, wil->status))
 856                 wmi_send(wil, WMI_DISCONNECT_CMDID, NULL, 0);
 857
 858         /* make sure wil is idle (not connected) */
 859         mutex_unlock(&wil->mutex);
 860         while (iter--) {
 861                 int idle = !test_bit(wil_status_fwconnected, wil->status) &&
 862                            !test_bit(wil_status_fwconnecting, wil->status);
 863                 if (idle)
 864                         break;
 865                 msleep(WAIT_FOR_DISCONNECT_INTERVAL_MS);
 866         }
 867         mutex_lock(&wil->mutex);
 868
 869         if (!iter)
 870                 wil_err(wil, "timeout waiting for idle FW/HW\n");
 871
 872         wil_reset(wil, false);
 873
 874         return 0;
 875 }
 876
 877 int wil_down(struct wil6210_priv *wil)
 878 {
 879         int rc;
 880
 881         wil_dbg_misc(wil, "%s()\n", __func__);
 882
 883         wil_set_recovery_state(wil, fw_recovery_idle);
 884         mutex_lock(&wil->mutex);
 885         rc = __wil_down(wil);
 886         mutex_unlock(&wil->mutex);
 887
 888         return rc;
 889 }
 890
 891 int wil_find_cid(struct wil6210_priv *wil, const u8 *mac)
 892 {
 893         int i;
 894         int rc = -ENOENT;
 895
 896         for (i = 0; i < ARRAY_SIZE(wil->sta); i++) {
 897                 if ((wil->sta[i].status != wil_sta_unused) &&
 898                     ether_addr_equal(wil->sta[i].addr, mac)) {
 899                         rc = i;
 900                         break;
 901                 }
 902         }
 903
 904         return rc;
 905 }