/* Bus ops */ static int wil_if_pcie_enable(struct wil6210_priv *wil) { struct pci_dev *pdev = wil->pdev; int rc; pci_set_master(pdev); /* * how many MSI interrupts to request? */ switch (use_msi) { case 3: case 1: case 0: break; default: wil_err(wil, "Invalid use_msi=%d, default to 1\n", use_msi); use_msi = 1; } wil->n_msi = use_msi; if (wil->n_msi) { wil_dbg_misc(wil, "Setup %d MSI interrupts\n", use_msi); rc = pci_enable_msi_block(pdev, wil->n_msi); if (rc && (wil->n_msi == 3)) { wil_err(wil, "3 MSI mode failed, try 1 MSI\n"); wil->n_msi = 1; rc = pci_enable_msi_block(pdev, wil->n_msi); } if (rc) { wil_err(wil, "pci_enable_msi failed, use INTx\n"); wil->n_msi = 0; } } else { wil_dbg_misc(wil, "MSI interrupts disabled, use INTx\n"); } rc = wil6210_init_irq(wil, pdev->irq); if (rc) goto stop_master; /* need reset here to obtain MAC */ rc = wil_reset(wil); if (debug_fw) rc = 0; if (rc) goto release_irq; return 0; release_irq: wil6210_fini_irq(wil, pdev->irq); /* safe to call if no MSI */ pci_disable_msi(pdev); stop_master: pci_clear_master(pdev); return rc; }
void wil_link_off(struct wil6210_priv *wil) { struct net_device *ndev = wil_to_ndev(wil); wil_dbg_misc(wil, "%s()\n", __func__); netif_tx_stop_all_queues(ndev); wil_dbg_misc(wil, "netif_tx_stop : link off\n"); netif_carrier_off(ndev); }
static void wil_vring_free(struct wil6210_priv *wil, struct vring *vring, int tx) { struct device *dev = wil_to_dev(wil); size_t sz = vring->size * sizeof(vring->va[0]); if (tx) { int vring_index = vring - wil->vring_tx; wil_dbg_misc(wil, "free Tx vring %d [%d] 0x%p:%pad 0x%p\n", vring_index, vring->size, vring->va, &vring->pa, vring->ctx); } else { wil_dbg_misc(wil, "free Rx vring [%d] 0x%p:%pad 0x%p\n", vring->size, vring->va, &vring->pa, vring->ctx); } while (!wil_vring_is_empty(vring)) { dma_addr_t pa; u16 dmalen; struct wil_ctx *ctx; if (tx) { struct vring_tx_desc dd, *d = ⅆ volatile struct vring_tx_desc *_d = &vring->va[vring->swtail].tx; ctx = &vring->ctx[vring->swtail]; *d = *_d; wil_txdesc_unmap(dev, d, ctx); if (ctx->skb) dev_kfree_skb_any(ctx->skb); vring->swtail = wil_vring_next_tail(vring); } else { /* rx */ struct vring_rx_desc dd, *d = ⅆ volatile struct vring_rx_desc *_d = &vring->va[vring->swhead].rx; ctx = &vring->ctx[vring->swhead]; *d = *_d; pa = wil_desc_addr(&d->dma.addr); dmalen = le16_to_cpu(d->dma.length); dma_unmap_single(dev, pa, dmalen, DMA_FROM_DEVICE); kfree_skb(ctx->skb); wil_vring_advance_head(vring, 1); } } dma_free_coherent(dev, sz, (void *)vring->va, vring->pa); kfree(vring->ctx); vring->pa = 0; vring->va = NULL; vring->ctx = NULL; }
static void wil_print_crypto(struct wil6210_priv *wil, struct cfg80211_crypto_settings *c) { wil_dbg_misc(wil, "WPA versions: 0x%08x cipher group 0x%08x\n", c->wpa_versions, c->cipher_group); wil_dbg_misc(wil, "Pairwise ciphers [%d]\n", c->n_ciphers_pairwise); wil_dbg_misc(wil, "AKM suites [%d]\n", c->n_akm_suites); wil_dbg_misc(wil, "Control port : %d, eth_type 0x%04x no_encrypt %d\n", c->control_port, be16_to_cpu(c->control_port_ethertype), c->control_port_no_encrypt); }
static int __wil_up(struct wil6210_priv *wil) { struct net_device *ndev = wil_to_ndev(wil); struct wireless_dev *wdev = wil->wdev; int rc; WARN_ON(!mutex_is_locked(&wil->mutex)); rc = wil_reset(wil); if (rc) return rc; /* Rx VRING. After MAC and beacon */ rc = wil_rx_init(wil); if (rc) return rc; switch (wdev->iftype) { case NL80211_IFTYPE_STATION: wil_dbg_misc(wil, "type: STATION\n"); ndev->type = ARPHRD_ETHER; break; case NL80211_IFTYPE_AP: wil_dbg_misc(wil, "type: AP\n"); ndev->type = ARPHRD_ETHER; break; case NL80211_IFTYPE_P2P_CLIENT: wil_dbg_misc(wil, "type: P2P_CLIENT\n"); ndev->type = ARPHRD_ETHER; break; case NL80211_IFTYPE_P2P_GO: wil_dbg_misc(wil, "type: P2P_GO\n"); ndev->type = ARPHRD_ETHER; break; case NL80211_IFTYPE_MONITOR: wil_dbg_misc(wil, "type: Monitor\n"); ndev->type = ARPHRD_IEEE80211_RADIOTAP; /* ARPHRD_IEEE80211 or ARPHRD_IEEE80211_RADIOTAP ? */ break; default: return -EOPNOTSUPP; } /* MAC address - pre-requisite for other commands */ wmi_set_mac_address(wil, ndev->dev_addr); napi_enable(&wil->napi_rx); napi_enable(&wil->napi_tx); set_bit(wil_status_napi_en, &wil->status); return 0; }
/** * Read from required position up to the end of current descriptor, * depends on descriptor size configured during alloc request. */ ssize_t wil_pmc_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) { struct wil6210_priv *wil = filp->private_data; struct pmc_ctx *pmc = &wil->pmc; size_t retval = 0; unsigned long long idx; loff_t offset; size_t pmc_size = pmc->descriptor_size * pmc->num_descriptors; mutex_lock(&pmc->lock); if (!wil_is_pmc_allocated(pmc)) { wil_err(wil, "%s: error, pmc is not allocated!\n", __func__); pmc->last_cmd_status = -EPERM; mutex_unlock(&pmc->lock); return -EPERM; } wil_dbg_misc(wil, "%s: size %u, pos %lld\n", __func__, (unsigned)count, *f_pos); pmc->last_cmd_status = 0; idx = *f_pos; do_div(idx, pmc->descriptor_size); offset = *f_pos - (idx * pmc->descriptor_size); if (*f_pos >= pmc_size) { wil_dbg_misc(wil, "%s: reached end of pmc buf: %lld >= %u\n", __func__, *f_pos, (unsigned)pmc_size); pmc->last_cmd_status = -ERANGE; goto out; } wil_dbg_misc(wil, "%s: read from pos %lld (descriptor %llu, offset %llu) %zu bytes\n", __func__, *f_pos, idx, offset, count); /* if no errors, return the copied byte count */ retval = simple_read_from_buffer(buf, count, &offset, pmc->descriptors[idx].va, pmc->descriptor_size); *f_pos += retval; out: mutex_unlock(&pmc->lock); return retval; }
/* Bus ops */ static int wil_if_pcie_enable(struct wil6210_priv *wil) { struct pci_dev *pdev = wil->pdev; int rc; /* on platforms with buggy ACPI, pdev->msi_enabled may be set to * allow pci_enable_device to work. This indicates INTx was not routed * and only MSI should be used */ int msi_only = pdev->msi_enabled; bool _use_msi = use_msi; wil_dbg_misc(wil, "%s()\n", __func__); pdev->msi_enabled = 0; pci_set_master(pdev); wil_dbg_misc(wil, "Setup %s interrupt\n", use_msi ? "MSI" : "INTx"); if (use_msi && pci_enable_msi(pdev)) { wil_err(wil, "pci_enable_msi failed, use INTx\n"); _use_msi = false; } if (!_use_msi && msi_only) { wil_err(wil, "Interrupt pin not routed, unable to use INTx\n"); rc = -ENODEV; goto stop_master; } rc = wil6210_init_irq(wil, pdev->irq, _use_msi); if (rc) goto stop_master; /* need reset here to obtain MAC */ mutex_lock(&wil->mutex); rc = wil_reset(wil, false); mutex_unlock(&wil->mutex); if (rc) goto release_irq; return 0; release_irq: wil6210_fini_irq(wil, pdev->irq); /* safe to call if no MSI */ pci_disable_msi(pdev); stop_master: pci_clear_master(pdev); return rc; }
int wil_p2p_listen(struct wil6210_priv *wil, struct wireless_dev *wdev, unsigned int duration, struct ieee80211_channel *chan, u64 *cookie) { struct wil_p2p_info *p2p = &wil->p2p; int rc; if (!chan) return -EINVAL; wil_dbg_misc(wil, "p2p_listen: duration %d\n", duration); mutex_lock(&wil->mutex); if (p2p->discovery_started) { wil_err(wil, "discovery already ongoing\n"); rc = -EBUSY; goto out; } memcpy(&p2p->listen_chan, chan, sizeof(*chan)); *cookie = ++p2p->cookie; p2p->listen_duration = duration; mutex_lock(&wil->p2p_wdev_mutex); if (wil->scan_request) { wil_dbg_misc(wil, "Delaying p2p listen until scan done\n"); p2p->pending_listen_wdev = wdev; p2p->discovery_started = 1; rc = 0; mutex_unlock(&wil->p2p_wdev_mutex); goto out; } mutex_unlock(&wil->p2p_wdev_mutex); rc = wil_p2p_start_listen(wil); if (rc) goto out; p2p->discovery_started = 1; wil->radio_wdev = wdev; cfg80211_ready_on_channel(wdev, *cookie, chan, duration, GFP_KERNEL); out: mutex_unlock(&wil->mutex); return rc; }
void wil_p2p_listen_expired(struct work_struct *work) { struct wil_p2p_info *p2p = container_of(work, struct wil_p2p_info, discovery_expired_work); struct wil6210_priv *wil = container_of(p2p, struct wil6210_priv, p2p); u8 started; wil_dbg_misc(wil, "p2p_listen_expired\n"); mutex_lock(&wil->mutex); started = wil_p2p_stop_discovery(wil); mutex_unlock(&wil->mutex); if (started) { mutex_lock(&wil->p2p_wdev_mutex); cfg80211_remain_on_channel_expired(wil->radio_wdev, p2p->cookie, &p2p->listen_chan, GFP_KERNEL); wil->radio_wdev = wil->wdev; mutex_unlock(&wil->p2p_wdev_mutex); } }
static int wil_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request) { struct wil6210_priv *wil = wiphy_to_wil(wiphy); struct wireless_dev *wdev = wil->wdev; struct { struct wmi_start_scan_cmd cmd; u16 chnl[4]; } __packed cmd; uint i, n; int rc; if (wil->scan_request) { wil_err(wil, "Already scanning\n"); return -EAGAIN; } /* check we are client side */ switch (wdev->iftype) { case NL80211_IFTYPE_STATION: case NL80211_IFTYPE_P2P_CLIENT: break; default: return -EOPNOTSUPP; } /* FW don't support scan after connection attempt */ if (test_bit(wil_status_dontscan, &wil->status)) { wil_err(wil, "Can't scan now\n"); return -EBUSY; } wil->scan_request = request; mod_timer(&wil->scan_timer, jiffies + WIL6210_SCAN_TO); memset(&cmd, 0, sizeof(cmd)); cmd.cmd.num_channels = 0; n = min(request->n_channels, 4U); for (i = 0; i < n; i++) { int ch = request->channels[i]->hw_value; if (ch == 0) { wil_err(wil, "Scan requested for unknown frequency %dMhz\n", request->channels[i]->center_freq); continue; } /* 0-based channel indexes */ cmd.cmd.channel_list[cmd.cmd.num_channels++].channel = ch - 1; wil_dbg_misc(wil, "Scan for ch %d : %d MHz\n", ch, request->channels[i]->center_freq); } rc = wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) + cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0])); if (rc) wil->scan_request = NULL; return rc; }
static void wil_disconnect_cid(struct wil6210_priv *wil, int cid) { uint i; struct net_device *ndev = wil_to_ndev(wil); struct wireless_dev *wdev = wil->wdev; struct wil_sta_info *sta = &wil->sta[cid]; wil_dbg_misc(wil, "%s(CID %d, status %d)\n", __func__, cid, sta->status); sta->data_port_open = false; if (sta->status != wil_sta_unused) { wmi_disconnect_sta(wil, sta->addr, WLAN_REASON_DEAUTH_LEAVING); switch (wdev->iftype) { case NL80211_IFTYPE_AP: case NL80211_IFTYPE_P2P_GO: /* AP-like interface */ cfg80211_del_sta(ndev, sta->addr, GFP_KERNEL); break; default: break; } sta->status = wil_sta_unused; } for (i = 0; i < WIL_STA_TID_NUM; i++) { struct wil_tid_ampdu_rx *r = sta->tid_rx[i]; sta->tid_rx[i] = NULL; wil_tid_ampdu_rx_free(wil, r); } for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) { if (wil->vring2cid_tid[i][0] == cid) wil_vring_fini_tx(wil, i); } memset(&sta->stats, 0, sizeof(sta->stats)); }
int wil_priv_init(struct wil6210_priv *wil) { wil_dbg_misc(wil, "%s()\n", __func__); mutex_init(&wil->mutex); mutex_init(&wil->wmi_mutex); init_completion(&wil->wmi_ready); wil->pending_connect_cid = -1; setup_timer(&wil->connect_timer, wil_connect_timer_fn, (ulong)wil); INIT_WORK(&wil->connect_worker, wil_connect_worker); INIT_WORK(&wil->disconnect_worker, wil_disconnect_worker); INIT_WORK(&wil->wmi_event_worker, wmi_event_worker); INIT_LIST_HEAD(&wil->pending_wmi_ev); spin_lock_init(&wil->wmi_ev_lock); wil->wmi_wq = create_singlethread_workqueue(WIL_NAME"_wmi"); if (!wil->wmi_wq) return -EAGAIN; wil->wmi_wq_conn = create_singlethread_workqueue(WIL_NAME"_connect"); if (!wil->wmi_wq_conn) { destroy_workqueue(wil->wmi_wq); return -EAGAIN; } return 0; }
static void _wil6210_disconnect(struct wil6210_priv *wil, void *bssid) { uint i; struct net_device *ndev = wil_to_ndev(wil); struct wireless_dev *wdev = wil->wdev; wil_dbg_misc(wil, "%s()\n", __func__); wil_link_off(wil); clear_bit(wil_status_fwconnected, &wil->status); switch (wdev->sme_state) { case CFG80211_SME_CONNECTED: cfg80211_disconnected(ndev, WLAN_STATUS_UNSPECIFIED_FAILURE, NULL, 0, GFP_KERNEL); break; case CFG80211_SME_CONNECTING: cfg80211_connect_result(ndev, bssid, NULL, 0, NULL, 0, WLAN_STATUS_UNSPECIFIED_FAILURE, GFP_KERNEL); break; default: break; } for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) wil_vring_fini_tx(wil, i); clear_bit(wil_status_dontscan, &wil->status); }
static int wil_ethtoolops_get_coalesce(struct net_device *ndev, struct ethtool_coalesce *cp) { struct wil6210_priv *wil = ndev_to_wil(ndev); u32 tx_itr_en, tx_itr_val = 0; u32 rx_itr_en, rx_itr_val = 0; int ret; wil_dbg_misc(wil, "ethtoolops_get_coalesce\n"); ret = wil_pm_runtime_get(wil); if (ret < 0) return ret; tx_itr_en = wil_r(wil, RGF_DMA_ITR_TX_CNT_CTL); if (tx_itr_en & BIT_DMA_ITR_TX_CNT_CTL_EN) tx_itr_val = wil_r(wil, RGF_DMA_ITR_TX_CNT_TRSH); rx_itr_en = wil_r(wil, RGF_DMA_ITR_RX_CNT_CTL); if (rx_itr_en & BIT_DMA_ITR_RX_CNT_CTL_EN) rx_itr_val = wil_r(wil, RGF_DMA_ITR_RX_CNT_TRSH); wil_pm_runtime_put(wil); cp->tx_coalesce_usecs = tx_itr_val; cp->rx_coalesce_usecs = rx_itr_val; return 0; }
/** * Status of the last operation requested via debugfs: alloc/free/read. * 0 - success or negative errno */ int wil_pmc_last_cmd_status(struct wil6210_priv *wil) { wil_dbg_misc(wil, "%s: status %d\n", __func__, wil->pmc.last_cmd_status); return wil->pmc.last_cmd_status; }
static void wil_pcie_remove(struct pci_dev *pdev) { struct wil6210_priv *wil = pci_get_drvdata(pdev); void __iomem *csr = wil->csr; wil_dbg_misc(wil, "%s()\n", __func__); #ifdef CONFIG_PM #ifdef CONFIG_PM_SLEEP unregister_pm_notifier(&wil->pm_notify); #endif /* CONFIG_PM_SLEEP */ #endif /* CONFIG_PM */ wil6210_debugfs_remove(wil); rtnl_lock(); wil_p2p_wdev_free(wil); rtnl_unlock(); wil_if_remove(wil); wil_if_pcie_disable(wil); pci_iounmap(pdev, csr); pci_release_region(pdev, 0); pci_disable_device(pdev); if (wil->platform_ops.uninit) wil->platform_ops.uninit(wil->platform_handle); wil_if_free(wil); }
void wil_p2p_search_expired(struct work_struct *work) { struct wil_p2p_info *p2p = container_of(work, struct wil_p2p_info, discovery_expired_work); struct wil6210_priv *wil = container_of(p2p, struct wil6210_priv, p2p); u8 started; wil_dbg_misc(wil, "%s()\n", __func__); mutex_lock(&wil->mutex); started = wil_p2p_stop_discovery(wil); mutex_unlock(&wil->mutex); if (started) { struct cfg80211_scan_info info = { .aborted = false, }; mutex_lock(&wil->p2p_wdev_mutex); cfg80211_scan_done(wil->scan_request, &info); wil->scan_request = NULL; wil->radio_wdev = wil->wdev; mutex_unlock(&wil->p2p_wdev_mutex); } }
static int wil_stop(struct net_device *ndev) { struct wil6210_priv *wil = ndev_to_wil(ndev); wil_dbg_misc(wil, "%s()\n", __func__); return wil_down(wil); }
static void wil_ethtoolops_complete(struct net_device *ndev) { struct wil6210_priv *wil = ndev_to_wil(ndev); wil_dbg_misc(wil, "ethtoolops_complete\n"); mutex_unlock(&wil->mutex); }
void wil_p2p_discovery_timer_fn(struct timer_list *t) { struct wil6210_priv *wil = from_timer(wil, t, p2p.discovery_timer); wil_dbg_misc(wil, "p2p_discovery_timer_fn\n"); schedule_work(&wil->p2p.discovery_expired_work); }
void wil_p2p_discovery_timer_fn(ulong x) { struct wil6210_priv *wil = (void *)x; wil_dbg_misc(wil, "%s\n", __func__); schedule_work(&wil->p2p.discovery_expired_work); }
void wil_if_remove(struct wil6210_priv *wil) { struct net_device *ndev = wil_to_ndev(wil); wil_dbg_misc(wil, "%s()\n", __func__); unregister_netdev(ndev); }
void wil_link_on(struct wil6210_priv *wil) { struct net_device *ndev = wil_to_ndev(wil); wil_dbg_misc(wil, "%s()\n", __func__); netif_carrier_on(ndev); netif_tx_wake_all_queues(ndev); }
int wil_p2p_listen(struct wil6210_priv *wil, unsigned int duration, struct ieee80211_channel *chan, u64 *cookie) { struct wil_p2p_info *p2p = &wil->p2p; u8 channel = P2P_DMG_SOCIAL_CHANNEL; int rc; if (!chan) return -EINVAL; channel = chan->hw_value; wil_dbg_misc(wil, "%s: duration %d\n", __func__, duration); mutex_lock(&wil->mutex); if (p2p->discovery_started) { wil_err(wil, "%s: discovery already ongoing\n", __func__); rc = -EBUSY; goto out; } rc = wmi_p2p_cfg(wil, channel, P2P_DEFAULT_BI); if (rc) { wil_err(wil, "%s: wmi_p2p_cfg failed\n", __func__); goto out; } rc = wmi_set_ssid(wil, strlen(P2P_WILDCARD_SSID), P2P_WILDCARD_SSID); if (rc) { wil_err(wil, "%s: wmi_set_ssid failed\n", __func__); goto out_stop; } rc = wmi_start_listen(wil); if (rc) { wil_err(wil, "%s: wmi_start_listen failed\n", __func__); goto out_stop; } memcpy(&p2p->listen_chan, chan, sizeof(*chan)); *cookie = ++p2p->cookie; p2p->discovery_started = 1; INIT_WORK(&p2p->discovery_expired_work, wil_p2p_listen_expired); mod_timer(&p2p->discovery_timer, jiffies + msecs_to_jiffies(duration)); out_stop: if (rc) wmi_stop_discovery(wil); out: mutex_unlock(&wil->mutex); return rc; }
static int wil_ethtoolops_begin(struct net_device *ndev) { struct wil6210_priv *wil = ndev_to_wil(ndev); mutex_lock(&wil->mutex); wil_dbg_misc(wil, "ethtoolops_begin\n"); return 0; }
static int wil_do_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd) { struct wil6210_priv *wil = ndev_to_wil(ndev); int ret = wil_ioctl(wil, ifr->ifr_data, cmd); wil_dbg_misc(wil, "ioctl(0x%04x) -> %d\n", cmd, ret); return ret; }
static int wil_vring_alloc(struct wil6210_priv *wil, struct vring *vring) { struct device *dev = wil_to_dev(wil); size_t sz = vring->size * sizeof(vring->va[0]); uint i; wil_dbg_misc(wil, "%s()\n", __func__); BUILD_BUG_ON(sizeof(vring->va[0]) != 32); vring->swhead = 0; vring->swtail = 0; vring->ctx = kcalloc(vring->size, sizeof(vring->ctx[0]), GFP_KERNEL); if (!vring->ctx) { vring->va = NULL; return -ENOMEM; } /* * vring->va should be aligned on its size rounded up to power of 2 * This is granted by the dma_alloc_coherent */ vring->va = dma_alloc_coherent(dev, sz, &vring->pa, GFP_KERNEL); if (!vring->va) { kfree(vring->ctx); vring->ctx = NULL; return -ENOMEM; } /* initially, all descriptors are SW owned * For Tx and Rx, ownership bit is at the same location, thus * we can use any */ for (i = 0; i < vring->size; i++) { volatile struct vring_tx_desc *_d = &vring->va[i].tx; _d->dma.status = TX_DMA_STATUS_DU; } wil_dbg_misc(wil, "vring[%d] 0x%p:%pad 0x%p\n", vring->size, vring->va, &vring->pa, vring->ctx); return 0; }
static void wil_connect_timer_fn(ulong x) { struct wil6210_priv *wil = (void *)x; wil_dbg_misc(wil, "Connect timeout\n"); /* reschedule to thread context - disconnect won't * run from atomic context */ schedule_work(&wil->disconnect_worker); }
static void _wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid) { int cid = -ENOENT; struct net_device *ndev = wil_to_ndev(wil); struct wireless_dev *wdev = wil->wdev; might_sleep(); if (bssid) { cid = wil_find_cid(wil, bssid); wil_dbg_misc(wil, "%s(%pM, CID %d)\n", __func__, bssid, cid); } else { wil_dbg_misc(wil, "%s(all)\n", __func__); } if (cid >= 0) /* disconnect 1 peer */ wil_disconnect_cid(wil, cid); else /* disconnect all */ for (cid = 0; cid < WIL6210_MAX_CID; cid++) wil_disconnect_cid(wil, cid); /* link state */ switch (wdev->iftype) { case NL80211_IFTYPE_STATION: case NL80211_IFTYPE_P2P_CLIENT: wil_link_off(wil); if (test_bit(wil_status_fwconnected, &wil->status)) { clear_bit(wil_status_fwconnected, &wil->status); cfg80211_disconnected(ndev, WLAN_STATUS_UNSPECIFIED_FAILURE, NULL, 0, GFP_KERNEL); } else if (test_bit(wil_status_fwconnecting, &wil->status)) { cfg80211_connect_result(ndev, bssid, NULL, 0, NULL, 0, WLAN_STATUS_UNSPECIFIED_FAILURE, GFP_KERNEL); } clear_bit(wil_status_fwconnecting, &wil->status); break; default: break; } }
static int wil_ethtoolops_set_coalesce(struct net_device *ndev, struct ethtool_coalesce *cp) { struct wil6210_priv *wil = ndev_to_wil(ndev); int ret; wil_dbg_misc(wil, "ethtoolops_set_coalesce: rx %d usec, tx %d usec\n", cp->rx_coalesce_usecs, cp->tx_coalesce_usecs); if (wil->wdev->iftype == NL80211_IFTYPE_MONITOR) { wil_dbg_misc(wil, "No IRQ coalescing in monitor mode\n"); return -EINVAL; } /* only @rx_coalesce_usecs and @tx_coalesce_usecs supported, * ignore other parameters */ if (cp->rx_coalesce_usecs > WIL6210_ITR_TRSH_MAX || cp->tx_coalesce_usecs > WIL6210_ITR_TRSH_MAX) goto out_bad; wil->tx_max_burst_duration = cp->tx_coalesce_usecs; wil->rx_max_burst_duration = cp->rx_coalesce_usecs; ret = wil_pm_runtime_get(wil); if (ret < 0) return ret; wil_configure_interrupt_moderation(wil); wil_pm_runtime_put(wil); return 0; out_bad: wil_dbg_misc(wil, "Unsupported coalescing params. Raw command:\n"); print_hex_dump_debug("DBG[MISC] coal ", DUMP_PREFIX_OFFSET, 16, 4, cp, sizeof(*cp), false); return -EINVAL; }