自学教程：C++ wil_dbg_misc函数代码示例

/* 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;}