static int wlan_device_get_mac_addr(unsigned char *buf)
{
char macaddr[20];
int mac_len = 0;
void *fp;
if (!buf){
pr_err("%s, null parameter !!\n", __func__);
return -EFAULT;
}
fp = dhd_os_open_image(CUSTOMER_MAC_FILE);
if (fp == NULL)
return -EFAULT;
mac_len = dhd_os_get_image_block(macaddr, 17, fp);
if (mac_len < 17)
return -EFAULT;
wlan_mac_addr[0] = (unsigned char)((char2bin(macaddr[0]) << 4) | char2bin(macaddr[1]));
wlan_mac_addr[1] = (unsigned char)((char2bin(macaddr[3]) << 4) | char2bin(macaddr[4]));
wlan_mac_addr[2] = (unsigned char)((char2bin(macaddr[6]) << 4) | char2bin(macaddr[7]));
wlan_mac_addr[3] = (unsigned char)((char2bin(macaddr[9]) << 4) | char2bin(macaddr[10]));
wlan_mac_addr[4] = (unsigned char)((char2bin(macaddr[12]) << 4) | char2bin(macaddr[13]));
wlan_mac_addr[5] = (unsigned char)((char2bin(macaddr[15]) << 4) | char2bin(macaddr[16]));
memcpy(buf, wlan_mac_addr, IFHWADDRLEN);
pr_info("wifi mac: %x:%x:%x:%x:%x:%x\n", wlan_mac_addr[0], wlan_mac_addr[1], wlan_mac_addr[2], wlan_mac_addr[3], wlan_mac_addr[4], wlan_mac_addr[5]);
dhd_os_close_image(fp);
return 0;
}
int wifi_get_mac_addr_intel(unsigned char *buf){
int ret = 0;
int i;
struct file *fp = NULL;
unsigned char c_mac[MAC_ADDRESS_LEN];
char fname[]="/config/wifi/mac.txt";
WL_TRACE(("%s Enter\n", __FUNCTION__));
fp = dhd_os_open_image(fname);
if (fp== NULL){
WL_ERROR(("%s: unable to open %s\n",__FUNCTION__, fname));
return 1;
}
if ( dhd_os_get_image_block(c_mac, MAC_ADDRESS_LEN, fp) != MAC_ADDRESS_LEN ){
WL_ERROR(("%s: Error on reading mac address from %s \n",__FUNCTION__, fname));
dhd_os_close_image(fp);
return 1;
}
dhd_os_close_image(fp);
for (i =0; i< MAC_ADDRESS_LEN ; i+=2){
c_mac[i] = bcm_isdigit(c_mac[i]) ? c_mac[i]-'0' : bcm_toupper(c_mac[i])-'A'+10;
c_mac[i+1] = bcm_isdigit(c_mac[i+1]) ? c_mac[i+1]-'0' : bcm_toupper(c_mac[i+1])-'A'+10;
buf[i/2] = c_mac[i]*16 + c_mac[i+1];
}
WL_TRACE(("%s: read from file mac address: %x:%x:%x:%x:%x:%x\n",
__FUNCTION__, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]));
return ret;
}
static int
dhd_read_mac_from_file(char *fpath, struct ether_addr *addr)
{
void *fp = NULL;
int len;
int ret = -1;
char ethbuf[32] = {0, };
struct ether_addr tmp;
if ( !fpath || !addr )
return -1;
if ((fp = dhd_os_open_image(fpath)) == NULL)
return -1;
len = dhd_os_get_image_block(ethbuf, 32, fp);
if ( len < 17 ) /* mac address format xx:xx:xx:xx:xx:xx */
goto err;
ethbuf[17] = '\0';
if (sscanf(ethbuf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
&tmp.octet[0], &tmp.octet[1], &tmp.octet[2],
&tmp.octet[3], &tmp.octet[4], &tmp.octet[5]) != 6)
goto err;
memcpy(addr, &tmp, sizeof(struct ether_addr));
ret = 0;
err:
dhd_os_close_image(fp);
return ret;
}
int somc_get_mac_address(unsigned char *buf)
{
int ret = -EINVAL;
int len;
unsigned char macaddr_buf[MACADDR_BUF_LEN];
void *fp = NULL;
struct ether_addr eth;
if (!buf)
return -EINVAL;
fp = dhd_os_open_image(MACADDR_PATH);
if (!fp) {
WL_ERROR(("%s: file open error\n", __FUNCTION__));
goto err;
}
len = dhd_os_get_image_block(macaddr_buf, MACADDR_BUF_LEN, fp);
if (len <= 0 || MACADDR_BUF_LEN <= len) {
WL_ERROR(("%s: file read error\n", __FUNCTION__));
goto err;
}
macaddr_buf[len] = '\0';
/* convert mac address */
ret = !bcm_ether_atoe(macaddr_buf, ð);
if (ret) {
WL_ERROR(("%s: convert mac value fail\n", __FUNCTION__));
goto err;
}
memcpy(buf, eth.octet, ETHER_ADDR_LEN);
err:
if (fp)
dhd_os_close_image(fp);
return ret;
}
int
dhd_conf_download_config(dhd_pub_t *dhd)
{
int bcmerror = -1, i;
uint len, len_val;
void * image = NULL;
char * memblock = NULL;
char *bufp, pick[MAXSZ_BUF], *pch, *pick_tmp;
char *pconf_path;
bool conf_file_exists;
pconf_path = dhd->conf_path;
conf_file_exists = ((pconf_path != NULL) && (pconf_path[0] != '\0'));
if (!conf_file_exists)
return (0);
if (conf_file_exists) {
image = dhd_os_open_image(pconf_path);
if (image == NULL) {
printk("%s: Ignore config file %s\n", __FUNCTION__, pconf_path);
goto err;
}
}
memblock = MALLOC(dhd->osh, MAXSZ_CONFIG);
if (memblock == NULL) {
CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
__FUNCTION__, MAXSZ_CONFIG));
goto err;
}
/* Download variables */
if (conf_file_exists) {
len = dhd_os_get_image_block(memblock, MAXSZ_CONFIG, image);
}
if (len > 0 && len < MAXSZ_CONFIG) {
bufp = (char *)memblock;
bufp[len] = 0;
/* Process firmware path */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "fw_path=");
if (len_val) {
memcpy(dhd->conf->fw_path, pick, len_val);
printf("%s: fw_path = %s\n", __FUNCTION__, dhd->conf->fw_path);
}
/* Process nvram path */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "nv_path=");
if (len_val) {
memcpy(dhd->conf->nv_path, pick, len_val);
printf("%s: nv_path = %s\n", __FUNCTION__, dhd->conf->nv_path);
}
/* Process band */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "band=");
if (len_val) {
if (!strncmp(pick, "b", len_val))
dhd->conf->band = WLC_BAND_2G;
printf("%s: band = %d\n", __FUNCTION__, dhd->conf->band);
}
/* Process country code */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "ccode=");
if (len_val) {
memset(&dhd->conf->cspec, 0, sizeof(wl_country_t));
memcpy(dhd->conf->cspec.country_abbrev, pick, len_val);
memcpy(dhd->conf->cspec.ccode, pick, len_val);
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "regrev=");
if (len_val)
dhd->conf->cspec.rev = (int32)simple_strtol(pick, NULL, 10);
}
/* Process channels */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "channels=");
pick_tmp = pick;
if (len_val) {
pch = bcmstrtok(&pick_tmp, " ,.-", 0);
i=0;
while (pch != NULL && i<WL_NUMCHANNELS) {
dhd->conf->channels.channel[i] = (uint32)simple_strtol(pch, NULL, 10);
pch = bcmstrtok(&pick_tmp, " ,.-", 0);
i++;
}
dhd->conf->channels.count = i;
printf("%s: channels = ", __FUNCTION__);
for (i=0; i<dhd->conf->channels.count; i++)
printf("%d ", dhd->conf->channels.channel[i]);
printf("\n");
}
/* Process roam */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "roam_off=");
if (len_val) {
if (!strncmp(pick, "0", len_val))
dhd->conf->roam_off = 0;
else
dhd->conf->roam_off = 1;
printf("%s: roam_off = %d\n", __FUNCTION__, dhd->conf->roam_off);
}
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "roam_off_suspend=");
if (len_val) {
if (!strncmp(pick, "0", len_val))
dhd->conf->roam_off_suspend = 0;
else
dhd->conf->roam_off_suspend = 1;
printf("%s: roam_off_suspend = %d\n", __FUNCTION__,
dhd->conf->roam_off_suspend);
}
if (!dhd->conf->roam_off || !dhd->conf->roam_off_suspend) {
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "roam_trigger=");
if (len_val)
dhd->conf->roam_trigger[0] = (int)simple_strtol(pick, NULL, 10);
printf("%s: roam_trigger = %d\n", __FUNCTION__,
dhd->conf->roam_trigger[0]);
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "roam_scan_period=");
if (len_val)
dhd->conf->roam_scan_period[0] = (int)simple_strtol(pick, NULL, 10);
printf("%s: roam_scan_period = %d\n", __FUNCTION__,
dhd->conf->roam_scan_period[0]);
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "roam_delta=");
if (len_val)
dhd->conf->roam_delta[0] = (int)simple_strtol(pick, NULL, 10);
printf("%s: roam_delta = %d\n", __FUNCTION__, dhd->conf->roam_delta[0]);
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "fullroamperiod=");
if (len_val)
dhd->conf->fullroamperiod = (int)simple_strtol(pick, NULL, 10);
printf("%s: fullroamperiod = %d\n", __FUNCTION__,
dhd->conf->fullroamperiod);
}
/* Process filter out all packets */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "filter_out_all_packets=");
if (len_val) {
if (!strncmp(pick, "0", len_val))
dhd->conf->filter_out_all_packets = 0;
else
dhd->conf->filter_out_all_packets = 1;
printf("%s: filter_out_all_packets = %d\n", __FUNCTION__,
dhd->conf->filter_out_all_packets);
}
/* Process keep alive period */
memset(pick, 0, MAXSZ_BUF);
len_val = process_config_vars(bufp, len, pick, "keep_alive_period=");
if (len_val) {
dhd->conf->keep_alive_period = (int)simple_strtol(pick, NULL, 10);
printf("%s: keep_alive_period = %d\n", __FUNCTION__,
dhd->conf->keep_alive_period);
}
bcmerror = 0;
} else {
CONFIG_ERROR(("%s: error reading config file: %d\n", __FUNCTION__, len));
bcmerror = BCME_SDIO_ERROR;
}
err:
if (memblock)
MFREE(dhd->osh, memblock, MAXSZ_CONFIG);
if (image)
dhd_os_close_image(image);
return bcmerror;
}
/* Function to get custom MAC address */
int
dhd_custom_get_mac_address(unsigned char *buf)
{
int ret = 0;
WL_TRACE(("%s Enter\n", __FUNCTION__));
if (!buf)
return -EINVAL;
/* Customer access to MAC address stored outside of DHD driver */
#if defined(CUSTOMER_HW2) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
ret = wifi_get_mac_addr(buf);
#endif
//#ifdef EXAMPLE_GET_MAC
/* EXAMPLE code */
{
char text[128];
int len;
void *image = NULL;
char *p_start=NULL;
char text_addr[12];
struct ether_addr ea_example = {{0xc8, 0x56, 0x78, 0x9a, 0xbc, 0xde}};
bcopy((char *)&ea_example, buf, sizeof(struct ether_addr));
buf[4]=random32()&0xff;
buf[5]=random32()&0xff;
image = dhd_os_open_image("/persist/WCNSS_qcom_cfg.ini");
if (image == NULL)
WL_ERROR(("%s can't open wncss config file!!!\n", __FUNCTION__));
/* Download image */
#if defined(NDISVER) && (NDISVER >= 0x0630)
while ((len = dhd_os_get_image_block((char*)text, 127, image, FALSE))) {
#else
while ((len = dhd_os_get_image_block((char*)text, 127, image))) {
#endif /* NDSIVER && (NDISVER >= 0x0680) */
if (len < 0) {
WL_ERROR(("%s get address data failed (%d)\n", __FUNCTION__,len));
goto err;;
}
if(text[0]=='#')
continue;
if ((p_start=strstr(text, "Intf0MacAddress")))
{
if ((p_start=strstr(text, "="))){
scru_ascii_2_hex (p_start+1, 12,text_addr);
memcpy(buf,text_addr,6);
printk("get wifi NV address=%x:%x:%x:%x:%x:%x\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5]);
ret = 0;
break;
}
}
}
err:
if (image){
dhd_os_close_image(image);
}
}
//#endif /* EXAMPLE_GET_MAC */
return ret;
}
#endif /* GET_CUSTOM_MAC_ENABLE */
/* Customized Locale table : OPTIONAL feature */
const struct cntry_locales_custom translate_custom_table[] = {
/* Table should be filled out based on custom platform regulatory requirement */
#ifdef EXAMPLE_TABLE
{"", "XY", 4}, /* Universal if Country code is unknown or empty */
{"US", "US", 69}, /* input ISO "US" to : US regrev 69 */
{"CA", "US", 69}, /* input ISO "CA" to : US regrev 69 */
{"EU", "EU", 5}, /* European union countries to : EU regrev 05 */
{"AT", "EU", 5},
{"BE", "EU", 5},
{"BG", "EU", 5},
{"CY", "EU", 5},
{"CZ", "EU", 5},
{"DK", "EU", 5},
{"EE", "EU", 5},
{"FI", "EU", 5},
{"FR", "EU", 5},
{"DE", "EU", 5},
{"GR", "EU", 5},
{"HU", "EU", 5},
{"IE", "EU", 5},
{"IT", "EU", 5},
{"LV", "EU", 5},
{"LI", "EU", 5},
{"LT", "EU", 5},
{"LU", "EU", 5},
{"MT", "EU", 5},
{"NL", "EU", 5},
{"PL", "EU", 5},
{"PT", "EU", 5},
{"RO", "EU", 5},
{"SK", "EU", 5},
{"SI", "EU", 5},
{"ES", "EU", 5},
{"SE", "EU", 5},
{"GB", "EU", 5},
{"KR", "XY", 3},
{"AU", "XY", 3},
{"CN", "XY", 3}, /* input ISO "CN" to : XY regrev 03 */
{"TW", "XY", 3},
{"AR", "XY", 3},
{"MX", "XY", 3},
{"IL", "IL", 0},
{"CH", "CH", 0},
{"TR", "TR", 0},
{"NO", "NO", 0},
#endif /* EXMAPLE_TABLE */
};
/* Customized Locale convertor
* input : ISO 3166-1 country abbreviation
* output: customized cspec
*/
void get_customized_country_code(char *country_iso_code, wl_country_t *cspec)
{
#if defined(CUSTOMER_HW2) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39))
struct cntry_locales_custom *cloc_ptr;
if (!cspec)
return;
cloc_ptr = wifi_get_country_code(country_iso_code);
if (cloc_ptr) {
strlcpy(cspec->ccode, cloc_ptr->custom_locale, WLC_CNTRY_BUF_SZ);
cspec->rev = cloc_ptr->custom_locale_rev;
}
return;
#else
int size, i;
size = ARRAYSIZE(translate_custom_table);
if (cspec == 0)
return;
if (size == 0)
return;
for (i = 0; i < size; i++) {
if (strcmp(country_iso_code, translate_custom_table[i].iso_abbrev) == 0) {
memcpy(cspec->ccode,
translate_custom_table[i].custom_locale, WLC_CNTRY_BUF_SZ);
cspec->rev = translate_custom_table[i].custom_locale_rev;
return;
}
}
#ifdef EXAMPLE_TABLE
/* if no country code matched return first universal code from translate_custom_table */
memcpy(cspec->ccode, translate_custom_table[0].custom_locale, WLC_CNTRY_BUF_SZ);
cspec->rev = translate_custom_table[0].custom_locale_rev;
#endif /* EXMAPLE_TABLE */
return;
#endif /* defined(CUSTOMER_HW2) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)) */
}
int dhd_preinit_config(dhd_pub_t *dhd, int ifidx)
{
mm_segment_t old_fs;
struct kstat stat;
struct file *fp = NULL;
unsigned int len;
char *buf = NULL, *p, *name, *value;
int ret = 0;
char *config_path;
config_path = CONFIG_BCMDHD_CONFIG_PATH;
if (!config_path)
{
printk(KERN_ERR "config_path can't read. \n");
return 0;
}
old_fs = get_fs();
set_fs(get_ds());
if ((ret = vfs_stat(config_path, &stat))) {
set_fs(old_fs);
printk(KERN_ERR "%s: Failed to get information (%d)\n",
config_path, ret);
return ret;
}
set_fs(old_fs);
if (!(buf = MALLOC(dhd->osh, stat.size + 1))) {
printk(KERN_ERR "Failed to allocate memory %llu bytes\n", stat.size);
return -ENOMEM;
}
printk("dhd_preinit_config : config path : %s \n", config_path);
if (!(fp = dhd_os_open_image(config_path)) ||
(len = dhd_os_get_image_block(buf, stat.size, fp)) < 0)
goto err;
buf[stat.size] = '\0';
for (p = buf; *p; p++) {
if (isspace(*p))
continue;
for (name = p++; *p && !isspace(*p); p++) {
if (*p == '=') {
*p = '\0';
p++;
for (value = p; *p && !isspace(*p); p++);
*p = '\0';
if ((ret = dhd_preinit_proc(dhd, ifidx, name, value)) < 0) {
printk(KERN_ERR "%s: %s=%s\n",
bcmerrorstr(ret), name, value);
}
break;
}
}
}
ret = 0;
out:
if (fp)
dhd_os_close_image(fp);
if (buf)
MFREE(dhd->osh, buf, stat.size+1);
return ret;
err:
ret = -1;
goto out;
}
