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

int r92su_register(struct r92su *r92su){	int err;	err = wiphy_register(r92su->wdev.wiphy);	if (err)		return err;	err = register_netdev(r92su->wdev.netdev);	if (err)		return err;	err = r92su_register_debugfs(r92su);	if (err)		return err;	err = r92su_register_wps_button(r92su);	if (err)		return err;	dev_info(wiphy_dev(r92su->wdev.wiphy),		 "Realtek RTL81XX rev %s, rf:%s is registered as '%s'./n",		 rev_to_string[r92su->chip_rev],		 rf_to_string(r92su->rf_type),		 wiphy_name(r92su->wdev.wiphy));	r92su_set_state(r92su, R92SU_STOP);	return 0;}

static void wil_wiphy_init(struct wiphy *wiphy){    /* TODO: set real value */    wiphy->max_scan_ssids = 10;    wiphy->max_num_pmkids = 0 /* TODO: */;    wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |                             BIT(NL80211_IFTYPE_AP) |                             BIT(NL80211_IFTYPE_MONITOR);    /* TODO: enable P2P when integrated with supplicant:     * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO)     */    wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |                    WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;    dev_warn(wiphy_dev(wiphy), "%s : flags = 0x%08x/n",             __func__, wiphy->flags);    wiphy->probe_resp_offload =        NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |        NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |        NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;    wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz;    /* TODO: figure this out */    wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;    wiphy->cipher_suites = wil_cipher_suites;    wiphy->n_cipher_suites = ARRAY_SIZE(wil_cipher_suites);    wiphy->mgmt_stypes = wil_mgmt_stypes;}

void ath9k_init_leds(struct ath9k_htc_priv *priv){	int ret;	if (AR_SREV_9287(priv->ah))		priv->ah->led_pin = ATH_LED_PIN_9287;	else if (AR_SREV_9271(priv->ah))		priv->ah->led_pin = ATH_LED_PIN_9271;	else if (AR_DEVID_7010(priv->ah))		priv->ah->led_pin = ATH_LED_PIN_7010;	else		priv->ah->led_pin = ATH_LED_PIN_DEF;	/* Configure gpio 1 for output */	ath9k_hw_cfg_output(priv->ah, priv->ah->led_pin,			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);	/* LED off, active low */	ath9k_hw_set_gpio(priv->ah, priv->ah->led_pin, 1);	snprintf(priv->led_name, sizeof(priv->led_name),		"ath9k_htc-%s", wiphy_name(priv->hw->wiphy));	priv->led_cdev.name = priv->led_name;	priv->led_cdev.brightness_set = ath9k_led_brightness;	ret = led_classdev_register(wiphy_dev(priv->hw->wiphy), &priv->led_cdev);	if (ret < 0)		return;	INIT_WORK(&priv->led_work, ath9k_led_work);	priv->led_registered = true;	return;}

static int carl9170_led_register_led(struct ar9170 *ar, int i, char *name,				     char *trigger){	int err;	snprintf(ar->leds[i].name, sizeof(ar->leds[i].name),		 "carl9170-%s::%s", wiphy_name(ar->hw->wiphy), name);	ar->leds[i].ar = ar;	ar->leds[i].l.name = ar->leds[i].name;	ar->leds[i].l.brightness_set = carl9170_led_set_brightness;	ar->leds[i].l.brightness = 0;	ar->leds[i].l.default_trigger = trigger;	err = led_classdev_register(wiphy_dev(ar->hw->wiphy),				    &ar->leds[i].l);	if (err) {		wiphy_err(ar->hw->wiphy, "failed to register %s LED (%d)./n",			ar->leds[i].name, err);	} else {		ar->leds[i].registered = true;	}	return err;}

/* * Register led class with the system */static int iwl_leds_register_led(struct iwl_priv *priv, struct iwl_led *led,				   enum led_type type, u8 set_led,				   char *trigger){	struct device *device = wiphy_dev(priv->hw->wiphy);	int ret;	led->led_dev.name = led->name;	led->led_dev.brightness_set = iwl_led_brightness_set;	led->led_dev.default_trigger = trigger;	led->priv = priv;	led->type = type;	ret = led_classdev_register(device, &led->led_dev);	if (ret) {		IWL_ERR(priv, "Error: failed to register led handler./n");		return ret;	}	led->registered = 1;	if (set_led && led->led_on)		led->led_on(priv, IWL_LED_LINK);	return 0;}

static int p54_register_led(struct p54_common *priv,			    unsigned int led_index,			    char *name, char *trigger){	struct p54_led_dev *led = &priv->leds[led_index];	int err;	if (led->registered)		return -EEXIST;	snprintf(led->name, sizeof(led->name), "p54-%s::%s",		 wiphy_name(priv->hw->wiphy), name);	led->hw_dev = priv->hw;	led->index = led_index;	led->led_dev.name = led->name;	led->led_dev.default_trigger = trigger;	led->led_dev.brightness_set = p54_led_brightness_set;	err = led_classdev_register(wiphy_dev(priv->hw->wiphy), &led->led_dev);	if (err)		wiphy_err(priv->hw->wiphy,			  "failed to register %s led./n", name);	else		led->registered = 1;	return err;}

void rt2x00rfkill_allocate(struct rt2x00_dev *rt2x00dev){	struct device *dev = wiphy_dev(rt2x00dev->hw->wiphy);	if (test_bit(RFKILL_STATE_ALLOCATED, &rt2x00dev->rfkill_state))		return;	rt2x00dev->rfkill = rfkill_allocate(dev, RFKILL_TYPE_WLAN);	if (!rt2x00dev->rfkill) {		ERROR(rt2x00dev, "Failed to allocate rfkill handler./n");		return;	}	__set_bit(RFKILL_STATE_ALLOCATED, &rt2x00dev->rfkill_state);	rt2x00dev->rfkill->name = rt2x00dev->ops->name;	rt2x00dev->rfkill->data = rt2x00dev;	rt2x00dev->rfkill->toggle_radio = rt2x00rfkill_toggle_radio;	if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags)) {		rt2x00dev->rfkill->get_state = rt2x00rfkill_get_state;		rt2x00dev->rfkill->state =			rt2x00dev->ops->lib->rfkill_poll(rt2x00dev) ?			    RFKILL_STATE_SOFT_BLOCKED : RFKILL_STATE_UNBLOCKED;	} else {		rt2x00dev->rfkill->state = RFKILL_STATE_UNBLOCKED;	}	INIT_DELAYED_WORK(&rt2x00dev->rfkill_work, rt2x00rfkill_poll);	return;}

void *wil_if_alloc(struct device *dev, void __iomem *csr){	struct net_device *ndev;	struct wireless_dev *wdev;	struct wil6210_priv *wil;	struct ieee80211_channel *ch;	int rc = 0;	wdev = wil_cfg80211_init(dev);	if (IS_ERR(wdev)) {		dev_err(dev, "wil_cfg80211_init failed/n");		return wdev;	}	wil = wdev_to_wil(wdev);	wil->csr = csr;	wil->wdev = wdev;	rc = wil_priv_init(wil);	if (rc) {		dev_err(dev, "wil_priv_init failed/n");		goto out_wdev;	}	wdev->iftype = NL80211_IFTYPE_STATION; /* TODO */	/* default monitor channel */	ch = wdev->wiphy->bands[IEEE80211_BAND_60GHZ]->channels;	cfg80211_chandef_create(&wdev->preset_chandef, ch, NL80211_CHAN_NO_HT);	ndev = alloc_netdev(0, "wlan%d", ether_setup);	if (!ndev) {		dev_err(dev, "alloc_netdev_mqs failed/n");		rc = -ENOMEM;		goto out_priv;	}	ndev->netdev_ops = &wil_netdev_ops;	ndev->ieee80211_ptr = wdev;	ndev->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;	ndev->features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM;	SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));	wdev->netdev = ndev;	netif_napi_add(ndev, &wil->napi_rx, wil6210_netdev_poll_rx,		       WIL6210_NAPI_BUDGET);	netif_napi_add(ndev, &wil->napi_tx, wil6210_netdev_poll_tx,		       WIL6210_NAPI_BUDGET);	wil_link_off(wil);	return wil; out_priv:	wil_priv_deinit(wil); out_wdev:	wil_wdev_free(wil);	return ERR_PTR(rc);}

u8 r92su_read8(struct r92su *r92su, const u32 address){	u8 data;	r92su_read_helper(r92su, address, &data, sizeof(data));	trace_r92su_ioread8(wiphy_dev(r92su->wdev.wiphy), address, data);	return data;}

void *iwm_if_alloc(int sizeof_bus, struct device *dev,		   struct iwm_if_ops *if_ops){	struct net_device *ndev;	struct wireless_dev *wdev;	struct iwm_priv *iwm;	int ret = 0;	wdev = iwm_wdev_alloc(sizeof_bus, dev);	if (IS_ERR(wdev))		return wdev;	iwm = wdev_to_iwm(wdev);	iwm->bus_ops = if_ops;	iwm->wdev = wdev;	ret = iwm_priv_init(iwm);	if (ret) {		dev_err(dev, "failed to init iwm_priv/n");		goto out_wdev;	}	wdev->iftype = iwm_mode_to_nl80211_iftype(iwm->conf.mode);	ndev = alloc_netdev_mq(0, "wlan%d", ether_setup, IWM_TX_QUEUES);	if (!ndev) {		dev_err(dev, "no memory for network device instance/n");		ret = -ENOMEM;		goto out_priv;	}	ndev->netdev_ops = &iwm_netdev_ops;	ndev->ieee80211_ptr = wdev;	SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));	wdev->netdev = ndev;	iwm->umac_profile = kmalloc(sizeof(struct iwm_umac_profile),				    GFP_KERNEL);	if (!iwm->umac_profile) {		dev_err(dev, "Couldn't alloc memory for profile/n");		ret = -ENOMEM;		goto out_profile;	}	iwm_init_default_profile(iwm, iwm->umac_profile);	return iwm; out_profile:	free_netdev(ndev); out_priv:	iwm_priv_deinit(iwm); out_wdev:	iwm_wdev_free(iwm);	return ERR_PTR(ret);}

void cfg80211_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info){	struct wireless_dev *wdev = dev->ieee80211_ptr;	strlcpy(info->driver, wiphy_dev(wdev->wiphy)->driver->name,		sizeof(info->driver));	strlcpy(info->version, init_utsname()->release, sizeof(info->version));	if (wdev->wiphy->fw_version[0])		strlcpy(info->fw_version, wdev->wiphy->fw_version,			sizeof(info->fw_version));	else		strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));	strlcpy(info->bus_info, dev_name(wiphy_dev(wdev->wiphy)),		sizeof(info->bus_info));}

void r92su_c2h_event(struct r92su *r92su, const struct h2cc2h *c2h){	unsigned int sequence = r92su->c2h_seq++;	trace_r92su_c2h(wiphy_dev(r92su->wdev.wiphy), c2h);	if (sequence != c2h->cmd_seq) {		R92SU_DBG(r92su, "received an c2h event out of sequence./n");		R92SU_DBG(r92su, "expected: %d, got %d/n", sequence,			  c2h->cmd_seq);		r92su->c2h_seq = c2h->cmd_seq + 1;	}	R92SU_DBG(r92su, "c2h event:%x len:%d/n",		  c2h->event, le16_to_cpu(c2h->len));	switch (c2h->event) {	case C2H_FWDBG_EVENT:		c2h_fwdbg_event(r92su, c2h);		break;	case C2H_SURVEY_EVENT:		c2h_survey_event(r92su, c2h);		break;	case C2H_SURVEY_DONE_EVENT:		c2h_survey_done_event(r92su, c2h);		break;	case C2H_JOIN_BSS_EVENT:		c2h_join_bss_event(r92su, c2h);		break;	case C2H_ADD_STA_EVENT:		c2h_add_sta_event(r92su, c2h);		break;	case C2H_DEL_STA_EVENT:		c2h_del_sta_event(r92su, c2h);		break;	case C2H_ATIM_DONE_EVENT:		c2h_atim_done_event(r92su, c2h);		break;	case C2H_REPORT_PWR_STATE_EVENT:		c2h_report_pwr_state_event(r92su, c2h);		break;	case C2H_WPS_PBC_EVENT:		c2h_wps_pbc_event(r92su, c2h);		break;	case C2H_ADDBA_REPORT_EVENT:		c2h_addba_report_event(r92su, c2h);		break;	default:		R92SU_ERR(r92su, "received invalid c2h event:%x/n", c2h->event);		print_hex_dump_bytes("C2H:", DUMP_PREFIX_OFFSET, c2h,				     le16_to_cpu(c2h->len) + sizeof(*c2h));		r92su_mark_dead(r92su);		break;	}}

u32 r92su_read32(struct r92su *r92su, const u32 address){	__le32 raw_data;	u32 data;	r92su_read_helper(r92su, address, &raw_data, sizeof(raw_data));	data = le32_to_cpu(raw_data);	trace_r92su_ioread32(wiphy_dev(r92su->wdev.wiphy), address, data);	return data;}

static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev){    struct device *device = wiphy_dev(rt2x00dev->hw->wiphy);    const struct firmware *fw;    char *fw_name;    int retval;    u16 crc;    /*     * Read correct firmware from harddisk.     */    fw_name = rt2x00dev->ops->lib->get_firmware_name(rt2x00dev);    if (!fw_name) {        ERROR(rt2x00dev,              "Invalid firmware filename./n"              "Please file bug report to %s./n", DRV_PROJECT);        return -EINVAL;    }    INFO(rt2x00dev, "Loading firmware file '%s'./n", fw_name);    retval = request_firmware(&fw, fw_name, device);    if (retval) {        ERROR(rt2x00dev, "Failed to request Firmware./n");        return retval;    }    if (!fw || !fw->size || !fw->data) {        ERROR(rt2x00dev, "Failed to read Firmware./n");        return -ENOENT;    }    crc = rt2x00dev->ops->lib->get_firmware_crc(fw->data, fw->size);    if (crc != (fw->data[fw->size - 2] << 8 | fw->data[fw->size - 1])) {        ERROR(rt2x00dev, "Firmware checksum error./n");        retval = -ENOENT;        goto exit;    }    INFO(rt2x00dev, "Firmware detected - version: %d.%d./n",         fw->data[fw->size - 4], fw->data[fw->size - 3]);    rt2x00dev->fw = fw;    return 0;exit:    release_firmware(fw);    return retval;}

struct ath6kl *ath6kl_core_alloc(struct device *sdev){	struct net_device *dev;	struct ath6kl *ar;	struct wireless_dev *wdev;	wdev = ath6kl_cfg80211_init(sdev);	if (!wdev) {		ath6kl_err("ath6kl_cfg80211_init failed/n");		return NULL;	}	ar = wdev_priv(wdev);	ar->dev = sdev;	ar->wdev = wdev;	wdev->iftype = NL80211_IFTYPE_STATION;	dev = alloc_netdev(0, "wlan%d", ether_setup);	if (!dev) {		ath6kl_err("no memory for network device instance/n");		ath6kl_cfg80211_deinit(ar);		return NULL;	}	dev->ieee80211_ptr = wdev;	SET_NETDEV_DEV(dev, wiphy_dev(wdev->wiphy));	wdev->netdev = dev;	ar->sme_state = SME_DISCONNECTED;	ar->auto_auth_stage = AUTH_IDLE;	init_netdev(dev);	ar->net_dev = dev;	set_bit(WLAN_ENABLED, &ar->flag);	ar->wlan_pwr_state = WLAN_POWER_STATE_ON;	spin_lock_init(&ar->lock);	ath6kl_init_control_info(ar);	init_waitqueue_head(&ar->event_wq);	sema_init(&ar->sem, 1);	clear_bit(DESTROY_IN_PROGRESS, &ar->flag);	INIT_LIST_HEAD(&ar->amsdu_rx_buffer_queue);	setup_timer(&ar->disconnect_timer, disconnect_timer_handler,		    (unsigned long) dev);	return ar;}

/*========================================================================Routine Description:	Register MAC80211 Module.Arguments:	pAdCB			- WLAN control block pointer	pDev			- Generic device interface	pNetDev			- Network deviceReturn Value:	NONENote:	pDev != pNetDev	#define SET_NETDEV_DEV(net, pdev)	((net)->dev.parent = (pdev))	Can not use pNetDev to replace pDev; Or kernel panic.========================================================================*/bool CFG80211_Register(	IN void 					*pAd,	IN struct device			*pDev,	IN struct net_device		*pNetDev){	CFG80211_CB *pCfg80211_CB = NULL;	CFG80211_BAND BandInfo;	/* allocate MAC80211 structure */	pCfg80211_CB = kmalloc(sizeof(CFG80211_CB), GFP_ATOMIC);	if (pCfg80211_CB == NULL)	{		DBGPRINT(RT_DEBUG_ERROR, ("80211> Allocate MAC80211 CB fail!/n"));		return false;	} /* End of if */	/* allocate wireless device */	RTMP_DRIVER_80211_BANDINFO_GET(pAd, &BandInfo);	pCfg80211_CB->pCfg80211_Wdev = /				CFG80211_WdevAlloc(pCfg80211_CB, &BandInfo, pAd, pDev);	if (pCfg80211_CB->pCfg80211_Wdev == NULL)	{		DBGPRINT(RT_DEBUG_ERROR, ("80211> Allocate Wdev fail!/n"));		kfree(pCfg80211_CB);		return false;	} /* End of if */	/* bind wireless device with net device */#ifdef CONFIG_STA_SUPPORT	/* default we are station mode */	pCfg80211_CB->pCfg80211_Wdev->iftype = NL80211_IFTYPE_STATION;#endif /* CONFIG_STA_SUPPORT */	pNetDev->ieee80211_ptr = pCfg80211_CB->pCfg80211_Wdev;	SET_NETDEV_DEV(pNetDev, wiphy_dev(pCfg80211_CB->pCfg80211_Wdev->wiphy));	pCfg80211_CB->pCfg80211_Wdev->netdev = pNetDev;#ifdef RFKILL_HW_SUPPORT	wiphy_rfkill_start_polling(pCfg80211_CB->pCfg80211_Wdev->wiphy);#endif /* RFKILL_HW_SUPPORT */	RTMP_DRIVER_80211_CB_SET(pAd, pCfg80211_CB);	CFG80211DBG(RT_DEBUG_ERROR, ("80211> CFG80211_Register/n"));	return true;} /* End of CFG80211_Register */

int r92su_h2c_submit(struct r92su *r92su, struct sk_buff *skb,		     const enum fw_h2c_cmd cmd){	unsigned long flags;	int err;	spin_lock_irqsave(&r92su->tx_cmd_lock, flags);	r92su_h2c_fill_header(r92su, skb, skb->len, cmd, true);	trace_r92su_h2c(wiphy_dev(r92su->wdev.wiphy),			(struct h2cc2h *) skb->data);	r92su_tx_fill_header(skb, skb->len, true, true);	err = r92su_usb_tx(r92su, skb, RTL8712_H2CCMD);	spin_unlock_irqrestore(&r92su->tx_cmd_lock, flags);	return err;}

static int r92su_alloc_netdev(struct r92su *r92su){	struct net_device *ndev;	/* The firmware/hardware does not support multiple interfaces.	 * So, we are fine with just a single netdevice.	 */	ndev = alloc_netdev_mqs(0, "wlan%d", NET_NAME_UNKNOWN,				r92su_if_setup, NUM_ACS, 1);	if (!ndev)		return -ENOMEM;	ndev->ml_priv = r92su;	r92su->wdev.netdev = ndev;	ndev->ieee80211_ptr = &r92su->wdev;	SET_NETDEV_DEV(ndev, wiphy_dev(r92su->wdev.wiphy));	return 0;}

static int ath_register_led(struct ath_softc *sc, struct ath_led *led,			    char *trigger){	int ret;	led->sc = sc;	led->led_cdev.name = led->name;	led->led_cdev.default_trigger = trigger;	led->led_cdev.brightness_set = ath_led_brightness;	ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &led->led_cdev);	if (ret)		ath_err(ath9k_hw_common(sc->sc_ah),			"Failed to register led:%s", led->name);	else		led->registered = 1;	return ret;}

int qtnf_core_net_attach(struct qtnf_wmac *mac, struct qtnf_vif *vif,			 const char *name, unsigned char name_assign_type,			 enum nl80211_iftype iftype){	struct wiphy *wiphy = priv_to_wiphy(mac);	struct net_device *dev;	void *qdev_vif;	int ret;	dev = alloc_netdev_mqs(sizeof(struct qtnf_vif *), name,			       name_assign_type, ether_setup, 1, 1);	if (!dev) {		memset(&vif->wdev, 0, sizeof(vif->wdev));		vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;		return -ENOMEM;	}	vif->netdev = dev;	dev->netdev_ops = &qtnf_netdev_ops;	dev->needs_free_netdev = true;	dev_net_set(dev, wiphy_net(wiphy));	dev->ieee80211_ptr = &vif->wdev;	dev->ieee80211_ptr->iftype = iftype;	ether_addr_copy(dev->dev_addr, vif->mac_addr);	SET_NETDEV_DEV(dev, wiphy_dev(wiphy));	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;	dev->watchdog_timeo = QTNF_DEF_WDOG_TIMEOUT;	dev->tx_queue_len = 100;	qdev_vif = netdev_priv(dev);	*((void **)qdev_vif) = vif;	SET_NETDEV_DEV(dev, mac->bus->dev);	ret = register_netdevice(dev);	if (ret) {		free_netdev(dev);		vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;	}	return ret;}

static int rt2x00leds_register_led(struct rt2x00_dev *rt2x00dev,				   struct rt2x00_led *led,				   const char *name){	struct device *device = wiphy_dev(rt2x00dev->hw->wiphy);	int retval;	led->led_dev.name = name;	led->led_dev.brightness = LED_OFF;	retval = led_classdev_register(device, &led->led_dev);	if (retval) {		ERROR(rt2x00dev, "Failed to register led handler./n");		return retval;	}	led->flags |= LED_REGISTERED;	return 0;}

void ath_init_leds(struct ath_softc *sc){	int ret;	if (AR_SREV_9100(sc->sc_ah))		return;	if (sc->sc_ah->led_pin < 0) {		if (AR_SREV_9287(sc->sc_ah))			sc->sc_ah->led_pin = ATH_LED_PIN_9287;		else if (AR_SREV_9485(sc->sc_ah))			sc->sc_ah->led_pin = ATH_LED_PIN_9485;		else if (AR_SREV_9300(sc->sc_ah))			sc->sc_ah->led_pin = ATH_LED_PIN_9300;		else if (AR_SREV_9462(sc->sc_ah))			sc->sc_ah->led_pin = ATH_LED_PIN_9462;		else			sc->sc_ah->led_pin = ATH_LED_PIN_DEF;	}	/* Configure gpio 1 for output */	ath9k_hw_cfg_output(sc->sc_ah, sc->sc_ah->led_pin,			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);	/* LED off, active low */	ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 1);	if (!led_blink)		sc->led_cdev.default_trigger =			ieee80211_get_radio_led_name(sc->hw);	snprintf(sc->led_name, sizeof(sc->led_name),		"ath9k-%s", wiphy_name(sc->hw->wiphy));	sc->led_cdev.name = sc->led_name;	sc->led_cdev.brightness_set = ath_led_brightness;	ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &sc->led_cdev);	if (ret < 0)		return;	sc->led_registered = true;}

void ath_init_leds(struct ath_softc *sc){	int ret;	if (AR_SREV_9100(sc->sc_ah))		return;	if (!led_blink)		sc->led_cdev.default_trigger =			ieee80211_get_radio_led_name(sc->hw);	snprintf(sc->led_name, sizeof(sc->led_name),		"ath9k-%s", wiphy_name(sc->hw->wiphy));	sc->led_cdev.name = sc->led_name;	sc->led_cdev.brightness_set = ath_led_brightness;	ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &sc->led_cdev);	if (ret < 0)		return;	sc->led_registered = true;}

static int wl1251_fetch_firmware(struct wl1251 *wl){	const struct firmware *fw;	struct device *dev = wiphy_dev(wl->hw->wiphy);	int ret;	ret = request_firmware(&fw, WL1251_FW_NAME, dev);	if (ret < 0) {		wl1251_error("could not get firmware: %d", ret);		return ret;	}	if (fw->size % 4) {		wl1251_error("firmware size is not multiple of 32 bits: %zu",			     fw->size);		ret = -EILSEQ;		goto out;	}	wl->fw_len = fw->size;	wl->fw = vmalloc(wl->fw_len);	if (!wl->fw) {		wl1251_error("could not allocate memory for the firmware");		ret = -ENOMEM;		goto out;	}	memcpy(wl->fw, fw->data, wl->fw_len);	ret = 0;out:	release_firmware(fw);	return ret;}

static int rt2x00rfkill_allocate(struct rt2x00_dev *rt2x00dev){	struct device *dev = wiphy_dev(rt2x00dev->hw->wiphy);	rt2x00dev->rfkill = rfkill_allocate(dev, RFKILL_TYPE_WLAN);	if (!rt2x00dev->rfkill)		return -ENOMEM;	rt2x00dev->rfkill->name = rt2x00dev->ops->name;	rt2x00dev->rfkill->data = rt2x00dev;	rt2x00dev->rfkill->toggle_radio = rt2x00rfkill_toggle_radio;	if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags)) {		rt2x00dev->rfkill->get_state = rt2x00rfkill_get_state;		rt2x00dev->rfkill->state =			rt2x00dev->ops->lib->rfkill_poll(rt2x00dev) ?			    RFKILL_STATE_SOFT_BLOCKED : RFKILL_STATE_UNBLOCKED;	} else {		rt2x00dev->rfkill->state = RFKILL_STATE_UNBLOCKED;	}	INIT_DELAYED_WORK(&rt2x00dev->rfkill_work, rt2x00rfkill_poll);	return 0;}

static int wl1251_fetch_nvs(struct wl1251 *wl){	const struct firmware *fw;	struct device *dev = wiphy_dev(wl->hw->wiphy);	int ret;	ret = request_firmware(&fw, WL1251_NVS_NAME, dev);	if (ret < 0) {		wl1251_error("could not get nvs file: %d", ret);		return ret;	}	if (fw->size % 4) {		wl1251_error("nvs size is not multiple of 32 bits: %zu",			     fw->size);		ret = -EILSEQ;		goto out;	}	wl->nvs_len = fw->size;	wl->nvs = kmemdup(fw->data, wl->nvs_len, GFP_KERNEL);	if (!wl->nvs) {		wl1251_error("could not allocate memory for the nvs file");		ret = -ENOMEM;		goto out;	}	ret = 0;out:	release_firmware(fw);	return ret;}

static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev){	struct device *device = wiphy_dev(rt2x00dev->hw->wiphy);	const struct firmware *fw;	char *fw_name;	int retval;	/*	 * Read correct firmware from harddisk.	 */	fw_name = rt2x00dev->ops->lib->get_firmware_name(rt2x00dev);	if (!fw_name) {		ERROR(rt2x00dev,		      "Invalid firmware filename./n"		      "Please file bug report to %s./n", DRV_PROJECT);		return -EINVAL;	}	INFO(rt2x00dev, "Loading firmware file '%s'./n", fw_name);	retval = request_firmware(&fw, fw_name, device);	if (retval) {		ERROR(rt2x00dev, "Failed to request Firmware./n");		return retval;	}	if (!fw || !fw->size || !fw->data) {		ERROR(rt2x00dev, "Failed to read Firmware./n");		release_firmware(fw);		return -ENOENT;	}	INFO(rt2x00dev, "Firmware detected - version: %d.%d./n",	     fw->data[fw->size - 4], fw->data[fw->size - 3]);	snprintf(rt2x00dev->hw->wiphy->fw_version,			sizeof(rt2x00dev->hw->wiphy->fw_version), "%d.%d",			fw->data[fw->size - 4], fw->data[fw->size - 3]);	retval = rt2x00dev->ops->lib->check_firmware(rt2x00dev, fw->data, fw->size);	switch (retval) {	case FW_OK:		break;	case FW_BAD_CRC:		ERROR(rt2x00dev, "Firmware checksum error./n");		goto exit;	case FW_BAD_LENGTH:		ERROR(rt2x00dev,		      "Invalid firmware file length (len=%zu)/n", fw->size);		goto exit;	case FW_BAD_VERSION:		ERROR(rt2x00dev,		      "Current firmware does not support detected chipset./n");		goto exit;	}	rt2x00dev->fw = fw;	return 0;exit:	release_firmware(fw);	return -ENOENT;}

//.........这里部分代码省略.........		/* allocation fail, exit */		DBGPRINT(RT_DEBUG_ERROR, ("Allocate network device fail (CFG80211).../n"));		return;	}	else	{		DBGPRINT(RT_DEBUG_TRACE, ("Register CFG80211 I/F (%s)/n", RTMP_OS_NETDEV_GET_DEVNAME(new_dev_p)));	}			new_dev_p->destructor =  free_netdev;	RTMP_OS_NETDEV_SET_PRIV(new_dev_p, pAd);	pNetDevOps->needProtcted = TRUE;	NdisMoveMemory(&pNetDevOps->devAddr[0], &pAd->CurrentAddress[0], MAC_ADDR_LEN);	//CFG_TODO	/* 	 		Bit1 of MAC address Byte0 is local administration bit 		and should be set to 1 in extended multiple BSSIDs'		Bit3~ of MAC address Byte0 is extended multiple BSSID index.	*/		if (pAd->chipCap.MBSSIDMode == MBSSID_MODE1)		pNetDevOps->devAddr[0] += 2; /* NEW BSSID */	else	{#ifdef P2P_ODD_MAC_ADJUST		if (pNetDevOps->devAddr[5] & 0x01 == 0x01)			pNetDevOps->devAddr[5] -= 1;		else#endif /* P2P_ODD_MAC_ADJUST */		pNetDevOps->devAddr[5] += FIRST_MBSSID;	}				switch (DevType)	{			case RT_CMD_80211_IFTYPE_MONITOR:			DBGPRINT(RT_DEBUG_ERROR, ("CFG80211 I/F Monitor Type/n"));						//RTMP_OS_NETDEV_SET_TYPE_MONITOR(new_dev_p);				break;#ifdef RT_CFG80211_P2P_SUPPORT		case RT_CMD_80211_IFTYPE_P2P_CLIENT:			pApCliEntry = &pAd->ApCfg.ApCliTab[MAIN_MBSSID];			wdev = &pApCliEntry->wdev;			wdev->wdev_type = WDEV_TYPE_STA;			wdev->func_dev = pApCliEntry;			wdev->sys_handle = (void *)pAd;			wdev->if_dev = new_dev_p;			wdev->tx_pkt_allowed = ApCliAllowToSendPacket;			RTMP_OS_NETDEV_SET_PRIV(new_dev_p, pAd);			RTMP_OS_NETDEV_SET_WDEV(new_dev_p, wdev);			if (rtmp_wdev_idx_reg(pAd, wdev) < 0) 			{				DBGPRINT(RT_DEBUG_ERROR, ("%s: Assign wdev idx for %s failed, free net device!/n",								__FUNCTION__,RTMP_OS_NETDEV_GET_DEVNAME(new_dev_p)));				RtmpOSNetDevFree(new_dev_p);				break;			}						/* init MAC address of virtual network interface */			COPY_MAC_ADDR(wdev->if_addr, pNetDevOps->devAddr);			break;		case RT_CMD_80211_IFTYPE_P2P_GO:			pNetDevOps->priv_flags = INT_P2P;			pAd->ApCfg.MBSSID[MAIN_MBSSID].MSSIDDev = NULL;			/* The Behivaor in SetBeacon Ops	*/			//pAd->ApCfg.MBSSID[MAIN_MBSSID].MSSIDDev = new_dev_p;			pAd->cfg80211_ctrl.isCfgInApMode = RT_CMD_80211_IFTYPE_AP;			COPY_MAC_ADDR(pAd->ApCfg.MBSSID[MAIN_MBSSID].wdev.if_addr, pNetDevOps->devAddr);			COPY_MAC_ADDR(pAd->ApCfg.MBSSID[MAIN_MBSSID].wdev.bssid, pNetDevOps->devAddr);			break;#endif /* RT_CFG80211_P2P_SUPPORT */		default:			DBGPRINT(RT_DEBUG_ERROR, ("Unknown CFG80211 I/F Type (%d)/n", DevType));	}	//CFG_TODO : should be move to VIF_CHG	if ((DevType == RT_CMD_80211_IFTYPE_P2P_CLIENT) ||	   (DevType == RT_CMD_80211_IFTYPE_P2P_GO))	{		COPY_MAC_ADDR(pAd->cfg80211_ctrl.P2PCurrentAddress, pNetDevOps->devAddr);	}		pWdev = kzalloc(sizeof(*pWdev), GFP_KERNEL);		new_dev_p->ieee80211_ptr = pWdev;	pWdev->wiphy = p80211CB->pCfg80211_Wdev->wiphy;	SET_NETDEV_DEV(new_dev_p, wiphy_dev(pWdev->wiphy));		pWdev->netdev = new_dev_p;	pWdev->iftype = DevType;			RtmpOSNetDevAttach(pAd->OpMode, new_dev_p, pNetDevOps);	AsicSetBssid(pAd, pAd->CurrentAddress); 			/* Record the pNetDevice to Cfg80211VifDevList */	RTMP_CFG80211_AddVifEntry(pAd, new_dev_p, DevType);	DBGPRINT(RT_DEBUG_TRACE, ("%s <---/n", __FUNCTION__));}

VOID RTMP_CFG80211_DummyP2pIf_Init(	IN VOID 		*pAdSrc){#define INF_CFG80211_DUMMY_P2P_NAME "p2p"	PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pAdSrc;	CFG80211_CB *p80211CB = pAd->pCfg80211_CB;	PCFG80211_CTRL cfg80211_ctrl = &pAd->cfg80211_ctrl;	RTMP_OS_NETDEV_OP_HOOK	netDevHook, *pNetDevOps;	PNET_DEV	new_dev_p;	UINT32 MC_RowID = 0, IoctlIF = 0, Inf = INT_P2P;	UINT preIfIndex = 0;	struct wireless_dev *pWdev;	DBGPRINT(RT_DEBUG_TRACE, (" %s =====> /n", __FUNCTION__));	if (cfg80211_ctrl->flg_cfg_dummy_p2p_init != FALSE)		return;#if RT_CFG80211_P2P_SUPPORT	cfg80211_ctrl->bP2pCliPmEnable = FALSE;	cfg80211_ctrl->bPreKeepSlient = FALSE;	cfg80211_ctrl->bKeepSlient = FALSE;	cfg80211_ctrl->NoAIndex = MAX_LEN_OF_MAC_TABLE;	cfg80211_ctrl->MyGOwcid = MAX_LEN_OF_MAC_TABLE;	cfg80211_ctrl->CTWindows=0;	/* CTWindows and OppPS parameter field */#endif /* RT_CFG80211_P2P_SUPPORT */		pNetDevOps=&netDevHook;	/* init operation functions and flags */	NdisZeroMemory(&netDevHook, sizeof(netDevHook));	netDevHook.open = CFG80211_DummyP2pIf_Open;	     /* device opem hook point */	netDevHook.stop = CFG80211_DummyP2pIf_Close;	     /* device close hook point */	netDevHook.xmit = CFG80211_DummyP2pIf_PacketSend;    /* hard transmit hook point */	netDevHook.ioctl = CFG80211_DummyP2pIf_Ioctl;	     /* ioctl hook point */			new_dev_p = RtmpOSNetDevCreate(MC_RowID, &IoctlIF, Inf, preIfIndex, sizeof(PRTMP_ADAPTER), INF_CFG80211_DUMMY_P2P_NAME);	if (new_dev_p == NULL)	{		/* allocation fail, exit */		DBGPRINT(RT_DEBUG_ERROR, ("Allocate network device fail (CFG80211: Dummy P2P IF).../n"));		return;	}	else	{		DBGPRINT(RT_DEBUG_TRACE, ("Register CFG80211 I/F (%s)/n", RTMP_OS_NETDEV_GET_DEVNAME(new_dev_p)));	}	RTMP_OS_NETDEV_SET_PRIV(new_dev_p, pAd);	NdisMoveMemory(&pNetDevOps->devAddr[0], &pAd->CurrentAddress[0], MAC_ADDR_LEN);	pNetDevOps->needProtcted = TRUE;		pWdev = kzalloc(sizeof(*pWdev), GFP_KERNEL);	if (unlikely(!pWdev)) 	{		DBGPRINT(RT_DEBUG_ERROR, ("Could not allocate wireless device/n"));		return;	}	new_dev_p->ieee80211_ptr = pWdev;	pWdev->wiphy = p80211CB->pCfg80211_Wdev->wiphy;	SET_NETDEV_DEV(new_dev_p, wiphy_dev(pWdev->wiphy));		pWdev->netdev = new_dev_p;	pWdev->iftype = RT_CMD_80211_IFTYPE_STATION;			RtmpOSNetDevAttach(pAd->OpMode, new_dev_p, pNetDevOps); 	cfg80211_ctrl->dummy_p2p_net_dev = new_dev_p;	cfg80211_ctrl->flg_cfg_dummy_p2p_init = TRUE;	DBGPRINT(RT_DEBUG_TRACE, (" %s <=====/n", __FUNCTION__));}

//.........这里部分代码省略.........		if (!wdev)			return ERR_PTR(-ENOMEM);		wdev->wiphy = wiphy;		priv->wdev = wdev;		wdev->iftype = NL80211_IFTYPE_STATION;		if (type == NL80211_IFTYPE_UNSPECIFIED)			priv->bss_mode = NL80211_IFTYPE_STATION;		else			priv->bss_mode = type;		priv->bss_type = MWIFIEX_BSS_TYPE_STA;		priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;		priv->bss_priority = MWIFIEX_BSS_ROLE_STA;		priv->bss_role = MWIFIEX_BSS_ROLE_STA;		priv->bss_num = 0;		break;	case NL80211_IFTYPE_AP:		priv = adapter->priv[MWIFIEX_BSS_TYPE_UAP];		if (priv->bss_mode) {			wiphy_err(wiphy, "Can't create multiple AP interfaces");			return ERR_PTR(-EINVAL);		}		wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);		if (!wdev)			return ERR_PTR(-ENOMEM);		priv->wdev = wdev;		wdev->wiphy = wiphy;		wdev->iftype = NL80211_IFTYPE_AP;		priv->bss_type = MWIFIEX_BSS_TYPE_UAP;		priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;		priv->bss_priority = MWIFIEX_BSS_ROLE_UAP;		priv->bss_role = MWIFIEX_BSS_ROLE_UAP;		priv->bss_started = 0;		priv->bss_num = 0;		priv->bss_mode = type;		break;	default:		wiphy_err(wiphy, "type not supported/n");		return ERR_PTR(-EINVAL);	}	dev = alloc_netdev_mq(sizeof(struct mwifiex_private *), name,			      ether_setup, 1);	if (!dev) {		wiphy_err(wiphy, "no memory available for netdevice/n");		priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;		return ERR_PTR(-ENOMEM);	}	mwifiex_init_priv_params(priv, dev);	priv->netdev = dev;	mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv);	if (adapter->config_bands & BAND_A)		mwifiex_setup_ht_caps(			&wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv);	dev_net_set(dev, wiphy_net(wiphy));	dev->ieee80211_ptr = priv->wdev;	dev->ieee80211_ptr->iftype = priv->bss_mode;	memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);	memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN);	SET_NETDEV_DEV(dev, wiphy_dev(wiphy));	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;	dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT;	dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN;	mdev_priv = netdev_priv(dev);	*((unsigned long *) mdev_priv) = (unsigned long) priv;	SET_NETDEV_DEV(dev, adapter->dev);	/* Register network device */	if (register_netdevice(dev)) {		wiphy_err(wiphy, "cannot register virtual network device/n");		free_netdev(dev);		priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;		return ERR_PTR(-EFAULT);	}	sema_init(&priv->async_sem, 1);	priv->scan_pending_on_block = false;	dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter/n", dev->name);#ifdef CONFIG_DEBUG_FS	mwifiex_dev_debugfs_init(priv);#endif	return dev;}