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 device
Return Value:
NONE
Note:
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;
}
VOID RTMP_CFG80211_VirtualIF_Init(
IN VOID *pAdSrc,
IN CHAR *pDevName,
IN UINT32 DevType)
{
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pAdSrc;
RTMP_OS_NETDEV_OP_HOOK netDevHook, *pNetDevOps;
PNET_DEV new_dev_p;
#ifdef RT_CFG80211_P2P_SUPPORT
APCLI_STRUCT *pApCliEntry;
#endif /* RT_CFG80211_P2P_SUPPORT */
struct wifi_dev *wdev;
CHAR preIfName[12];
UINT devNameLen = strlen(pDevName);
UINT preIfIndex = pDevName[devNameLen-1] - 48;
CFG80211_CB *p80211CB = pAd->pCfg80211_CB;
struct wireless_dev *pWdev;
UINT32 MC_RowID = 0, IoctlIF = 0, Inf = INT_P2P;
memset(preIfName, 0, sizeof(preIfName));
NdisCopyMemory(preIfName, pDevName, devNameLen-1);
pNetDevOps=&netDevHook;
DBGPRINT(RT_DEBUG_TRACE, ("%s ---> (%s, %s, %d)\n", __FUNCTION__, pDevName, preIfName, preIfIndex));
/* init operation functions and flags */
NdisZeroMemory(&netDevHook, sizeof(netDevHook));
netDevHook.open = CFG80211_VirtualIF_Open; /* device opem hook point */
netDevHook.stop = CFG80211_VirtualIF_Close; /* device close hook point */
netDevHook.xmit = CFG80211_VirtualIF_PacketSend; /* hard transmit hook point */
netDevHook.ioctl = CFG80211_VirtualIF_Ioctl; /* ioctl hook point */
#if WIRELESS_EXT >= 12
//netDevHook.iw_handler = (void *)&rt28xx_ap_iw_handler_def;
#endif /* WIRELESS_EXT >= 12 */
new_dev_p = RtmpOSNetDevCreate(MC_RowID, &IoctlIF, Inf, preIfIndex, sizeof(PRTMP_ADAPTER), preIfName);
if (new_dev_p == NULL)
{
/* 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__));
}
/*
* create a new virtual interface with the given name
*/
struct net_device *mwifiex_add_virtual_intf(struct wiphy *wiphy,
char *name,
enum nl80211_iftype type,
u32 *flags,
struct vif_params *params)
{
struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
struct mwifiex_private *priv;
struct net_device *dev;
void *mdev_priv;
struct wireless_dev *wdev;
if (!adapter)
return ERR_PTR(-EFAULT);
switch (type) {
case NL80211_IFTYPE_UNSPECIFIED:
case NL80211_IFTYPE_STATION:
case NL80211_IFTYPE_ADHOC:
priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
if (priv->bss_mode) {
wiphy_err(wiphy,
"cannot create multiple sta/adhoc ifaces\n");
return ERR_PTR(-EINVAL);
}
wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
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;
}