void rtw_macaddr_cfg(u8 *mac_addr)
{
u8 mac[ETH_ALEN];
if (mac_addr == NULL)
return;
if (rtw_initmac && mac_pton(rtw_initmac, mac)) {
/* Users specify the mac address */
memcpy(mac_addr, mac, ETH_ALEN);
} else {
/* Use the mac address stored in the Efuse */
memcpy(mac, mac_addr, ETH_ALEN);
}
if (((mac[0] == 0xff) && (mac[1] == 0xff) && (mac[2] == 0xff) &&
(mac[3] == 0xff) && (mac[4] == 0xff) && (mac[5] == 0xff)) ||
((mac[0] == 0x0) && (mac[1] == 0x0) && (mac[2] == 0x0) &&
(mac[3] == 0x0) && (mac[4] == 0x0) && (mac[5] == 0x0))) {
mac[0] = 0x00;
mac[1] = 0xe0;
mac[2] = 0x4c;
mac[3] = 0x87;
mac[4] = 0x00;
mac[5] = 0x00;
/* use default mac address */
memcpy(mac_addr, mac, ETH_ALEN);
DBG_88E("MAC Address from efuse error, assign default one !!!\n");
}
DBG_88E("rtw_macaddr_cfg MAC Address = %pM\n", (mac_addr));
}
static int __init dns323_read_mac_addr(void)
{
u_int8_t addr[6];
void __iomem *mac_page;
/* MAC address is stored as a regular ol' string in /dev/mtdblock4
* (0x007d0000-0x00800000) starting at offset 196480 (0x2ff80).
*/
mac_page = ioremap(DNS323_NOR_BOOT_BASE + 0x7d0000 + 196480, 1024);
if (!mac_page)
return -ENOMEM;
if (!mac_pton((__force const char *) mac_page, addr))
goto error_fail;
iounmap(mac_page);
printk("DNS-323: Found ethernet MAC address: %pM\n", addr);
memcpy(dns323_eth_data.mac_addr, addr, 6);
return 0;
error_fail:
iounmap(mac_page);
return -EINVAL;
}
static void __init cpmac_get_mac(int instance, unsigned char *dev_addr)
{
char name[5], *mac;
sprintf(name, "mac%c", 'a' + instance);
mac = prom_getenv(name);
if (!mac && instance) {
sprintf(name, "mac%c", 'a');
mac = prom_getenv(name);
}
if (mac) {
if (!mac_pton(mac, dev_addr)) {
pr_warn("cannot parse mac address, using random address\n");
eth_random_addr(dev_addr);
}
} else
eth_random_addr(dev_addr);
}
static ssize_t store_pch_mac(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
u8 mac[ETH_ALEN];
ssize_t rom_size;
struct pch_phub_reg *chip = dev_get_drvdata(dev);
int ret;
if (!mac_pton(buf, mac))
return -EINVAL;
chip->pch_phub_extrom_base_address = pci_map_rom(chip->pdev, &rom_size);
if (!chip->pch_phub_extrom_base_address)
return -ENOMEM;
ret = pch_phub_write_gbe_mac_addr(chip, mac);
pci_unmap_rom(chip->pdev, chip->pch_phub_extrom_base_address);
if (ret)
return ret;
return count;
}
void rtw_macaddr_cfg(u8 *mac_addr)
{
if (mac_addr == NULL)
return;
if ( rtw_initmac )
{
// Users specify the mac address
if (mac_pton(rtw_initmac, mac_addr))
return;
}
else {
if (!is_zero_mac_addr(mac_addr) &&
!is_broadcast_mac_addr(mac_addr))
return;
}
// use default mac addresss
copy_mac_addr(mac_addr, (u8 []){0x00, 0xe0, 0x4c, 0x87, 0x00, 0x00});
DBG_871X("MAC Address from efuse error, assign default one !!!\n");
DBG_871X("rtw_macaddr_cfg MAC Address = "MAC_FMT"\n", MAC_ARG(mac_addr));
}
/*
* drv_init() - a device potentially for us
*
* notes: drv_init() is called when the bus driver has located a card for us
* to support. We accept the new device by returning 0.
*/
static int r871xu_drv_init(struct usb_interface *pusb_intf,
const struct usb_device_id *pdid)
{
uint status;
struct _adapter *padapter = NULL;
struct dvobj_priv *pdvobjpriv;
struct net_device *pnetdev;
struct usb_device *udev;
/* In this probe function, O.S. will provide the usb interface pointer
* to driver. We have to increase the reference count of the usb device
* structure by using the usb_get_dev function.
*/
udev = interface_to_usbdev(pusb_intf);
usb_get_dev(udev);
pintf = pusb_intf;
/* step 1. */
pnetdev = r8712_init_netdev();
if (!pnetdev)
goto error;
padapter = netdev_priv(pnetdev);
disable_ht_for_spec_devid(pdid, padapter);
pdvobjpriv = &padapter->dvobjpriv;
pdvobjpriv->padapter = padapter;
padapter->dvobjpriv.pusbdev = udev;
padapter->pusb_intf = pusb_intf;
usb_set_intfdata(pusb_intf, pnetdev);
SET_NETDEV_DEV(pnetdev, &pusb_intf->dev);
pnetdev->dev.type = &wlan_type;
/* step 2. */
padapter->dvobj_init = r8712_usb_dvobj_init;
padapter->dvobj_deinit = r8712_usb_dvobj_deinit;
padapter->halpriv.hal_bus_init = r8712_usb_hal_bus_init;
padapter->dvobjpriv.inirp_init = r8712_usb_inirp_init;
padapter->dvobjpriv.inirp_deinit = r8712_usb_inirp_deinit;
/* step 3.
* initialize the dvobj_priv
*/
if (!padapter->dvobj_init) {
goto error;
} else {
status = padapter->dvobj_init(padapter);
if (status != _SUCCESS)
goto error;
}
/* step 4. */
status = r8712_init_drv_sw(padapter);
if (status == _FAIL)
goto error;
/* step 5. read efuse/eeprom data and get mac_addr */
{
int i, offset;
u8 mac[6];
u8 tmpU1b, AutoloadFail, eeprom_CustomerID;
u8 *pdata = padapter->eeprompriv.efuse_eeprom_data;
tmpU1b = r8712_read8(padapter, EE_9346CR);/*CR9346*/
/* To check system boot selection.*/
dev_info(&udev->dev, "r8712u: Boot from %s: Autoload %s\n",
(tmpU1b & _9356SEL) ? "EEPROM" : "EFUSE",
(tmpU1b & _EEPROM_EN) ? "OK" : "Failed");
/* To check autoload success or not.*/
if (tmpU1b & _EEPROM_EN) {
AutoloadFail = true;
/* The following operations prevent Efuse leakage by
* turning on 2.5V.
*/
tmpU1b = r8712_read8(padapter, EFUSE_TEST + 3);
r8712_write8(padapter, EFUSE_TEST + 3, tmpU1b | 0x80);
msleep(20);
r8712_write8(padapter, EFUSE_TEST + 3,
(tmpU1b & (~BIT(7))));
/* Retrieve Chip version.
* Recognize IC version by Reg0x4 BIT15.
*/
tmpU1b = (u8)((r8712_read32(padapter, PMC_FSM) >> 15) &
0x1F);
if (tmpU1b == 0x3)
padapter->registrypriv.chip_version =
RTL8712_3rdCUT;
else
padapter->registrypriv.chip_version =
(tmpU1b >> 1) + 1;
switch (padapter->registrypriv.chip_version) {
case RTL8712_1stCUT:
case RTL8712_2ndCUT:
case RTL8712_3rdCUT:
break;
default:
padapter->registrypriv.chip_version =
RTL8712_2ndCUT;
break;
}
for (i = 0, offset = 0; i < 128; i += 8, offset++)
r8712_efuse_pg_packet_read(padapter, offset,
&pdata[i]);
if (!r8712_initmac || !mac_pton(r8712_initmac, mac)) {
/* Use the mac address stored in the Efuse
* offset = 0x12 for usb in efuse
*/
ether_addr_copy(mac, &pdata[0x12]);
}
eeprom_CustomerID = pdata[0x52];
switch (eeprom_CustomerID) {
case EEPROM_CID_ALPHA:
padapter->eeprompriv.CustomerID =
RT_CID_819x_ALPHA;
break;
case EEPROM_CID_CAMEO:
padapter->eeprompriv.CustomerID =
RT_CID_819x_CAMEO;
break;
case EEPROM_CID_SITECOM:
padapter->eeprompriv.CustomerID =
RT_CID_819x_Sitecom;
break;
case EEPROM_CID_COREGA:
padapter->eeprompriv.CustomerID =
RT_CID_COREGA;
break;
case EEPROM_CID_Senao:
padapter->eeprompriv.CustomerID =
RT_CID_819x_Senao;
break;
case EEPROM_CID_EDIMAX_BELKIN:
padapter->eeprompriv.CustomerID =
RT_CID_819x_Edimax_Belkin;
break;
case EEPROM_CID_SERCOMM_BELKIN:
padapter->eeprompriv.CustomerID =
RT_CID_819x_Sercomm_Belkin;
break;
case EEPROM_CID_WNC_COREGA:
padapter->eeprompriv.CustomerID =
RT_CID_819x_WNC_COREGA;
break;
case EEPROM_CID_WHQL:
break;
case EEPROM_CID_NetCore:
padapter->eeprompriv.CustomerID =
RT_CID_819x_Netcore;
break;
case EEPROM_CID_CAMEO1:
padapter->eeprompriv.CustomerID =
RT_CID_819x_CAMEO1;
break;
case EEPROM_CID_CLEVO:
padapter->eeprompriv.CustomerID =
RT_CID_819x_CLEVO;
break;
default:
padapter->eeprompriv.CustomerID =
RT_CID_DEFAULT;
break;
}
dev_info(&udev->dev, "r8712u: CustomerID = 0x%.4x\n",
padapter->eeprompriv.CustomerID);
/* Led mode */
switch (padapter->eeprompriv.CustomerID) {
case RT_CID_DEFAULT:
case RT_CID_819x_ALPHA:
case RT_CID_819x_CAMEO:
padapter->ledpriv.LedStrategy = SW_LED_MODE1;
padapter->ledpriv.bRegUseLed = true;
break;
case RT_CID_819x_Sitecom:
padapter->ledpriv.LedStrategy = SW_LED_MODE2;
padapter->ledpriv.bRegUseLed = true;
break;
case RT_CID_COREGA:
case RT_CID_819x_Senao:
padapter->ledpriv.LedStrategy = SW_LED_MODE3;
padapter->ledpriv.bRegUseLed = true;
break;
case RT_CID_819x_Edimax_Belkin:
padapter->ledpriv.LedStrategy = SW_LED_MODE4;
padapter->ledpriv.bRegUseLed = true;
break;
case RT_CID_819x_Sercomm_Belkin:
padapter->ledpriv.LedStrategy = SW_LED_MODE5;
padapter->ledpriv.bRegUseLed = true;
break;
case RT_CID_819x_WNC_COREGA:
padapter->ledpriv.LedStrategy = SW_LED_MODE6;
padapter->ledpriv.bRegUseLed = true;
break;
default:
padapter->ledpriv.LedStrategy = SW_LED_MODE0;
padapter->ledpriv.bRegUseLed = false;
break;
}
} else {
static ssize_t ieee80211_if_parse_tkip_mic_test(
struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
{
struct ieee80211_local *local = sdata->local;
u8 addr[ETH_ALEN];
struct sk_buff *skb;
struct ieee80211_hdr *hdr;
__le16 fc;
if (!mac_pton(buf, addr))
return -EINVAL;
if (!ieee80211_sdata_running(sdata))
return -ENOTCONN;
skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 100);
if (!skb)
return -ENOMEM;
skb_reserve(skb, local->hw.extra_tx_headroom);
hdr = (struct ieee80211_hdr *) skb_put(skb, 24);
memset(hdr, 0, 24);
fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
switch (sdata->vif.type) {
case NL80211_IFTYPE_AP:
fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
/* DA BSSID SA */
memcpy(hdr->addr1, addr, ETH_ALEN);
memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
memcpy(hdr->addr3, sdata->vif.addr, ETH_ALEN);
break;
case NL80211_IFTYPE_STATION:
fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
/* BSSID SA DA */
sdata_lock(sdata);
if (!sdata->u.mgd.associated) {
sdata_unlock(sdata);
dev_kfree_skb(skb);
return -ENOTCONN;
}
memcpy(hdr->addr1, sdata->u.mgd.associated->bssid, ETH_ALEN);
memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
memcpy(hdr->addr3, addr, ETH_ALEN);
sdata_unlock(sdata);
break;
default:
dev_kfree_skb(skb);
return -EOPNOTSUPP;
}
hdr->frame_control = fc;
/*
* Add some length to the test frame to make it look bit more valid.
* The exact contents does not matter since the recipient is required
* to drop this because of the Michael MIC failure.
*/
memset(skb_put(skb, 50), 0, 50);
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_TKIP_MIC_FAILURE;
ieee80211_tx_skb(sdata, skb);
return buflen;
}